| blob | 850df133a429096c08ba83188cf1b417ba96eed7 |
1 include "OptionsBase.td"
3 let Command = "target modules dump symtab" in {
4 def tm_sort : Option<"sort", "s">, Group<1>,
5 Desc<"Supply a sort order when dumping the symbol table.">,
6 EnumArg<"SortOrder", "OptionEnumValues(g_sort_option_enumeration)">;
7 def tm_smn : Option<"show-mangled-names", "m">, Group<1>,
8 Desc<"Do not demangle symbol names before showing them.">;
9 }
11 let Command = "help" in {
12 def help_hide_aliases : Option<"hide-aliases", "a">,
13 Desc<"Hide aliases in the command list.">;
14 def help_hide_user : Option<"hide-user-commands", "u">,
15 Desc<"Hide user-defined commands from the list.">;
16 def help_show_hidden : Option<"show-hidden-commands", "h">,
17 Desc<"Include commands prefixed with an underscore.">;
18 }
20 let Command = "settings set" in {
21 def setset_global : Option<"global", "g">, Arg<"Filename">,
22 Completion<"DiskFile">,
23 Desc<"Apply the new value to the global default value.">;
24 def setset_force : Option<"force", "f">,
25 Desc<"Force an empty value to be accepted as the default.">;
26 }
28 let Command = "settings write" in {
29 def setwrite_file : Option<"file", "f">, Required, Arg<"Filename">,
30 Completion<"DiskFile">,
31 Desc<"The file into which to write the settings.">;
32 def setwrite_append : Option<"append", "a">,
33 Desc<"Append to saved settings file if it exists.">;
34 }
36 let Command = "settings read" in {
37 def setread_file : Option<"file", "f">, Required, Arg<"Filename">,
38 Completion<"DiskFile">,
39 Desc<"The file from which to read the settings.">;
40 }
42 let Command = "breakpoint list" in {
43 // FIXME: We need to add an "internal" command, and then add this sort of
44 // thing to it. But I need to see it for now, and don't want to wait.
45 def blist_internal : Option<"internal", "i">,
46 Desc<"Show debugger internal breakpoints">;
47 def blist_brief : Option<"brief", "b">, Group<1>,
48 Desc<"Give a brief description of the breakpoint (no location info).">;
49 def blist_full : Option<"full", "f">, Group<2>,
50 Desc<"Give a full description of the breakpoint and its locations.">;
51 def blist_verbose : Option<"verbose", "v">, Group<3>,
52 Desc<"Explain everything we know about the breakpoint (for debugging "
53 "debugger bugs).">;
54 def blist_dummy_bp : Option<"dummy-breakpoints", "D">,
55 Desc<"List Dummy breakpoints - i.e. breakpoints set before a file is "
56 "provided, which prime new targets.">;
57 }
59 let Command = "breakpoint modify" in {
60 def breakpoint_modify_ignore_count : Option<"ignore-count", "i">, Group<1>,
61 Arg<"Count">,
62 Desc<"Set the number of times this breakpoint is skipped before stopping.">;
63 def breakpoint_modify_one_shot : Option<"one-shot", "o">, Group<1>,
64 Arg<"Boolean">,
65 Desc<"The breakpoint is deleted the first time it stop causes a stop.">;
66 def breakpoint_modify_thread_index : Option<"thread-index", "x">, Group<1>,
67 Arg<"ThreadIndex">, Desc<"The breakpoint stops only for the thread whose "
68 "index matches this argument.">;
69 def breakpoint_modify_thread_id : Option<"thread-id", "t">, Group<1>,
70 Arg<"ThreadID">, Desc<"The breakpoint stops only for the thread whose TID "
71 "matches this argument.">;
72 def breakpoint_modify_thread_name : Option<"thread-name", "T">, Group<1>,
73 Arg<"ThreadName">, Desc<"The breakpoint stops only for the thread whose "
74 "thread name matches this argument.">;
75 def breakpoint_modify_queue_name : Option<"queue-name", "q">, Group<1>,
76 Arg<"QueueName">, Desc<"The breakpoint stops only for threads in the queue "
77 "whose name is given by this argument.">;
78 def breakpoint_modify_condition : Option<"condition", "c">, Group<1>,
79 Arg<"Expression">, Desc<"The breakpoint stops only if this condition "
80 "expression evaluates to true.">;
81 def breakpoint_modify_auto_continue : Option<"auto-continue", "G">, Group<1>,
82 Arg<"Boolean">,
83 Desc<"The breakpoint will auto-continue after running its commands.">;
84 def breakpoint_modify_enable : Option<"enable", "e">, Group<2>,
85 Desc<"Enable the breakpoint.">;
86 def breakpoint_modify_disable : Option<"disable", "d">, Group<3>,
87 Desc<"Disable the breakpoint.">;
88 def breakpoint_modify_command : Option<"command", "C">, Group<4>,
89 Arg<"Command">,
90 Desc<"A command to run when the breakpoint is hit, can be provided more "
91 "than once, the commands will get run in order left to right.">;
92 }
94 let Command = "breakpoint dummy" in {
95 def breakpoint_dummy_options_dummy_breakpoints :
96 Option<"dummy-breakpoints", "D">, Group<1>,
97 Desc<"Act on Dummy breakpoints - i.e. breakpoints set before a file is "
98 "provided, which prime new targets.">;
99 }
101 let Command = "breakpoint set" in {
102 def breakpoint_set_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
103 Completion<"Module">, Groups<[1,2,3,4,5,6,7,8,9,11]>, // *not* in group 10
104 Desc<"Set the breakpoint only in this shared library. Can repeat this "
105 "option multiple times to specify multiple shared libraries.">;
106 def breakpoint_set_hardware : Option<"hardware", "H">,
107 Desc<"Require the breakpoint to use hardware breakpoints.">;
108 def breakpoint_set_file : Option<"file", "f">, Arg<"Filename">,
109 Completion<"SourceFile">, Groups<[1,3,4,5,6,7,8,9,11]>,
110 Desc<"Specifies the source file in which to set this breakpoint. Note, by "
111 "default lldb only looks for files that are #included if they use the "
112 "standard include file extensions. To set breakpoints on .c/.cpp/.m/.mm "
113 "files that are #included, set target.inline-breakpoint-strategy to "
114 "\"always\".">;
115 def breakpoint_set_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
116 Required,
117 Desc<"Specifies the line number on which to set this breakpoint.">;
118 def breakpoint_set_address : Option<"address", "a">, Group<2>,
119 Arg<"AddressOrExpression">, Required,
120 Desc<"Set the breakpoint at the specified address. If the address maps "
121 "uniquely toa particular binary, then the address will be converted to "
122 "a \"file\"address, so that the breakpoint will track that binary+offset "
123 "no matter where the binary eventually loads. Alternately, if you also "
124 "specify the module - with the -s option - then the address will be "
125 "treated as a file address in that module, and resolved accordingly. "
126 "Again, this will allow lldb to track that offset on subsequent reloads. "
127 " The module need not have been loaded at the time you specify this "
128 "breakpoint, and will get resolved when the module is loaded.">;
129 def breakpoint_set_name : Option<"name", "n">, Group<3>, Arg<"FunctionName">,
130 Completion<"Symbol">, Required,
131 Desc<"Set the breakpoint by function name. Can be repeated multiple times "
132 "to makeone breakpoint for multiple names">;
133 def breakpoint_set_source_regexp_function :
134 Option<"source-regexp-function", "X">, Group<9>, Arg<"FunctionName">,
135 Completion<"Symbol">,
136 Desc<"When used with '-p' limits the source regex to source contained in "
137 "the namedfunctions. Can be repeated multiple times.">;
138 def breakpoint_set_fullname : Option<"fullname", "F">, Group<4>,
139 Arg<"FullName">, Required, Completion<"Symbol">,
140 Desc<"Set the breakpoint by fully qualified function names. For C++ this "
141 "means namespaces and all arguments, and for Objective-C this means a full "
142 "functionprototype with class and selector. Can be repeated multiple times"
143 " to make one breakpoint for multiple names.">;
144 def breakpoint_set_selector : Option<"selector", "S">, Group<5>,
145 Arg<"Selector">, Required,
146 Desc<"Set the breakpoint by ObjC selector name. Can be repeated multiple "
147 "times tomake one breakpoint for multiple Selectors.">;
148 def breakpoint_set_method : Option<"method", "M">, Group<6>, Arg<"Method">,
149 Required, Desc<"Set the breakpoint by C++ method names. Can be repeated "
150 "multiple times tomake one breakpoint for multiple methods.">;
151 def breakpoint_set_func_regex : Option<"func-regex", "r">, Group<7>,
152 Arg<"RegularExpression">, Required, Desc<"Set the breakpoint by function "
153 "name, evaluating a regular-expression to findthe function name(s).">;
154 def breakpoint_set_basename : Option<"basename", "b">, Group<8>,
155 Arg<"FunctionName">, Required, Completion<"Symbol">,
156 Desc<"Set the breakpoint by function basename (C++ namespaces and arguments"
157 " will beignored). Can be repeated multiple times to make one breakpoint "
158 "for multiplesymbols.">;
159 def breakpoint_set_source_pattern_regexp :
160 Option<"source-pattern-regexp", "p">, Group<9>, Arg<"RegularExpression">,
161 Required, Desc<"Set the breakpoint by specifying a regular expression which"
162 " is matched against the source text in a source file or files specified "
163 "with the -f can be specified more than once. If no source files "
164 "are specified, uses the current \"default source file\". If you want to "
165 "match against all source files, pass the \"--all-files\" option.">;
166 def breakpoint_set_all_files : Option<"all-files", "A">, Group<9>,
167 Desc<"All files are searched for source pattern matches.">;
168 def breakpoint_set_language_exception : Option<"language-exception", "E">,
169 Group<10>, Arg<"Language">, Required,
170 Desc<"Set the breakpoint on exceptions thrown by the specified language "
171 "(without options, on throw but not catch.)">;
172 def breakpoint_set_on_throw : Option<"on-throw", "w">, Group<10>,
173 Arg<"Boolean">, Desc<"Set the breakpoint on exception throW.">;
174 def breakpoint_set_on_catch : Option<"on-catch", "h">, Group<10>,
175 Arg<"Boolean">, Desc<"Set the breakpoint on exception catcH.">;
176 def breakpoint_set_language : Option<"language", "L">, GroupRange<3, 8>,
177 Arg<"Language">,
178 Desc<"Specifies the Language to use when interpreting the breakpoint's "
179 "expression (note: currently only implemented for setting breakpoints on "
180 "identifiers). If not set the target.language setting is used.">;
181 def breakpoint_set_skip_prologue : Option<"skip-prologue", "K">,
182 Arg<"Boolean">, Groups<[1,3,4,5,6,7,8]>,
183 Desc<"sKip the prologue if the breakpoint is at the beginning of a "
184 "function. If not set the target.skip-prologue setting is used.">;
185 def breakpoint_set_breakpoint_name : Option<"breakpoint-name", "N">,
186 Arg<"BreakpointName">,
187 Desc<"Adds this to the list of names for this breakpoint.">;
188 def breakpoint_set_address_slide : Option<"address-slide", "R">,
189 Arg<"Address">, Groups<[1,3,4,5,6,7,8]>,
190 Desc<"Add the specified offset to whatever address(es) the breakpoint "
191 "resolves to. At present this applies the offset directly as given, and "
192 "doesn't try to align it to instruction boundaries.">;
193 def breakpoint_set_move_to_nearest_code : Option<"move-to-nearest-code", "m">,
194 Groups<[1, 9]>, Arg<"Boolean">,
195 Desc<"Move breakpoints to nearest code. If not set the "
196 "target.move-to-nearest-codesetting is used.">;
197 /* Don't add this option till it actually does something useful...
198 def breakpoint_set_exception_typename : Option<"exception-typename", "O">,
199 Arg<"TypeName">, Desc<"The breakpoint will only stop if an "
200 "exception Object of this type is thrown. Can be repeated multiple times "
201 "to stop for multiple object types">;
202 */
203 }
205 let Command = "breakpoint clear" in {
206 def breakpoint_clear_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
207 Completion<"SourceFile">,
208 Desc<"Specify the breakpoint by source location in this particular file.">;
209 def breakpoint_clear_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
210 Required,
211 Desc<"Specify the breakpoint by source location at this particular line.">;
212 }
214 let Command = "breakpoint delete" in {
215 def breakpoint_delete_force : Option<"force", "f">, Group<1>,
216 Desc<"Delete all breakpoints without querying for confirmation.">;
217 def breakpoint_delete_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
218 Group<1>, Desc<"Delete Dummy breakpoints - i.e. breakpoints set before a "
219 "file is provided, which prime new targets.">;
220 }
222 let Command = "breakpoint name" in {
223 def breakpoint_name_name : Option<"name", "N">, Group<1>,
224 Arg<"BreakpointName">, Desc<"Specifies a breakpoint name to use.">;
225 def breakpoint_name_breakpoint_id : Option<"breakpoint-id", "B">, Group<2>,
226 Arg<"BreakpointID">, Desc<"Specify a breakpoint ID to use.">;
227 def breakpoint_name_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
228 Group<3>, Desc<"Operate on Dummy breakpoints - i.e. breakpoints set before "
229 "a file is provided, which prime new targets.">;
230 def breakpoint_name_help_string : Option<"help-string", "H">, Group<4>,
231 Arg<"None">, Desc<"A help string describing the purpose of this name.">;
232 }
234 let Command = "breakpoint access" in {
235 def breakpoint_access_allow_list : Option<"allow-list", "L">, Group<1>,
236 Arg<"Boolean">, Desc<"Determines whether the breakpoint will show up in "
237 "break list if not referred to explicitly.">;
238 def breakpoint_access_allow_disable : Option<"allow-disable", "A">, Group<2>,
239 Arg<"Boolean">, Desc<"Determines whether the breakpoint can be disabled by "
240 "name or when all breakpoints are disabled.">;
241 def breakpoint_access_allow_delete : Option<"allow-delete", "D">, Group<3>,
242 Arg<"Boolean">, Desc<"Determines whether the breakpoint can be deleted by "
243 "name or when all breakpoints are deleted.">;
244 }
246 let Command = "breakpoint read" in {
247 def breakpoint_read_file : Option<"file", "f">, Arg<"Filename">, Required,
248 Completion<"DiskFile">,
249 Desc<"The file from which to read the breakpoints.">;
250 def breakpoint_read_breakpoint_name : Option<"breakpoint-name", "N">,
251 Arg<"BreakpointName">, Desc<"Only read in breakpoints with this name.">;
252 }
254 let Command = "breakpoint write" in {
255 def breakpoint_write_file : Option<"file", "f">, Arg<"Filename">, Required,
256 Completion<"DiskFile">,
257 Desc<"The file into which to write the breakpoints.">;
258 def breakpoint_write_append : Option<"append", "a">,
259 Desc<"Append to saved breakpoints file if it exists.">;
260 }
262 let Command = "breakpoint command add" in {
263 def breakpoint_add_one_liner : Option<"one-liner", "o">, Group<1>,
264 Arg<"OneLiner">, Desc<"Specify a one-line breakpoint command inline. Be "
265 "sure to surround it with quotes.">;
266 def breakpoint_add_stop_on_error : Option<"stop-on-error", "e">,
267 Arg<"Boolean">, Desc<"Specify whether breakpoint command execution should "
268 "terminate on error.">;
269 def breakpoint_add_script_type : Option<"script-type", "s">,
270 EnumArg<"None", "ScriptOptionEnum()">,
271 Desc<"Specify the language for the commands - if none is specified, the "
272 "lldb command interpreter will be used.">;
273 def breakpoint_add_dummy_breakpoints : Option<"dummy-breakpoints", "D">,
274 Desc<"Sets Dummy breakpoints - i.e. breakpoints set before a file is "
275 "provided, which prime new targets.">;
276 }
278 let Command = "breakpoint command delete" in {
279 def breakpoint_command_delete_dummy_breakpoints :
280 Option<"dummy-breakpoints", "D">, Group<1>,
281 Desc<"Delete commands from Dummy breakpoints - i.e. breakpoints set before "
282 "a file is provided, which prime new targets.">;
283 }
285 let Command = "disassemble" in {
286 def disassemble_options_bytes : Option<"bytes", "b">,
287 Desc<"Show opcode bytes when disassembling.">;
288 def disassemble_options_context : Option<"context", "C">, Arg<"NumLines">,
289 Desc<"Number of context lines of source to show.">;
290 def disassemble_options_mixed : Option<"mixed", "m">,
291 Desc<"Enable mixed source and assembly display.">;
292 def disassemble_options_raw : Option<"raw", "r">,
293 Desc<"Print raw disassembly with no symbol information.">;
294 def disassemble_options_plugin : Option<"plugin", "P">, Arg<"Plugin">,
295 Desc<"Name of the disassembler plugin you want to use.">;
296 def disassemble_options_flavor : Option<"flavor", "F">,
297 Arg<"DisassemblyFlavor">, Desc<"Name of the disassembly flavor you want to "
298 "use. Currently the only valid options are default, and for Intel "
299 "architectures, att and intel.">;
300 def disassemble_options_arch : Option<"arch", "A">, Arg<"Architecture">,
301 Desc<"Specify the architecture to use from cross disassembly.">;
302 def disassemble_options_start_address : Option<"start-address", "s">,
303 Groups<[1,2]>, Arg<"AddressOrExpression">, Required,
304 Desc<"Address at which to start disassembling.">;
305 def disassemble_options_end_address : Option<"end-address", "e">, Group<1>,
306 Arg<"AddressOrExpression">, Desc<"Address at which to end disassembling.">;
307 def disassemble_options_count : Option<"count", "c">, Groups<[2,3,4,5]>,
308 Arg<"NumLines">, Desc<"Number of instructions to display.">;
309 def disassemble_options_name : Option<"name", "n">, Group<3>,
310 Arg<"FunctionName">, Completion<"Symbol">,
311 Desc<"Disassemble entire contents of the given function name.">;
312 def disassemble_options_frame : Option<"frame", "f">, Group<4>,
313 Desc<"Disassemble from the start of the current frame's function.">;
314 def disassemble_options_pc : Option<"pc", "p">, Group<5>,
315 Desc<"Disassemble around the current pc.">;
316 def disassemble_options_line : Option<"line", "l">, Group<6>,
317 Desc<"Disassemble the current frame's current source line instructions if"
318 "there is debug line table information, else disassemble around the pc.">;
319 def disassemble_options_address : Option<"address", "a">, Group<7>,
320 Arg<"AddressOrExpression">,
321 Desc<"Disassemble function containing this address.">;
322 }
324 let Command = "expression" in {
325 def expression_options_all_threads : Option<"all-threads", "a">,
326 Groups<[1,2]>, Arg<"Boolean">, Desc<"Should we run all threads if the "
327 "execution doesn't complete on one thread.">;
328 def expression_options_ignore_breakpoints : Option<"ignore-breakpoints", "i">,
329 Groups<[1,2]>, Arg<"Boolean">,
330 Desc<"Ignore breakpoint hits while running expressions">;
331 def expression_options_timeout : Option<"timeout", "t">, Groups<[1,2]>,
332 Arg<"UnsignedInteger">,
333 Desc<"Timeout value (in microseconds) for running the expression.">;
334 def expression_options_unwind_on_error : Option<"unwind-on-error", "u">,
335 Groups<[1,2]>, Arg<"Boolean">,
336 Desc<"Clean up program state if the expression causes a crash, or raises a "
337 "signal. Note, unlike gdb hitting a breakpoint is controlled by another "
338 "option (-i).">;
339 def expression_options_debug : Option<"debug", "g">, Groups<[1,2]>,
340 Desc<"When specified, debug the JIT code by setting a breakpoint on the "
341 "first instruction and forcing breakpoints to not be ignored (-i0) and no "
342 "unwinding to happen on error (-u0).">;
343 def expression_options_language : Option<"language", "l">, Groups<[1,2]>,
344 Arg<"Language">, Desc<"Specifies the Language to use when parsing the "
345 "expression. If not set the target.language setting is used.">;
346 def expression_options_apply_fixits : Option<"apply-fixits", "X">,
347 Groups<[1,2]>, Arg<"Language">, Desc<"If true, simple fix-it hints will be "
348 "automatically applied to the expression.">;
349 def expression_options_description_verbosity :
350 Option<"description-verbosity", "v">, Group<1>,
351 OptionalEnumArg<"DescriptionVerbosity", "DescriptionVerbosityTypes()">,
352 Desc<"How verbose should the output of this expression be, if the object "
353 "description is asked for.">;
354 def expression_options_top_level : Option<"top-level", "p">, Groups<[1,2]>,
355 Desc<"Interpret the expression as a complete translation unit, without "
356 "injecting it into the local context. Allows declaration of persistent, "
357 "top-level entities without a $ prefix.">;
358 def expression_options_allow_jit : Option<"allow-jit", "j">, Groups<[1,2]>,
359 Arg<"Boolean">,
360 Desc<"Controls whether the expression can fall back to being JITted if it's"
361 "not supported by the interpreter (defaults to true).">;
362 }
364 let Command = "frame diag" in {
365 def frame_diag_register : Option<"register", "r">, Group<1>,
366 Arg<"RegisterName">, Desc<"A register to diagnose.">;
367 def frame_diag_address : Option<"address", "a">, Group<1>, Arg<"Address">,
368 Desc<"An address to diagnose.">;
369 def frame_diag_offset : Option<"offset", "o">, Group<1>, Arg<"Offset">,
370 Desc<"An optional offset. Requires --register.">;
371 }
373 let Command = "frame select" in {
374 def frame_select_relative : Option<"relative", "r">, Group<1>, Arg<"Offset">,
375 Desc<"A relative frame index offset from the current frame index.">;
376 }
378 let Command = "frame recognizer add" in {
379 def frame_recognizer_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
380 Completion<"Module">,
381 Desc<"Name of the module or shared library that this recognizer applies "
382 "to.">;
383 def frame_recognizer_function : Option<"function", "n">, Arg<"Name">,
384 Completion<"Symbol">,
385 Desc<"Name of the function that this recognizer applies to.">;
386 def frame_recognizer_python_class : Option<"python-class", "l">, Group<2>,
387 Arg<"PythonClass">,
388 Desc<"Give the name of a Python class to use for this frame recognizer.">;
389 def frame_recognizer_regex : Option<"regex", "x">,
390 Desc<"Function name and module name are actually regular expressions.">;
391 }
393 let Command = "history" in {
394 def history_count : Option<"count", "c">, Group<1>, Arg<"UnsignedInteger">,
395 Desc<"How many history commands to print.">;
396 def history_start_index : Option<"start-index", "s">, Group<1>,
397 Arg<"UnsignedInteger">, Desc<"Index at which to start printing history "
398 "commands (or end to mean tail mode).">;
399 def history_end_index : Option<"end-index", "e">, Group<1>,
400 Arg<"UnsignedInteger">,
401 Desc<"Index at which to stop printing history commands.">;
402 def history_clear : Option<"clear", "C">, Group<2>,
403 Desc<"Clears the current command history.">;
404 }
406 let Command = "log" in {
407 def log_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
408 Desc<"Set the destination file to log to.">;
409 def log_threadsafe : Option<"threadsafe", "t">, Group<1>,
410 Desc<"Enable thread safe logging to avoid interweaved log lines.">;
411 def log_verbose : Option<"verbose", "v">, Group<1>,
412 Desc<"Enable verbose logging.">;
413 def log_sequence : Option<"sequence", "s">, Group<1>,
414 Desc<"Prepend all log lines with an increasing integer sequence id.">;
415 def log_timestamp : Option<"timestamp", "T">, Group<1>,
416 Desc<"Prepend all log lines with a timestamp.">;
417 def log_pid_tid : Option<"pid-tid", "p">, Group<1>,
418 Desc<"Prepend all log lines with the process and thread ID that generates "
419 "the log line.">;
420 def log_thread_name : Option<"thread-name", "n">, Group<1>,
421 Desc<"Prepend all log lines with the thread name for the thread that "
422 "generates the log line.">;
424 def log_stack : Option<"stack", "S">, Group<1>,
425 Desc<"Append a stack backtrace to each log line.">;
426 def log_append : Option<"append", "a">, Group<1>,
427 Desc<"Append to the log file instead of overwriting.">;
428 def log_file_function : Option<"file-function", "F">, Group<1>,
429 Desc<"Prepend the names of files and function that generate the logs.">;
430 }
432 let Command = "reproducer dump" in {
433 def reproducer_provider : Option<"provider", "p">, Group<1>,
434 EnumArg<"None", "ReproducerProviderType()">,
435 Required, Desc<"The reproducer provider to dump.">;
436 def reproducer_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
437 Desc<"The reproducer path. If a reproducer is replayed and no path is "
438 "provided, that reproducer is dumped.">;
439 }
441 let Command = "reproducer xcrash" in {
442 def reproducer_signal : Option<"signal", "s">, Group<1>,
443 EnumArg<"None", "ReproducerSignalType()">,
444 Required, Desc<"The signal to crash the debugger.">;
445 }
447 let Command = "memory read" in {
448 def memory_read_num_per_line : Option<"num-per-line", "l">, Group<1>,
449 Arg<"NumberPerLine">, Desc<"The number of items per line to display.">;
450 def memory_read_binary : Option<"binary", "b">, Group<2>,
451 Desc<"If true, memory will be saved as binary. If false, the memory is "
452 "saved save as an ASCII dump that uses the format, size, count and number "
453 "per line settings.">;
454 def memory_read_type : Option<"type", "t">, Groups<[3,4]>, Arg<"Name">,
455 Required, Desc<"The name of a type to view memory as.">;
456 def memory_read_language : Option<"language", "x">, Group<4>, Arg<"Language">,
457 Desc<"The language of the type to view memory as.">;
458 def memory_read_offset : Option<"offset", "E">, Group<3>, Arg<"Count">,
459 Desc<"How many elements of the specified type to skip before starting to "
460 "display data.">;
461 def memory_read_force : Option<"force", "r">, Groups<[1,2,3]>,
462 Desc<"Necessary if reading over target.max-memory-read-size bytes.">;
463 }
465 let Command = "memory find" in {
466 def memory_find_expression : Option<"expression", "e">, Group<1>,
467 Arg<"Expression">, Required,
468 Desc<"Evaluate an expression to obtain a byte pattern.">;
469 def memory_find_string : Option<"string", "s">, Group<2>, Arg<"Name">,
470 Required, Desc<"Use text to find a byte pattern.">;
471 def memory_find_count : Option<"count", "c">, Arg<"Count">,
472 Desc<"How many times to perform the search.">;
473 def memory_find_dump_offset : Option<"dump-offset", "o">, Arg<"Offset">,
474 Desc<"When dumping memory for a match, an offset from the match location to"
475 " start dumping from.">;
476 }
478 let Command = "memory write" in {
479 def memory_write_infile : Option<"infile", "i">, Group<1>, Arg<"Filename">,
480 Required, Desc<"Write memory using the contents of a file.">;
481 def memory_write_offset : Option<"offset", "o">, Group<1>, Arg<"Offset">,
482 Desc<"Start writing bytes from an offset within the input file.">;
483 }
485 let Command = "register read" in {
486 def register_read_alternate : Option<"alternate", "A">,
487 Desc<"Display register names using the alternate register name if there "
488 "is one.">;
489 def register_read_set : Option<"set", "s">, Group<1>, Arg<"Index">,
490 Desc<"Specify which register sets to dump by index.">;
491 def register_read_all : Option<"all", "a">, Group<2>,
492 Desc<"Show all register sets.">;
493 }
495 let Command = "source" in {
496 def source_stop_on_error : Option<"stop-on-error", "e">, Arg<"Boolean">,
497 Desc<"If true, stop executing commands on error.">;
498 def source_stop_on_continue : Option<"stop-on-continue", "c">, Arg<"Boolean">,
499 Desc<"If true, stop executing commands on continue.">;
500 def source_silent_run : Option<"silent-run", "s">, Arg<"Boolean">,
501 Desc<"If true don't echo commands while executing.">;
502 }
504 let Command = "alias" in {
505 def alias_help : Option<"help", "h">, Arg<"HelpText">,
506 Desc<"Help text for this command">;
507 def alias_long_help : Option<"long-help", "H">, Arg<"HelpText">,
508 Desc<"Long help text for this command">;
509 }
511 let Command = "regex" in {
512 def regex_help : Option<"help", "h">, Group<1>, Arg<"None">,
513 Desc<"The help text to display for this command.">;
514 def regex_syntax : Option<"syntax", "s">, Group<1>, Arg<"None">,
515 Desc<"A syntax string showing the typical usage syntax.">;
516 }
518 let Command = "permissions" in {
519 def permissions_permissions_value : Option<"permissions-value", "v">,
520 Arg<"PermissionsNumber">,
521 Desc<"Give out the numeric value for permissions (e.g. 757)">;
522 def permissions_permissions_string : Option<"permissions-string", "s">,
523 Arg<"PermissionsString">,
524 Desc<"Give out the string value for permissions (e.g. rwxr-xr--).">;
525 def permissions_user_read : Option<"user-read", "r">,
526 Desc<"Allow user to read.">;
527 def permissions_user_write : Option<"user-write", "w">,
528 Desc<"Allow user to write.">;
529 def permissions_user_exec : Option<"user-exec", "x">,
530 Desc<"Allow user to execute.">;
531 def permissions_group_read : Option<"group-read", "R">,
532 Desc<"Allow group to read.">;
533 def permissions_group_write : Option<"group-write", "W">,
534 Desc<"Allow group to write.">;
535 def permissions_group_exec : Option<"group-exec", "X">,
536 Desc<"Allow group to execute.">;
537 def permissions_world_read : Option<"world-read", "d">,
538 Desc<"Allow world to read.">;
539 def permissions_world_write : Option<"world-write", "t">,
540 Desc<"Allow world to write.">;
541 def permissions_world_exec : Option<"world-exec", "e">,
542 Desc<"Allow world to execute.">;
543 }
545 let Command = "platform fread" in {
546 def platform_fread_offset : Option<"offset", "o">, Group<1>, Arg<"Index">,
547 Desc<"Offset into the file at which to start reading.">;
548 def platform_fread_count : Option<"count", "c">, Group<1>, Arg<"Count">,
549 Desc<"Number of bytes to read from the file.">;
550 }
552 let Command = "platform fwrite" in {
553 def platform_fwrite_offset : Option<"offset", "o">, Group<1>, Arg<"Index">,
554 Desc<"Offset into the file at which to start reading.">;
555 def platform_fwrite_data : Option<"data", "d">, Group<1>, Arg<"Value">,
556 Desc<"Text to write to the file.">;
557 }
559 let Command = "platform process list" in {
560 def platform_process_list_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
561 Desc<"List the process info for a specific process ID.">;
562 def platform_process_list_name : Option<"name", "n">, Group<2>,
563 Arg<"ProcessName">, Required,
564 Desc<"Find processes with executable basenames that match a string.">;
565 def platform_process_list_ends_with : Option<"ends-with", "e">, Group<3>,
566 Arg<"ProcessName">, Required,
567 Desc<"Find processes with executable basenames that end with a string.">;
568 def platform_process_list_starts_with : Option<"starts-with", "s">, Group<4>,
569 Arg<"ProcessName">, Required,
570 Desc<"Find processes with executable basenames that start with a string.">;
571 def platform_process_list_contains : Option<"contains", "c">, Group<5>,
572 Arg<"ProcessName">, Required,
573 Desc<"Find processes with executable basenames that contain a string.">;
574 def platform_process_list_regex : Option<"regex", "r">, Group<6>,
575 Arg<"RegularExpression">, Required,
576 Desc<"Find processes with executable basenames that match a regular "
577 "expression.">;
578 def platform_process_list_parent : Option<"parent", "P">, GroupRange<2, 6>,
579 Arg<"Pid">, Desc<"Find processes that have a matching parent process ID.">;
580 def platform_process_list_uid : Option<"uid", "u">, GroupRange<2, 6>,
581 Arg<"UnsignedInteger">, Validator<"&posix_validator">,
582 Desc<"Find processes that have a matching user ID.">;
583 def platform_process_list_euid : Option<"euid", "U">, GroupRange<2, 6>,
584 Arg<"UnsignedInteger">, Validator<"&posix_validator">,
585 Desc<"Find processes that have a matching effective user ID.">;
586 def platform_process_list_gid : Option<"gid", "g">, GroupRange<2, 6>,
587 Arg<"UnsignedInteger">, Validator<"&posix_validator">,
588 Desc<"Find processes that have a matching group ID.">;
589 def platform_process_list_egid : Option<"egid", "G">, GroupRange<2, 6>,
590 Arg<"UnsignedInteger">, Validator<"&posix_validator">,
591 Desc<"Find processes that have a matching effective group ID.">;
592 def platform_process_list_arch : Option<"arch", "a">, GroupRange<2, 6>,
593 Arg<"Architecture">,
594 Desc<"Find processes that have a matching architecture.">;
595 def platform_process_list_show_args : Option<"show-args", "A">,
596 GroupRange<1, 6>,
597 Desc<"Show process arguments instead of the process executable basename.">;
598 def platform_process_list_all_users: Option<"all-users", "x">,
599 GroupRange<1,6>,
600 Desc<"Show processes matching all user IDs.">;
601 def platform_process_list_verbose : Option<"verbose", "v">, GroupRange<1, 6>,
602 Desc<"Enable verbose output.">;
603 }
605 let Command = "platform process attach" in {
606 def platform_process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
607 Desc<"Name of the process plugin you want to use.">;
608 def platform_process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
609 Desc<"The process ID of an existing process to attach to.">;
610 def platform_process_attach_name : Option<"name", "n">, Group<2>,
611 Arg<"ProcessName">, Desc<"The name of the process to attach to.">;
612 def platform_process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
613 Desc<"Wait for the process with <process-name> to launch.">;
614 }
616 let Command = "platform shell" in {
617 def platform_shell_timeout : Option<"timeout", "t">, Arg<"Value">,
618 Desc<"Seconds to wait for the remote host to finish running the command.">;
619 }
621 let Command = "process attach" in {
622 def process_attach_continue : Option<"continue", "c">,
623 Desc<"Immediately continue the process once attached.">;
624 def process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
625 Desc<"Name of the process plugin you want to use.">;
626 def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
627 Desc<"The process ID of an existing process to attach to.">;
628 def process_attach_name : Option<"name", "n">, Group<2>, Arg<"ProcessName">,
629 Desc<"The name of the process to attach to.">;
630 def process_attach_include_existing : Option<"include-existing", "i">,
631 Group<2>, Desc<"Include existing processes when doing attach -w.">;
632 def process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
633 Desc<"Wait for the process with <process-name> to launch.">;
634 }
636 let Command = "process continue" in {
637 def process_continue_ignore_count : Option<"ignore-count", "i">,
638 Arg<"UnsignedInteger">, Desc<"Ignore <N> crossings of the breakpoint (if it"
639 " exists) for the currently selected thread.">;
640 }
642 let Command = "process detach" in {
643 def process_detach_keep_stopped : Option<"keep-stopped", "s">, Group<1>,
644 Arg<"Boolean">, Desc<"Whether or not the process should be kept stopped on"
645 " detach (if possible).">;
646 }
648 let Command = "process connect" in {
649 def process_connect_plugin : Option<"plugin", "p">, Arg<"Plugin">,
650 Desc<"Name of the process plugin you want to use.">;
651 }
653 let Command = "process load" in {
654 def process_load_install : Option<"install", "i">, OptionalArg<"Path">,
655 Desc<"Install the shared library to the target. If specified without an "
656 "argument then the library will installed in the current working "
657 "directory.">;
658 }
660 let Command = "process handle" in {
661 def process_handle_stop : Option<"stop", "s">, Group<1>, Arg<"Boolean">,
662 Desc<"Whether or not the process should be stopped if the signal is "
663 "received.">;
664 def process_handle_notify : Option<"notify", "n">, Group<1>, Arg<"Boolean">,
665 Desc<"Whether or not the debugger should notify the user if the signal is "
666 "received.">;
667 def process_handle_pass : Option<"pass", "p">, Group<1>, Arg<"Boolean">,
668 Desc<"Whether or not the signal should be passed to the process.">;
669 }
671 let Command = "script import" in {
672 def script_import_allow_reload : Option<"allow-reload", "r">, Group<1>,
673 Desc<"Allow the script to be loaded even if it was already loaded before. "
674 "This argument exists for backwards compatibility, but reloading is always "
675 "allowed, whether you specify it or not.">;
676 }
678 let Command = "script add" in {
679 def script_add_function : Option<"function", "f">, Group<1>,
680 Arg<"PythonFunction">,
681 Desc<"Name of the Python function to bind to this command name.">;
682 def script_add_class : Option<"class", "c">, Group<2>, Arg<"PythonClass">,
683 Desc<"Name of the Python class to bind to this command name.">;
684 def script_add_help : Option<"help", "h">, Group<1>, Arg<"HelpText">,
685 Desc<"The help text to display for this command.">;
686 def script_add_synchronicity : Option<"synchronicity", "s">,
687 EnumArg<"ScriptedCommandSynchronicity", "ScriptSynchroType()">,
688 Desc<"Set the synchronicity of this command's executions with regard to "
689 "LLDB event system.">;
690 }
691 let Command = "source info" in {
692 def source_info_count : Option<"count", "c">, Arg<"Count">,
693 Desc<"The number of line entries to display.">;
694 def source_info_shlib : Option<"shlib", "s">, Groups<[1,2]>, Arg<"ShlibName">,
695 Completion<"Module">, Desc<"Look up the source in the given module or "
696 "shared library (can be specified more than once).">;
697 def source_info_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
698 Completion<"SourceFile">, Desc<"The file from which to display source.">;
699 def source_info_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
700 Desc<"The line number at which to start the displaying lines.">;
701 def source_info_end_line : Option<"end-line", "e">, Group<1>, Arg<"LineNum">,
702 Desc<"The line number at which to stop displaying lines.">;
703 def source_info_name : Option<"name", "n">, Group<2>, Arg<"Symbol">,
704 Completion<"Symbol">,
705 Desc<"The name of a function whose source to display.">;
706 def source_info_address : Option<"address", "a">, Group<3>,
707 Arg<"AddressOrExpression">, Desc<"Lookup the address and display the source"
708 " information for the corresponding file and line.">;
709 }
711 let Command = "source list" in {
712 def source_list_count : Option<"count", "c">, Arg<"Count">,
713 Desc<"The number of source lines to display.">;
714 def source_list_shlib : Option<"shlib", "s">, Groups<[1,2]>, Arg<"ShlibName">,
715 Completion<"Module">,
716 Desc<"Look up the source file in the given shared library.">;
717 def source_list_show_breakpoints : Option<"show-breakpoints", "b">,
718 Desc<"Show the line table locations from the debug information that "
719 "indicate valid places to set source level breakpoints.">;
720 def source_list_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
721 Completion<"SourceFile">, Desc<"The file from which to display source.">;
722 def source_list_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
723 Desc<"The line number at which to start the display source.">;
724 def source_list_name : Option<"name", "n">, Group<2>, Arg<"Symbol">,
725 Completion<"Symbol">,
726 Desc<"The name of a function whose source to display.">;
727 def source_list_address : Option<"address", "a">, Group<3>,
728 Arg<"AddressOrExpression">, Desc<"Lookup the address and display the source"
729 " information for the corresponding file and line.">;
730 def source_list_reverse : Option<"reverse", "r">, Group<4>, Desc<"Reverse the"
731 " listing to look backwards from the last displayed block of source.">;
732 }
734 let Command = "target dependents" in {
735 def dependents_no_dependents : Option<"no-dependents", "d">, Group<1>,
736 OptionalEnumArg<"Value", "OptionEnumValues(g_dependents_enumaration)">,
737 Desc<"Whether or not to load dependents when creating a target. If the "
738 "option is not specified, the value is implicitly 'default'. If the "
739 "option is specified but without a value, the value is implicitly "
740 "'true'.">;
741 }
743 let Command = "target modules dump" in {
744 def target_modules_dump_verbose : Option<"verbose", "v">,
745 Desc<"Enable verbose dump.">;
746 }
748 let Command = "target modules list" in {
749 def target_modules_list_address : Option<"address", "a">, Group<1>,
750 Arg<"AddressOrExpression">, Desc<"Display the image at this address.">;
751 def target_modules_list_arch : Option<"arch", "A">, Group<1>,
752 OptionalArg<"Width">, Desc<"Display the architecture when listing images.">;
753 def target_modules_list_triple : Option<"triple", "t">, Group<1>,
754 OptionalArg<"Width">, Desc<"Display the triple when listing images.">;
755 def target_modules_list_header : Option<"header", "h">, Group<1>,
756 Desc<"Display the image base address as a load address if debugging, a file"
757 " address otherwise.">;
758 def target_modules_list_offset : Option<"offset", "o">, Group<1>,
759 Desc<"Display the image load address offset from the base file address "
760 "(the slide amount).">;
761 def target_modules_list_uuid : Option<"uuid", "u">, Group<1>,
762 Desc<"Display the UUID when listing images.">;
763 def target_modules_list_fullpath : Option<"fullpath", "f">, Group<1>,
764 OptionalArg<"Width">,
765 Desc<"Display the fullpath to the image object file.">;
766 def target_modules_list_directory : Option<"directory", "d">, Group<1>,
767 OptionalArg<"Width">, Desc<"Display the directory with optional width for "
768 "the image object file.">;
769 def target_modules_list_basename : Option<"basename", "b">, Group<1>,
770 OptionalArg<"Width">, Desc<"Display the basename with optional width for "
771 "the image object file.">;
772 def target_modules_list_symfile : Option<"symfile", "s">, Group<1>,
773 OptionalArg<"Width">, Desc<"Display the fullpath to the image symbol file "
774 "with optional width.">;
775 def target_modules_list_symfile_unique : Option<"symfile-unique", "S">,
776 Group<1>, OptionalArg<"Width">, Desc<"Display the symbol file with optional"
777 " width only if it is different from the executable object file.">;
778 def target_modules_list_mod_time : Option<"mod-time", "m">, Group<1>,
779 OptionalArg<"Width">, Desc<"Display the modification time with optional "
780 "width of the module.">;
781 def target_modules_list_ref_count : Option<"ref-count", "r">, Group<1>,
782 OptionalArg<"Width">, Desc<"Display the reference count if the module is "
783 "still in the shared module cache.">;
784 def target_modules_list_pointer : Option<"pointer", "p">, Group<1>,
785 OptionalArg<"None">, Desc<"Display the module pointer.">;
786 def target_modules_list_global : Option<"global", "g">, Group<1>,
787 Desc<"Display the modules from the global module list, not just the "
788 "current target.">;
789 }
791 let Command = "target modules show unwind" in {
792 def target_modules_show_unwind_name : Option<"name", "n">, Group<1>,
793 Arg<"FunctionName">,
794 Desc<"Show unwind instructions for a function or symbol name.">;
795 def target_modules_show_unwind_address : Option<"address", "a">, Group<2>,
796 Arg<"AddressOrExpression">, Desc<"Show unwind instructions for a function "
797 "or symbol containing an address">;
798 }
800 let Command = "target modules lookup" in {
801 def target_modules_lookup_address : Option<"address", "a">, Group<1>,
802 Arg<"AddressOrExpression">, Required, Desc<"Lookup an address in one or "
803 "more target modules.">;
804 def target_modules_lookup_offset : Option<"offset", "o">, Group<1>,
805 Arg<"Offset">, Desc<"When looking up an address subtract <offset> from any "
806 "addresses before doing the lookup.">;
807 // FIXME: re-enable regex for types when the LookupTypeInModule actually uses
808 // the regex option by adding to group 6.
809 def target_modules_lookup_regex : Option<"regex", "r">, Groups<[2,4,5]>,
810 Desc<"The <name> argument for name lookups are regular expressions.">;
811 def target_modules_lookup_symbol : Option<"symbol", "s">, Group<2>,
812 Arg<"Symbol">, Required, Desc<"Lookup a symbol by name in the symbol tables"
813 " in one or more target modules.">;
814 def target_modules_lookup_file : Option<"file", "f">, Group<3>,
815 Arg<"Filename">, Required, Desc<"Lookup a file by fullpath or basename in "
816 "one or more target modules.">;
817 def target_modules_lookup_line : Option<"line", "l">, Group<3>,
818 Arg<"LineNum">, Desc<"Lookup a line number in a file (must be used in "
819 "conjunction with --file).">;
820 def target_modules_lookup_no_inlines : Option<"no-inlines", "i">,
821 GroupRange<3,5>,
822 Desc<"Ignore inline entries (must be used in conjunction with --file or "
823 "--function).">;
824 def target_modules_lookup_function : Option<"function", "F">, Group<4>,
825 Arg<"FunctionName">, Required, Desc<"Lookup a function by name in the debug"
826 " symbols in one or more target modules.">;
827 def target_modules_lookup_name : Option<"name", "n">, Group<5>,
828 Arg<"FunctionOrSymbol">, Required, Desc<"Lookup a function or symbol by "
829 "name in one or more target modules.">;
830 def target_modules_lookup_type : Option<"type", "t">, Group<6>, Arg<"Name">,
831 Required, Desc<"Lookup a type by name in the debug symbols in one or more "
832 "target modules.">;
833 def target_modules_lookup_verbose : Option<"verbose", "v">,
834 Desc<"Enable verbose lookup information.">;
835 def target_modules_lookup_all : Option<"all", "A">, Desc<"Print all matches, "
836 "not just the best match, if a best match is available.">;
837 }
839 let Command = "target stop hook add" in {
840 def target_stop_hook_add_one_liner : Option<"one-liner", "o">,
841 Arg<"OneLiner">, Desc<"Add a command for the stop hook. Can be specified "
842 "more than once, and commands will be run in the order they appear.">;
843 def target_stop_hook_add_shlib : Option<"shlib", "s">, Arg<"ShlibName">,
844 Completion<"Module">,
845 Desc<"Set the module within which the stop-hook is to be run.">;
846 def target_stop_hook_add_thread_index : Option<"thread-index", "x">,
847 Arg<"ThreadIndex">, Desc<"The stop hook is run only for the thread whose "
848 "index matches this argument.">;
849 def target_stop_hook_add_thread_id : Option<"thread-id", "t">,
850 Arg<"ThreadID">, Desc<"The stop hook is run only for the thread whose TID "
851 "matches this argument.">;
852 def target_stop_hook_add_thread_name : Option<"thread-name", "T">,
853 Arg<"ThreadName">, Desc<"The stop hook is run only for the thread whose "
854 "thread name matches this argument.">;
855 def target_stop_hook_add_queue_name : Option<"queue-name", "q">,
856 Arg<"QueueName">, Desc<"The stop hook is run only for threads in the queue "
857 "whose name is given by this argument.">;
858 def target_stop_hook_add_file : Option<"file", "f">, Group<1>,
859 Arg<"Filename">, Desc<"Specify the source file within which the stop-hook "
860 "is to be run.">, Completion<"SourceFile">;
861 def target_stop_hook_add_start_line : Option<"start-line", "l">, Group<1>,
862 Arg<"LineNum">, Desc<"Set the start of the line range for which the "
863 "stop-hook is to be run.">;
864 def target_stop_hook_add_end_line : Option<"end-line", "e">, Group<1>,
865 Arg<"LineNum">, Desc<"Set the end of the line range for which the stop-hook"
866 " is to be run.">;
867 def target_stop_hook_add_classname : Option<"classname", "c">, Group<2>,
868 Arg<"ClassName">,
869 Desc<"Specify the class within which the stop-hook is to be run.">;
870 def target_stop_hook_add_name : Option<"name", "n">, Group<3>,
871 Arg<"FunctionName">, Desc<"Set the function name within which the stop hook"
872 " will be run.">, Completion<"Symbol">;
873 def target_stop_hook_add_auto_continue : Option<"auto-continue", "G">,
874 Arg<"Boolean">, Desc<"The breakpoint will auto-continue after running its"
875 " commands.">;
876 }
878 let Command = "thread backtrace" in {
879 def thread_backtrace_count : Option<"count", "c">, Group<1>, Arg<"Count">,
880 Desc<"How many frames to display (-1 for all)">;
881 def thread_backtrace_start : Option<"start", "s">, Group<1>,
882 Arg<"FrameIndex">, Desc<"Frame in which to start the backtrace">;
883 def thread_backtrace_extended : Option<"extended", "e">, Group<1>,
884 Arg<"Boolean">, Desc<"Show the extended backtrace, if available">;
885 }
887 let Command = "thread step scope" in {
888 def thread_step_scope_step_in_avoids_no_debug :
889 Option<"step-in-avoids-no-debug", "a">, Group<1>, Arg<"Boolean">,
890 Desc<"A boolean value that sets whether stepping into functions will step "
891 "over functions with no debug information.">;
892 def thread_step_scope_step_out_avoids_no_debug :
893 Option<"step-out-avoids-no-debug", "A">, Group<1>, Arg<"Boolean">,
894 Desc<"A boolean value, if true stepping out of functions will continue to"
895 " step out till it hits a function with debug information.">;
896 def thread_step_scope_count : Option<"count", "c">, Group<1>, Arg<"Count">,
897 Desc<"How many times to perform the stepping operation - currently only "
898 "supported for step-inst and next-inst.">;
899 def thread_step_scope_end_linenumber : Option<"end-linenumber", "e">,
900 Group<1>, Arg<"LineNum">, Desc<"The line at which to stop stepping - "
901 "defaults to the next line and only supported for step-in and step-over."
902 " You can also pass the string 'block' to step to the end of the current"
903 " block. This is particularly use in conjunction with --step-target to"
904 " step through a complex calling sequence.">;
905 def thread_step_scope_run_mode : Option<"run-mode", "m">, Group<1>,
906 EnumArg<"RunMode", "TriRunningModes()">, Desc<"Determine how to run other "
907 "threads while stepping the current thread.">;
908 def thread_step_scope_step_over_regexp : Option<"step-over-regexp", "r">,
909 Group<1>, Arg<"RegularExpression">, Desc<"A regular expression that defines"
910 "function names to not to stop at when stepping in.">;
911 def thread_step_scope_step_in_target : Option<"step-in-target", "t">,
912 Group<1>, Arg<"FunctionName">, Desc<"The name of the directly called "
913 "function step in should stop at when stepping into.">;
914 }
916 let Command = "thread until" in {
917 def thread_until_frame : Option<"frame", "f">, Group<1>, Arg<"FrameIndex">,
918 Desc<"Frame index for until operation - defaults to 0">;
919 def thread_until_thread : Option<"thread", "t">, Group<1>, Arg<"ThreadIndex">,
920 Desc<"Thread index for the thread for until operation">;
921 def thread_until_run_mode : Option<"run-mode", "m">, Group<1>,
922 EnumArg<"RunMode", "DuoRunningModes()">, Desc<"Determine how to run other"
923 "threads while stepping this one">;
924 def thread_until_address : Option<"address", "a">, Group<1>,
925 Arg<"AddressOrExpression">, Desc<"Run until we reach the specified address,"
926 "or leave the function - can be specified multiple times.">;
927 }
929 let Command = "thread info" in {
930 def thread_info_json : Option<"json", "j">, Desc<"Display the thread info in"
931 " JSON format.">;
932 def thread_info_stop_info : Option<"stop-info", "s">, Desc<"Display the "
933 "extended stop info in JSON format.">;
934 }
936 let Command = "thread return" in {
937 def thread_return_from_expression : Option<"from-expression", "x">,
938 Desc<"Return from the innermost expression evaluation.">;
939 }
941 let Command = "thread jump" in {
942 def thread_jump_file : Option<"file", "f">, Group<1>, Arg<"Filename">,
943 Completion<"SourceFile">, Desc<"Specifies the source file to jump to.">;
944 def thread_jump_line : Option<"line", "l">, Group<1>, Arg<"LineNum">,
945 Required, Desc<"Specifies the line number to jump to.">;
946 def thread_jump_by : Option<"by", "b">, Group<2>, Arg<"Offset">, Required,
947 Desc<"Jumps by a relative line offset from the current line.">;
948 def thread_jump_address : Option<"address", "a">, Group<3>,
949 Arg<"AddressOrExpression">, Required, Desc<"Jumps to a specific address.">;
950 def thread_jump_force : Option<"force", "r">, Groups<[1,2,3]>,
951 Desc<"Allows the PC to leave the current function.">;
952 }
954 let Command = "thread plan list" in {
955 def thread_plan_list_verbose : Option<"verbose", "v">, Group<1>,
956 Desc<"Display more information about the thread plans">;
957 def thread_plan_list_internal : Option<"internal", "i">, Group<1>,
958 Desc<"Display internal as well as user thread plans">;
959 }
961 let Command = "type summary add" in {
962 def type_summary_add_category : Option<"category", "w">, Arg<"Name">,
963 Desc<"Add this to the given category instead of the default one.">;
964 def type_summary_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
965 Desc<"If true, cascade through typedef chains.">;
966 def type_summary_add_no_value : Option<"no-value", "v">,
967 Desc<"Don't show the value, just show the summary, for this type.">;
968 def type_summary_add_skip_pointers : Option<"skip-pointers", "p">,
969 Desc<"Don't use this format for pointers-to-type objects.">;
970 def type_summary_add_skip_references : Option<"skip-references", "r">,
971 Desc<"Don't use this format for references-to-type objects.">;
972 def type_summary_add_regex : Option<"regex", "x">,
973 Desc<"Type names are actually regular expressions.">;
974 def type_summary_add_inline_children : Option<"inline-children", "c">,
975 Group<1>, Required,
976 Desc<"If true, inline all child values into summary string.">;
977 def type_summary_add_omit_names : Option<"omit-names", "O">, Group<1>,
978 Desc<"If true, omit value names in the summary display.">;
979 def type_summary_add_summary_string : Option<"summary-string", "s">, Group<2>,
980 Arg<"SummaryString">, Required,
981 Desc<"Summary string used to display text and object contents.">;
982 def type_summary_add_python_script : Option<"python-script", "o">, Group<3>,
983 Arg<"PythonScript">,
984 Desc<"Give a one-liner Python script as part of the command.">;
985 def type_summary_add_python_function : Option<"python-function", "F">,
986 Group<3>, Arg<"PythonFunction">,
987 Desc<"Give the name of a Python function to use for this type.">;
988 def type_summary_add_input_python : Option<"input-python", "P">, Group<3>,
989 Desc<"Input Python code to use for this type manually.">;
990 def type_summary_add_expand : Option<"expand", "e">, Groups<[2,3]>,
991 Desc<"Expand aggregate data types to show children on separate lines.">;
992 def type_summary_add_hide_empty : Option<"hide-empty", "h">, Groups<[2,3]>,
993 Desc<"Do not expand aggregate data types with no children.">;
994 def type_summary_add_name : Option<"name", "n">, Groups<[2,3]>, Arg<"Name">,
995 Desc<"A name for this summary string.">;
996 }
998 let Command = "type synth add" in {
999 def type_synth_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1000 Desc<"If true, cascade through typedef chains.">;
1001 def type_synth_add_skip_pointers : Option<"skip-pointers", "p">,
1002 Desc<"Don't use this format for pointers-to-type objects.">;
1003 def type_synth_add_skip_references : Option<"skip-references", "r">,
1004 Desc<"Don't use this format for references-to-type objects.">;
1005 def type_synth_add_category : Option<"category", "w">, Arg<"Name">,
1006 Desc<"Add this to the given category instead of the default one.">;
1007 def type_synth_add_python_class : Option<"python-class", "l">, Group<2>,
1008 Arg<"PythonClass">,
1009 Desc<"Use this Python class to produce synthetic children.">;
1010 def type_synth_add_input_python : Option<"input-python", "P">, Group<3>,
1011 Desc<"Type Python code to generate a class that provides synthetic "
1012 "children.">;
1013 def type_synth_add_regex : Option<"regex", "x">,
1014 Desc<"Type names are actually regular expressions.">;
1015 }
1017 let Command = "type format add" in {
1018 def type_format_add_category : Option<"category", "w">, Arg<"Name">,
1019 Desc<"Add this to the given category instead of the default one.">;
1020 def type_format_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1021 Desc<"If true, cascade through typedef chains.">;
1022 def type_format_add_skip_pointers : Option<"skip-pointers", "p">,
1023 Desc<"Don't use this format for pointers-to-type objects.">;
1024 def type_format_add_skip_references : Option<"skip-references", "r">,
1025 Desc<"Don't use this format for references-to-type objects.">;
1026 def type_format_add_regex : Option<"regex", "x">,
1027 Desc<"Type names are actually regular expressions.">;
1028 def type_format_add_type : Option<"type", "t">, Group<2>, Arg<"Name">,
1029 Desc<"Format variables as if they were of this type.">;
1030 }
1032 let Command = "type formatter delete" in {
1033 def type_formatter_delete_all : Option<"all", "a">, Group<1>,
1034 Desc<"Delete from every category.">;
1035 def type_formatter_delete_category : Option<"category", "w">, Group<2>,
1036 Arg<"Name">, Desc<"Delete from given category.">;
1037 def type_formatter_delete_language : Option<"language", "l">, Group<3>,
1038 Arg<"Language">, Desc<"Delete from given language's category.">;
1039 }
1041 let Command = "type formatter clear" in {
1042 def type_formatter_clear_all : Option<"all", "a">,
1043 Desc<"Clear every category.">;
1044 }
1046 let Command = "type formatter list" in {
1047 def type_formatter_list_category_regex : Option<"category-regex", "w">,
1048 Group<1>, Arg<"Name">, Desc<"Only show categories matching this filter.">;
1049 def type_formatter_list_language : Option<"language", "l">, Group<2>,
1050 Arg<"Language">, Desc<"Only show the category for a specific language.">;
1051 }
1053 let Command = "type category define" in {
1054 def type_category_define_enabled : Option<"enabled", "e">,
1055 Desc<"If specified, this category will be created enabled.">;
1056 def type_category_define_language : Option<"language", "l">, Arg<"Language">,
1057 Desc<"Specify the language that this category is supported for.">;
1058 }
1060 let Command = "type category enable" in {
1061 def type_category_enable_language : Option<"language", "l">, Arg<"Language">,
1062 Desc<"Enable the category for this language.">;
1063 }
1065 let Command = "type category disable" in {
1066 def type_category_disable_language : Option<"language", "l">, Arg<"Language">,
1067 Desc<"Enable the category for this language.">;
1068 }
1070 let Command = "type filter add" in {
1071 def type_filter_add_cascade : Option<"cascade", "C">, Arg<"Boolean">,
1072 Desc<"If true, cascade through typedef chains.">;
1073 def type_filter_add_skip_pointers : Option<"skip-pointers", "p">,
1074 Desc<"Don't use this format for pointers-to-type objects.">;
1075 def type_filter_add_skip_references : Option<"skip-references", "r">,
1076 Desc<"Don't use this format for references-to-type objects.">;
1077 def type_filter_add_category : Option<"category", "w">, Arg<"Name">,
1078 Desc<"Add this to the given category instead of the default one.">;
1079 def type_filter_add_child : Option<"child", "c">, Arg<"ExpressionPath">,
1080 Desc<"Include this expression path in the synthetic view.">;
1081 def type_filter_add_regex : Option<"regex", "x">,
1082 Desc<"Type names are actually regular expressions.">;
1083 }
1085 let Command = "type lookup" in {
1086 def type_lookup_show_help : Option<"show-help", "h">,
1087 Desc<"Display available help for types">;
1088 def type_lookup_language : Option<"language", "l">, Arg<"Language">,
1089 Desc<"Which language's types should the search scope be">;
1090 }
1092 let Command = "watchpoint list" in {
1093 def watchpoint_list_brief : Option<"brief", "b">, Group<1>, Desc<"Give a "
1094 "brief description of the watchpoint (no location info).">;
1095 def watchpoint_list_full : Option<"full", "f">, Group<2>, Desc<"Give a full "
1096 "description of the watchpoint and its locations.">;
1097 def watchpoint_list_verbose : Option<"verbose", "v">, Group<3>, Desc<"Explain"
1098 "everything we know about the watchpoint (for debugging debugger bugs).">;
1099 }
1101 let Command = "watchpoint ignore" in {
1102 def watchpoint_ignore_ignore_count : Option<"ignore-count", "i">,
1103 Arg<"Count">, Required, Desc<"Set the number of times this watchpoint is"
1104 " skipped before stopping.">;
1105 }
1107 let Command = "watchpoint modify" in {
1108 def watchpoint_modify_condition : Option<"condition", "c">, Arg<"Expression">,
1109 Desc<"The watchpoint stops only if this condition expression evaluates "
1110 "to true.">;
1111 }
1113 let Command = "watchpoint command add" in {
1114 def watchpoint_command_add_one_liner : Option<"one-liner", "o">, Group<1>,
1115 Arg<"OneLiner">, Desc<"Specify a one-line watchpoint command inline. Be "
1116 "sure to surround it with quotes.">;
1117 def watchpoint_command_add_stop_on_error : Option<"stop-on-error", "e">,
1118 Arg<"Boolean">, Desc<"Specify whether watchpoint command execution should "
1119 "terminate on error.">;
1120 def watchpoint_command_add_script_type : Option<"script-type", "s">,
1121 EnumArg<"None", "ScriptOptionEnum()">, Desc<"Specify the language for the"
1122 " commands - if none is specified, the lldb command interpreter will be "
1123 "used.">;
1124 def watchpoint_command_add_python_function : Option<"python-function", "F">,
1125 Group<2>, Arg<"PythonFunction">, Desc<"Give the name of a Python function "
1126 "to run as command for this watchpoint. Be sure to give a module name if "
1127 "appropriate.">;
1128 }
1130 let Command = "watchpoint delete" in {
1131 def watchpoint_delete_force : Option<"force", "f">, Group<1>,
1132 Desc<"Delete all watchpoints without querying for confirmation.">;
1133 }