gen/tools/lldb/source/Commands/CommandOptions.inc

reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Options for LLDB command line commands.                                    *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

// Options for alias
#ifdef LLDB_OPTIONS_alias
constexpr static OptionDefinition g_alias_options[] = {
  {LLDB_OPT_SET_ALL, false, "help", 'h', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeHelpText, "Help text for this command"},
  {LLDB_OPT_SET_ALL, false, "long-help", 'H', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeHelpText, "Long help text for this command"},
};
#undef LLDB_OPTIONS_alias
#endif // alias command

// Options for breakpoint access
#ifdef LLDB_OPTIONS_breakpoint_access
constexpr static OptionDefinition g_breakpoint_access_options[] = {
  {LLDB_OPT_SET_3, false, "allow-delete", 'D', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Determines whether the breakpoint can be deleted by name or when all breakpoints are deleted."},
  {LLDB_OPT_SET_2, false, "allow-disable", 'A', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Determines whether the breakpoint can be disabled by name or when all breakpoints are disabled."},
  {LLDB_OPT_SET_1, false, "allow-list", 'L', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Determines whether the breakpoint will show up in break list if not referred to explicitly."},
};
#undef LLDB_OPTIONS_breakpoint_access
#endif // breakpoint access command

// Options for breakpoint clear
#ifdef LLDB_OPTIONS_breakpoint_clear
constexpr static OptionDefinition g_breakpoint_clear_options[] = {
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the breakpoint by source location in this particular file."},
  {LLDB_OPT_SET_1, true, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Specify the breakpoint by source location at this particular line."},
};
#undef LLDB_OPTIONS_breakpoint_clear
#endif // breakpoint clear command

// Options for breakpoint command add
#ifdef LLDB_OPTIONS_breakpoint_command_add
constexpr static OptionDefinition g_breakpoint_command_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
  {LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOneLiner, "Specify a one-line breakpoint command inline. Be sure to surround it with quotes."},
  {LLDB_OPT_SET_ALL, false, "script-type", 's', OptionParser::eRequiredArgument, nullptr, ScriptOptionEnum(), CommandCompletions::eNoCompletion, eArgTypeNone, "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
  {LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Specify whether breakpoint command execution should terminate on error."},
};
#undef LLDB_OPTIONS_breakpoint_command_add
#endif // breakpoint command add command

// Options for breakpoint command delete
#ifdef LLDB_OPTIONS_breakpoint_command_delete
constexpr static OptionDefinition g_breakpoint_command_delete_options[] = {
  {LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Delete commands from Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
};
#undef LLDB_OPTIONS_breakpoint_command_delete
#endif // breakpoint command delete command

// Options for breakpoint delete
#ifdef LLDB_OPTIONS_breakpoint_delete
constexpr static OptionDefinition g_breakpoint_delete_options[] = {
  {LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Delete Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
  {LLDB_OPT_SET_1, false, "force", 'f', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Delete all breakpoints without querying for confirmation."},
};
#undef LLDB_OPTIONS_breakpoint_delete
#endif // breakpoint delete command

// Options for breakpoint dummy
#ifdef LLDB_OPTIONS_breakpoint_dummy
constexpr static OptionDefinition g_breakpoint_dummy_options[] = {
  {LLDB_OPT_SET_1, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Act on Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
};
#undef LLDB_OPTIONS_breakpoint_dummy
#endif // breakpoint dummy command

// Options for breakpoint list
#ifdef LLDB_OPTIONS_breakpoint_list
constexpr static OptionDefinition g_breakpoint_list_options[] = {
  {LLDB_OPT_SET_1, false, "brief", 'b', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Give a brief description of the breakpoint (no location info)."},
  {LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "List Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
  {LLDB_OPT_SET_2, false, "full", 'f', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Give a full description of the breakpoint and its locations."},
  {LLDB_OPT_SET_ALL, false, "internal", 'i', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show debugger internal breakpoints"},
  {LLDB_OPT_SET_3, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Explain everything we know about the breakpoint (for debugging debugger bugs)."},
};
#undef LLDB_OPTIONS_breakpoint_list
#endif // breakpoint list command

// Options for breakpoint modify
#ifdef LLDB_OPTIONS_breakpoint_modify
constexpr static OptionDefinition g_breakpoint_modify_options[] = {
  {LLDB_OPT_SET_1, false, "auto-continue", 'G', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "The breakpoint will auto-continue after running its commands."},
  {LLDB_OPT_SET_4, false, "command", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCommand, "A command to run when the breakpoint is hit, can be provided more than once, the commands will get run in order left to right."},
  {LLDB_OPT_SET_1, false, "condition", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeExpression, "The breakpoint stops only if this condition expression evaluates to true."},
  {LLDB_OPT_SET_3, false, "disable", 'd', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Disable the breakpoint."},
  {LLDB_OPT_SET_2, false, "enable", 'e', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable the breakpoint."},
  {LLDB_OPT_SET_1, false, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "Set the number of times this breakpoint is skipped before stopping."},
  {LLDB_OPT_SET_1, false, "one-shot", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "The breakpoint is deleted the first time it stop causes a stop."},
  {LLDB_OPT_SET_1, false, "queue-name", 'q', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeQueueName, "The breakpoint stops only for threads in the queue whose name is given by this argument."},
  {LLDB_OPT_SET_1, false, "thread-id", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadID, "The breakpoint stops only for the thread whose TID matches this argument."},
  {LLDB_OPT_SET_1, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadIndex, "The breakpoint stops only for the thread whose index matches this argument."},
  {LLDB_OPT_SET_1, false, "thread-name", 'T', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadName, "The breakpoint stops only for the thread whose thread name matches this argument."},
};
#undef LLDB_OPTIONS_breakpoint_modify
#endif // breakpoint modify command

// Options for breakpoint name
#ifdef LLDB_OPTIONS_breakpoint_name
constexpr static OptionDefinition g_breakpoint_name_options[] = {
  {LLDB_OPT_SET_2, false, "breakpoint-id", 'B', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBreakpointID, "Specify a breakpoint ID to use."},
  {LLDB_OPT_SET_3, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Operate on Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
  {LLDB_OPT_SET_4, false, "help-string", 'H', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "A help string describing the purpose of this name."},
  {LLDB_OPT_SET_1, false, "name", 'N', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBreakpointName, "Specifies a breakpoint name to use."},
};
#undef LLDB_OPTIONS_breakpoint_name
#endif // breakpoint name command

// Options for breakpoint read
#ifdef LLDB_OPTIONS_breakpoint_read
constexpr static OptionDefinition g_breakpoint_read_options[] = {
  {LLDB_OPT_SET_ALL, false, "breakpoint-name", 'N', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBreakpointName, "Only read in breakpoints with this name."},
  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename, "The file from which to read the breakpoints."},
};
#undef LLDB_OPTIONS_breakpoint_read
#endif // breakpoint read command

// Options for breakpoint set
#ifdef LLDB_OPTIONS_breakpoint_set
constexpr static OptionDefinition g_breakpoint_set_options[] = {
  {LLDB_OPT_SET_2, true, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Set the breakpoint at the specified address.  If the address maps uniquely toa particular binary, then the address will be converted to a \22file\22address, 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."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6 | LLDB_OPT_SET_7 | LLDB_OPT_SET_8, false, "address-slide", 'R', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddress, "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."},
  {LLDB_OPT_SET_9, false, "all-files", 'A', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "All files are searched for source pattern matches."},
  {LLDB_OPT_SET_8, true, "basename", 'b', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the breakpoint by function basename (C++ namespaces and arguments will beignored).  Can be repeated multiple times to make one breakpoint for multiplesymbols."},
  {LLDB_OPT_SET_ALL, false, "breakpoint-name", 'N', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBreakpointName, "Adds this to the list of names for this breakpoint."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6 | LLDB_OPT_SET_7 | LLDB_OPT_SET_8 | LLDB_OPT_SET_9 | LLDB_OPT_SET_11, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "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 \22always\22."},
  {LLDB_OPT_SET_4, true, "fullname", 'F', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFullName, "Set the breakpoint by fully qualified function names. For C++ this means namespaces and all arguments, and for Objective-C this means a full functionprototype with class and selector.  Can be repeated multiple times to make one breakpoint for multiple names."},
  {LLDB_OPT_SET_7, true, "func-regex", 'r', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeRegularExpression, "Set the breakpoint by function name, evaluating a regular-expression to findthe function name(s)."},
  {LLDB_OPT_SET_ALL, false, "hardware", 'H', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Require the breakpoint to use hardware breakpoints."},
  {LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6 | LLDB_OPT_SET_7 | LLDB_OPT_SET_8, false, "language", 'L', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "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."},
  {LLDB_OPT_SET_10, true, "language-exception", 'E', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Set the breakpoint on exceptions thrown by the specified language (without options, on throw but not catch.)"},
  {LLDB_OPT_SET_1, true, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Specifies the line number on which to set this breakpoint."},
  {LLDB_OPT_SET_6, true, "method", 'M', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeMethod, "Set the breakpoint by C++ method names.  Can be repeated multiple times tomake one breakpoint for multiple methods."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_9, false, "move-to-nearest-code", 'm', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Move breakpoints to nearest code. If not set the target.move-to-nearest-codesetting is used."},
  {LLDB_OPT_SET_3, true, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the breakpoint by function name.  Can be repeated multiple times to makeone breakpoint for multiple names"},
  {LLDB_OPT_SET_10, false, "on-catch", 'h', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Set the breakpoint on exception catcH."},
  {LLDB_OPT_SET_10, false, "on-throw", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Set the breakpoint on exception throW."},
  {LLDB_OPT_SET_5, true, "selector", 'S', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeSelector, "Set the breakpoint by ObjC selector name. Can be repeated multiple times tomake one breakpoint for multiple Selectors."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6 | LLDB_OPT_SET_7 | LLDB_OPT_SET_8 | LLDB_OPT_SET_9 | LLDB_OPT_SET_11, false, "shlib", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Set the breakpoint only in this shared library.  Can repeat this option multiple times to specify multiple shared libraries."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6 | LLDB_OPT_SET_7 | LLDB_OPT_SET_8, false, "skip-prologue", 'K', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "sKip the prologue if the breakpoint is at the beginning of a function. If not set the target.skip-prologue setting is used."},
  {LLDB_OPT_SET_9, true, "source-pattern-regexp", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeRegularExpression, "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 \22default source file\22.  If you want to match against all source files, pass the \22--all-files\22 option."},
  {LLDB_OPT_SET_9, false, "source-regexp-function", 'X', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "When used with '-p' limits the source regex to source contained in the namedfunctions.  Can be repeated multiple times."},
};
#undef LLDB_OPTIONS_breakpoint_set
#endif // breakpoint set command

// Options for breakpoint write
#ifdef LLDB_OPTIONS_breakpoint_write
constexpr static OptionDefinition g_breakpoint_write_options[] = {
  {LLDB_OPT_SET_ALL, false, "append", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Append to saved breakpoints file if it exists."},
  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename, "The file into which to write the breakpoints."},
};
#undef LLDB_OPTIONS_breakpoint_write
#endif // breakpoint write command

// Options for disassemble
#ifdef LLDB_OPTIONS_disassemble
constexpr static OptionDefinition g_disassemble_options[] = {
  {LLDB_OPT_SET_7, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Disassemble function containing this address."},
  {LLDB_OPT_SET_ALL, false, "arch", 'A', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeArchitecture, "Specify the architecture to use from cross disassembly."},
  {LLDB_OPT_SET_ALL, false, "bytes", 'b', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show opcode bytes when disassembling."},
  {LLDB_OPT_SET_ALL, false, "context", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNumLines, "Number of context lines of source to show."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNumLines, "Number of instructions to display."},
  {LLDB_OPT_SET_1, false, "end-address", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Address at which to end disassembling."},
  {LLDB_OPT_SET_ALL, false, "flavor", 'F', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeDisassemblyFlavor, "Name of the disassembly flavor you want to use. Currently the only valid options are default, and for Intel architectures, att and intel."},
  {LLDB_OPT_SET_4, false, "frame", 'f', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Disassemble from the start of the current frame's function."},
  {LLDB_OPT_SET_6, false, "line", 'l', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Disassemble the current frame's current source line instructions ifthere is debug line table information, else disassemble around the pc."},
  {LLDB_OPT_SET_ALL, false, "mixed", 'm', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable mixed source and assembly display."},
  {LLDB_OPT_SET_3, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Disassemble entire contents of the given function name."},
  {LLDB_OPT_SET_5, false, "pc", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Disassemble around the current pc."},
  {LLDB_OPT_SET_ALL, false, "plugin", 'P', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePlugin, "Name of the disassembler plugin you want to use."},
  {LLDB_OPT_SET_ALL, false, "raw", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Print raw disassembly with no symbol information."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, true, "start-address", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Address at which to start disassembling."},
};
#undef LLDB_OPTIONS_disassemble
#endif // disassemble command

// Options for expression
#ifdef LLDB_OPTIONS_expression
constexpr static OptionDefinition g_expression_options[] = {
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "all-threads", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Should we run all threads if the execution doesn't complete on one thread."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "allow-jit", 'j', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Controls whether the expression can fall back to being JITted if it'snot supported by the interpreter (defaults to true)."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "apply-fixits", 'X', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "If true, simple fix-it hints will be automatically applied to the expression."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug", 'g', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "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)."},
  {LLDB_OPT_SET_1, false, "description-verbosity", 'v', OptionParser::eOptionalArgument, nullptr, DescriptionVerbosityTypes(), CommandCompletions::eNoCompletion, eArgTypeDescriptionVerbosity, "How verbose should the output of this expression be, if the object description is asked for."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "ignore-breakpoints", 'i', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Ignore breakpoint hits while running expressions"},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Specifies the Language to use when parsing the expression.  If not set the target.language setting is used."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Timeout value (in microseconds) for running the expression."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "top-level", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "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."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error", 'u', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "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)."},
};
#undef LLDB_OPTIONS_expression
#endif // expression command

// Options for frame diag
#ifdef LLDB_OPTIONS_frame_diag
constexpr static OptionDefinition g_frame_diag_options[] = {
  {LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddress, "An address to diagnose."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "An optional offset.  Requires --register."},
  {LLDB_OPT_SET_1, false, "register", 'r', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeRegisterName, "A register to diagnose."},
};
#undef LLDB_OPTIONS_frame_diag
#endif // frame diag command

// Options for frame recognizer add
#ifdef LLDB_OPTIONS_frame_recognizer_add
constexpr static OptionDefinition g_frame_recognizer_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "function", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeName, "Name of the function that this recognizer applies to."},
  {LLDB_OPT_SET_2, false, "python-class", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonClass, "Give the name of a Python class to use for this frame recognizer."},
  {LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Function name and module name are actually regular expressions."},
  {LLDB_OPT_SET_ALL, false, "shlib", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Name of the module or shared library that this recognizer applies to."},
};
#undef LLDB_OPTIONS_frame_recognizer_add
#endif // frame recognizer add command

// Options for frame select
#ifdef LLDB_OPTIONS_frame_select
constexpr static OptionDefinition g_frame_select_options[] = {
  {LLDB_OPT_SET_1, false, "relative", 'r', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "A relative frame index offset from the current frame index."},
};
#undef LLDB_OPTIONS_frame_select
#endif // frame select command

// Options for help
#ifdef LLDB_OPTIONS_help
constexpr static OptionDefinition g_help_options[] = {
  {LLDB_OPT_SET_ALL, false, "hide-aliases", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Hide aliases in the command list."},
  {LLDB_OPT_SET_ALL, false, "hide-user-commands", 'u', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Hide user-defined commands from the list."},
  {LLDB_OPT_SET_ALL, false, "show-hidden-commands", 'h', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Include commands prefixed with an underscore."},
};
#undef LLDB_OPTIONS_help
#endif // help command

// Options for history
#ifdef LLDB_OPTIONS_history
constexpr static OptionDefinition g_history_options[] = {
  {LLDB_OPT_SET_2, false, "clear", 'C', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Clears the current command history."},
  {LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "How many history commands to print."},
  {LLDB_OPT_SET_1, false, "end-index", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Index at which to stop printing history commands."},
  {LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)."},
};
#undef LLDB_OPTIONS_history
#endif // history command

// Options for log
#ifdef LLDB_OPTIONS_log
constexpr static OptionDefinition g_log_options[] = {
  {LLDB_OPT_SET_1, false, "append", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Append to the log file instead of overwriting."},
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFilename, "Set the destination file to log to."},
  {LLDB_OPT_SET_1, false, "file-function", 'F', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Prepend the names of files and function that generate the logs."},
  {LLDB_OPT_SET_1, false, "pid-tid", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Prepend all log lines with the process and thread ID that generates the log line."},
  {LLDB_OPT_SET_1, false, "sequence", 's', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Prepend all log lines with an increasing integer sequence id."},
  {LLDB_OPT_SET_1, false, "stack", 'S', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Append a stack backtrace to each log line."},
  {LLDB_OPT_SET_1, false, "thread-name", 'n', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Prepend all log lines with the thread name for the thread that generates the log line."},
  {LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable thread safe logging to avoid interweaved log lines."},
  {LLDB_OPT_SET_1, false, "timestamp", 'T', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Prepend all log lines with a timestamp."},
  {LLDB_OPT_SET_1, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable verbose logging."},
};
#undef LLDB_OPTIONS_log
#endif // log command

// Options for memory find
#ifdef LLDB_OPTIONS_memory_find
constexpr static OptionDefinition g_memory_find_options[] = {
  {LLDB_OPT_SET_ALL, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "How many times to perform the search."},
  {LLDB_OPT_SET_ALL, false, "dump-offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "When dumping memory for a match, an offset from the match location to start dumping from."},
  {LLDB_OPT_SET_1, true, "expression", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeExpression, "Evaluate an expression to obtain a byte pattern."},
  {LLDB_OPT_SET_2, true, "string", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Use text to find a byte pattern."},
};
#undef LLDB_OPTIONS_memory_find
#endif // memory find command

// Options for memory read
#ifdef LLDB_OPTIONS_memory_read
constexpr static OptionDefinition g_memory_read_options[] = {
  {LLDB_OPT_SET_2, false, "binary", 'b', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "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."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Necessary if reading over target.max-memory-read-size bytes."},
  {LLDB_OPT_SET_4, false, "language", 'x', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "The language of the type to view memory as."},
  {LLDB_OPT_SET_1, false, "num-per-line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNumberPerLine, "The number of items per line to display."},
  {LLDB_OPT_SET_3, false, "offset", 'E', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "How many elements of the specified type to skip before starting to display data."},
  {LLDB_OPT_SET_3 | LLDB_OPT_SET_4, true, "type", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "The name of a type to view memory as."},
};
#undef LLDB_OPTIONS_memory_read
#endif // memory read command

// Options for memory write
#ifdef LLDB_OPTIONS_memory_write
constexpr static OptionDefinition g_memory_write_options[] = {
  {LLDB_OPT_SET_1, true, "infile", 'i', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFilename, "Write memory using the contents of a file."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "Start writing bytes from an offset within the input file."},
};
#undef LLDB_OPTIONS_memory_write
#endif // memory write command

// Options for permissions
#ifdef LLDB_OPTIONS_permissions
constexpr static OptionDefinition g_permissions_options[] = {
  {LLDB_OPT_SET_ALL, false, "group-exec", 'X', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow group to execute."},
  {LLDB_OPT_SET_ALL, false, "group-read", 'R', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow group to read."},
  {LLDB_OPT_SET_ALL, false, "group-write", 'W', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow group to write."},
  {LLDB_OPT_SET_ALL, false, "permissions-string", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePermissionsString, "Give out the string value for permissions (e.g. rwxr-xr--)."},
  {LLDB_OPT_SET_ALL, false, "permissions-value", 'v', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePermissionsNumber, "Give out the numeric value for permissions (e.g. 757)"},
  {LLDB_OPT_SET_ALL, false, "user-exec", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow user to execute."},
  {LLDB_OPT_SET_ALL, false, "user-read", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow user to read."},
  {LLDB_OPT_SET_ALL, false, "user-write", 'w', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow user to write."},
  {LLDB_OPT_SET_ALL, false, "world-exec", 'e', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow world to execute."},
  {LLDB_OPT_SET_ALL, false, "world-read", 'd', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow world to read."},
  {LLDB_OPT_SET_ALL, false, "world-write", 't', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allow world to write."},
};
#undef LLDB_OPTIONS_permissions
#endif // permissions command

// Options for platform fread
#ifdef LLDB_OPTIONS_platform_fread
constexpr static OptionDefinition g_platform_fread_options[] = {
  {LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "Number of bytes to read from the file."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeIndex, "Offset into the file at which to start reading."},
};
#undef LLDB_OPTIONS_platform_fread
#endif // platform fread command

// Options for platform fwrite
#ifdef LLDB_OPTIONS_platform_fwrite
constexpr static OptionDefinition g_platform_fwrite_options[] = {
  {LLDB_OPT_SET_1, false, "data", 'd', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeValue, "Text to write to the file."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeIndex, "Offset into the file at which to start reading."},
};
#undef LLDB_OPTIONS_platform_fwrite
#endif // platform fwrite command

// Options for platform process attach
#ifdef LLDB_OPTIONS_platform_process_attach
constexpr static OptionDefinition g_platform_process_attach_options[] = {
  {LLDB_OPT_SET_2, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "The name of the process to attach to."},
  {LLDB_OPT_SET_1, false, "pid", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePid, "The process ID of an existing process to attach to."},
  {LLDB_OPT_SET_ALL, false, "plugin", 'P', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePlugin, "Name of the process plugin you want to use."},
  {LLDB_OPT_SET_2, false, "waitfor", 'w', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Wait for the process with <process-name> to launch."},
};
#undef LLDB_OPTIONS_platform_process_attach
#endif // platform process attach command

// Options for platform process list
#ifdef LLDB_OPTIONS_platform_process_list
constexpr static OptionDefinition g_platform_process_list_options[] = {
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "all-users", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show processes matching all user IDs."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "arch", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeArchitecture, "Find processes that have a matching architecture."},
  {LLDB_OPT_SET_5, true, "contains", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "Find processes with executable basenames that contain a string."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "egid", 'G', OptionParser::eRequiredArgument, &posix_validator, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Find processes that have a matching effective group ID."},
  {LLDB_OPT_SET_3, true, "ends-with", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "Find processes with executable basenames that end with a string."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "euid", 'U', OptionParser::eRequiredArgument, &posix_validator, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Find processes that have a matching effective user ID."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "gid", 'g', OptionParser::eRequiredArgument, &posix_validator, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Find processes that have a matching group ID."},
  {LLDB_OPT_SET_2, true, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "Find processes with executable basenames that match a string."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "parent", 'P', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePid, "Find processes that have a matching parent process ID."},
  {LLDB_OPT_SET_1, false, "pid", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePid, "List the process info for a specific process ID."},
  {LLDB_OPT_SET_6, true, "regex", 'r', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeRegularExpression, "Find processes with executable basenames that match a regular expression."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "show-args", 'A', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show process arguments instead of the process executable basename."},
  {LLDB_OPT_SET_4, true, "starts-with", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "Find processes with executable basenames that start with a string."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "uid", 'u', OptionParser::eRequiredArgument, &posix_validator, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Find processes that have a matching user ID."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5 | LLDB_OPT_SET_6, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable verbose output."},
};
#undef LLDB_OPTIONS_platform_process_list
#endif // platform process list command

// Options for platform shell
#ifdef LLDB_OPTIONS_platform_shell
constexpr static OptionDefinition g_platform_shell_options[] = {
  {LLDB_OPT_SET_ALL, false, "timeout", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeValue, "Seconds to wait for the remote host to finish running the command."},
};
#undef LLDB_OPTIONS_platform_shell
#endif // platform shell command

// Options for process attach
#ifdef LLDB_OPTIONS_process_attach
constexpr static OptionDefinition g_process_attach_options[] = {
  {LLDB_OPT_SET_ALL, false, "continue", 'c', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Immediately continue the process once attached."},
  {LLDB_OPT_SET_2, false, "include-existing", 'i', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Include existing processes when doing attach -w."},
  {LLDB_OPT_SET_2, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeProcessName, "The name of the process to attach to."},
  {LLDB_OPT_SET_1, false, "pid", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePid, "The process ID of an existing process to attach to."},
  {LLDB_OPT_SET_ALL, false, "plugin", 'P', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePlugin, "Name of the process plugin you want to use."},
  {LLDB_OPT_SET_2, false, "waitfor", 'w', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Wait for the process with <process-name> to launch."},
};
#undef LLDB_OPTIONS_process_attach
#endif // process attach command

// Options for process connect
#ifdef LLDB_OPTIONS_process_connect
constexpr static OptionDefinition g_process_connect_options[] = {
  {LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePlugin, "Name of the process plugin you want to use."},
};
#undef LLDB_OPTIONS_process_connect
#endif // process connect command

// Options for process continue
#ifdef LLDB_OPTIONS_process_continue
constexpr static OptionDefinition g_process_continue_options[] = {
  {LLDB_OPT_SET_ALL, false, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeUnsignedInteger, "Ignore <N> crossings of the breakpoint (if it exists) for the currently selected thread."},
};
#undef LLDB_OPTIONS_process_continue
#endif // process continue command

// Options for process detach
#ifdef LLDB_OPTIONS_process_detach
constexpr static OptionDefinition g_process_detach_options[] = {
  {LLDB_OPT_SET_1, false, "keep-stopped", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Whether or not the process should be kept stopped on detach (if possible)."},
};
#undef LLDB_OPTIONS_process_detach
#endif // process detach command

// Options for process handle
#ifdef LLDB_OPTIONS_process_handle
constexpr static OptionDefinition g_process_handle_options[] = {
  {LLDB_OPT_SET_1, false, "notify", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Whether or not the debugger should notify the user if the signal is received."},
  {LLDB_OPT_SET_1, false, "pass", 'p', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Whether or not the signal should be passed to the process."},
  {LLDB_OPT_SET_1, false, "stop", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Whether or not the process should be stopped if the signal is received."},
};
#undef LLDB_OPTIONS_process_handle
#endif // process handle command

// Options for process load
#ifdef LLDB_OPTIONS_process_load
constexpr static OptionDefinition g_process_load_options[] = {
  {LLDB_OPT_SET_ALL, false, "install", 'i', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePath, "Install the shared library to the target. If specified without an argument then the library will installed in the current working directory."},
};
#undef LLDB_OPTIONS_process_load
#endif // process load command

// Options for regex
#ifdef LLDB_OPTIONS_regex
constexpr static OptionDefinition g_regex_options[] = {
  {LLDB_OPT_SET_1, false, "help", 'h', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "The help text to display for this command."},
  {LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "A syntax string showing the typical usage syntax."},
};
#undef LLDB_OPTIONS_regex
#endif // regex command

// Options for register read
#ifdef LLDB_OPTIONS_register_read
constexpr static OptionDefinition g_register_read_options[] = {
  {LLDB_OPT_SET_2, false, "all", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show all register sets."},
  {LLDB_OPT_SET_ALL, false, "alternate", 'A', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display register names using the alternate register name if there is one."},
  {LLDB_OPT_SET_1, false, "set", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeIndex, "Specify which register sets to dump by index."},
};
#undef LLDB_OPTIONS_register_read
#endif // register read command

// Options for reproducer
#ifdef LLDB_OPTIONS_reproducer
constexpr static OptionDefinition g_reproducer_options[] = {
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFilename, "The reproducer path. If a reproducer is replayed and no path is provided, that reproducer is dumped."},
  {LLDB_OPT_SET_1, true, "provider", 'p', OptionParser::eRequiredArgument, nullptr, ReproducerProviderType(), CommandCompletions::eNoCompletion, eArgTypeNone, "The reproducer provider to dump."},
};
#undef LLDB_OPTIONS_reproducer
#endif // reproducer command

// Options for script add
#ifdef LLDB_OPTIONS_script_add
constexpr static OptionDefinition g_script_add_options[] = {
  {LLDB_OPT_SET_2, false, "class", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonClass, "Name of the Python class to bind to this command name."},
  {LLDB_OPT_SET_1, false, "function", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonFunction, "Name of the Python function to bind to this command name."},
  {LLDB_OPT_SET_1, false, "help", 'h', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeHelpText, "The help text to display for this command."},
  {LLDB_OPT_SET_ALL, false, "synchronicity", 's', OptionParser::eRequiredArgument, nullptr, ScriptSynchroType(), CommandCompletions::eNoCompletion, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system."},
};
#undef LLDB_OPTIONS_script_add
#endif // script add command

// Options for script import
#ifdef LLDB_OPTIONS_script_import
constexpr static OptionDefinition g_script_import_options[] = {
  {LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "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."},
};
#undef LLDB_OPTIONS_script_import
#endif // script import command

// Options for settings read
#ifdef LLDB_OPTIONS_settings_read
constexpr static OptionDefinition g_settings_read_options[] = {
  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename, "The file from which to read the settings."},
};
#undef LLDB_OPTIONS_settings_read
#endif // settings read command

// Options for settings set
#ifdef LLDB_OPTIONS_settings_set
constexpr static OptionDefinition g_settings_set_options[] = {
  {LLDB_OPT_SET_ALL, false, "force", 'f', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Force an empty value to be accepted as the default."},
  {LLDB_OPT_SET_ALL, false, "global", 'g', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename, "Apply the new value to the global default value."},
};
#undef LLDB_OPTIONS_settings_set
#endif // settings set command

// Options for settings write
#ifdef LLDB_OPTIONS_settings_write
constexpr static OptionDefinition g_settings_write_options[] = {
  {LLDB_OPT_SET_ALL, false, "append", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Append to saved settings file if it exists."},
  {LLDB_OPT_SET_ALL, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eDiskFileCompletion, eArgTypeFilename, "The file into which to write the settings."},
};
#undef LLDB_OPTIONS_settings_write
#endif // settings write command

// Options for source
#ifdef LLDB_OPTIONS_source
constexpr static OptionDefinition g_source_options[] = {
  {LLDB_OPT_SET_ALL, false, "silent-run", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true don't echo commands while executing."},
  {LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, stop executing commands on continue."},
  {LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, stop executing commands on error."},
};
#undef LLDB_OPTIONS_source
#endif // source command

// Options for source info
#ifdef LLDB_OPTIONS_source_info
constexpr static OptionDefinition g_source_info_options[] = {
  {LLDB_OPT_SET_3, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."},
  {LLDB_OPT_SET_ALL, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "The number of line entries to display."},
  {LLDB_OPT_SET_1, false, "end-line", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "The line number at which to stop displaying lines."},
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "The file from which to display source."},
  {LLDB_OPT_SET_1, false, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "The line number at which to start the displaying lines."},
  {LLDB_OPT_SET_2, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeSymbol, "The name of a function whose source to display."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Look up the source in the given module or shared library (can be specified more than once)."},
};
#undef LLDB_OPTIONS_source_info
#endif // source info command

// Options for source list
#ifdef LLDB_OPTIONS_source_list
constexpr static OptionDefinition g_source_list_options[] = {
  {LLDB_OPT_SET_3, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Lookup the address and display the source information for the corresponding file and line."},
  {LLDB_OPT_SET_ALL, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "The number of source lines to display."},
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "The file from which to display source."},
  {LLDB_OPT_SET_1, false, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "The line number at which to start the display source."},
  {LLDB_OPT_SET_2, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeSymbol, "The name of a function whose source to display."},
  {LLDB_OPT_SET_4, false, "reverse", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Reverse the listing to look backwards from the last displayed block of source."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "shlib", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Look up the source file in the given shared library."},
  {LLDB_OPT_SET_ALL, false, "show-breakpoints", 'b', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Show the line table locations from the debug information that indicate valid places to set source level breakpoints."},
};
#undef LLDB_OPTIONS_source_list
#endif // source list command

// Options for target dependents
#ifdef LLDB_OPTIONS_target_dependents
constexpr static OptionDefinition g_target_dependents_options[] = {
  {LLDB_OPT_SET_1, false, "no-dependents", 'd', OptionParser::eOptionalArgument, nullptr, OptionEnumValues(g_dependents_enumaration), CommandCompletions::eNoCompletion, eArgTypeValue, "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'."},
};
#undef LLDB_OPTIONS_target_dependents
#endif // target dependents command

// Options for target modules dump
#ifdef LLDB_OPTIONS_target_modules_dump
constexpr static OptionDefinition g_target_modules_dump_options[] = {
  {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable verbose dump."},
};
#undef LLDB_OPTIONS_target_modules_dump
#endif // target modules dump command

// Options for target modules dump symtab
#ifdef LLDB_OPTIONS_target_modules_dump_symtab
constexpr static OptionDefinition g_target_modules_dump_symtab_options[] = {
  {LLDB_OPT_SET_1, false, "sort", 's', OptionParser::eRequiredArgument, nullptr, OptionEnumValues(g_sort_option_enumeration), CommandCompletions::eNoCompletion, eArgTypeSortOrder, "Supply a sort order when dumping the symbol table."},
};
#undef LLDB_OPTIONS_target_modules_dump_symtab
#endif // target modules dump symtab command

// Options for target modules list
#ifdef LLDB_OPTIONS_target_modules_list
constexpr static OptionDefinition g_target_modules_list_options[] = {
  {LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Display the image at this address."},
  {LLDB_OPT_SET_1, false, "arch", 'A', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the architecture when listing images."},
  {LLDB_OPT_SET_1, false, "basename", 'b', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the basename with optional width for the image object file."},
  {LLDB_OPT_SET_1, false, "directory", 'd', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the directory with optional width for the image object file."},
  {LLDB_OPT_SET_1, false, "fullpath", 'f', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the fullpath to the image object file."},
  {LLDB_OPT_SET_1, false, "global", 'g', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the modules from the global module list, not just the current target."},
  {LLDB_OPT_SET_1, false, "header", 'h', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the image base address as a load address if debugging, a file address otherwise."},
  {LLDB_OPT_SET_1, false, "mod-time", 'm', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the modification time with optional width of the module."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the image load address offset from the base file address (the slide amount)."},
  {LLDB_OPT_SET_1, false, "pointer", 'p', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the module pointer."},
  {LLDB_OPT_SET_1, false, "ref-count", 'r', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the reference count if the module is still in the shared module cache."},
  {LLDB_OPT_SET_1, false, "symfile", 's', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the fullpath to the image symbol file with optional width."},
  {LLDB_OPT_SET_1, false, "symfile-unique", 'S', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the symbol file with optional width only if it is different from the executable object file."},
  {LLDB_OPT_SET_1, false, "triple", 't', OptionParser::eOptionalArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeWidth, "Display the triple when listing images."},
  {LLDB_OPT_SET_1, false, "uuid", 'u', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the UUID when listing images."},
};
#undef LLDB_OPTIONS_target_modules_list
#endif // target modules list command

// Options for target modules lookup
#ifdef LLDB_OPTIONS_target_modules_lookup
constexpr static OptionDefinition g_target_modules_lookup_options[] = {
  {LLDB_OPT_SET_1, true, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Lookup an address in one or more target modules."},
  {LLDB_OPT_SET_ALL, false, "all", 'A', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Print all matches, not just the best match, if a best match is available."},
  {LLDB_OPT_SET_3, true, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFilename, "Lookup a file by fullpath or basename in one or more target modules."},
  {LLDB_OPT_SET_4, true, "function", 'F', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFunctionName, "Lookup a function by name in the debug symbols in one or more target modules."},
  {LLDB_OPT_SET_3, false, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Lookup a line number in a file (must be used in conjunction with --file)."},
  {LLDB_OPT_SET_5, true, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFunctionOrSymbol, "Lookup a function or symbol by name in one or more target modules."},
  {LLDB_OPT_SET_3 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "no-inlines", 'i', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Ignore inline entries (must be used in conjunction with --file or --function)."},
  {LLDB_OPT_SET_1, false, "offset", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "When looking up an address subtract <offset> from any addresses before doing the lookup."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_4 | LLDB_OPT_SET_5, false, "regex", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "The <name> argument for name lookups are regular expressions."},
  {LLDB_OPT_SET_2, true, "symbol", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeSymbol, "Lookup a symbol by name in the symbol tables in one or more target modules."},
  {LLDB_OPT_SET_6, true, "type", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Lookup a type by name in the debug symbols in one or more target modules."},
  {LLDB_OPT_SET_ALL, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Enable verbose lookup information."},
};
#undef LLDB_OPTIONS_target_modules_lookup
#endif // target modules lookup command

// Options for target modules show unwind
#ifdef LLDB_OPTIONS_target_modules_show_unwind
constexpr static OptionDefinition g_target_modules_show_unwind_options[] = {
  {LLDB_OPT_SET_2, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Show unwind instructions for a function or symbol containing an address"},
  {LLDB_OPT_SET_1, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFunctionName, "Show unwind instructions for a function or symbol name."},
};
#undef LLDB_OPTIONS_target_modules_show_unwind
#endif // target modules show unwind command

// Options for target stop hook add
#ifdef LLDB_OPTIONS_target_stop_hook_add
constexpr static OptionDefinition g_target_stop_hook_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "auto-continue", 'G', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "The breakpoint will auto-continue after running its commands."},
  {LLDB_OPT_SET_2, false, "classname", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeClassName, "Specify the class within which the stop-hook is to be run."},
  {LLDB_OPT_SET_1, false, "end-line", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Set the end of the line range for which the stop-hook is to be run."},
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specify the source file within which the stop-hook is to be run."},
  {LLDB_OPT_SET_3, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSymbolCompletion, eArgTypeFunctionName, "Set the function name within which the stop hook will be run."},
  {LLDB_OPT_SET_ALL, false, "one-liner", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOneLiner, "Add a command for the stop hook.  Can be specified more than once, and commands will be run in the order they appear."},
  {LLDB_OPT_SET_ALL, false, "queue-name", 'q', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeQueueName, "The stop hook is run only for threads in the queue whose name is given by this argument."},
  {LLDB_OPT_SET_ALL, false, "shlib", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Set the module within which the stop-hook is to be run."},
  {LLDB_OPT_SET_1, false, "start-line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Set the start of the line range for which the stop-hook is to be run."},
  {LLDB_OPT_SET_ALL, false, "thread-id", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadID, "The stop hook is run only for the thread whose TID matches this argument."},
  {LLDB_OPT_SET_ALL, false, "thread-index", 'x', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadIndex, "The stop hook is run only for the thread whose index matches this argument."},
  {LLDB_OPT_SET_ALL, false, "thread-name", 'T', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadName, "The stop hook is run only for the thread whose thread name matches this argument."},
};
#undef LLDB_OPTIONS_target_stop_hook_add
#endif // target stop hook add command

// Options for thread backtrace
#ifdef LLDB_OPTIONS_thread_backtrace
constexpr static OptionDefinition g_thread_backtrace_options[] = {
  {LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "How many frames to display (-1 for all)"},
  {LLDB_OPT_SET_1, false, "extended", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Show the extended backtrace, if available"},
  {LLDB_OPT_SET_1, false, "start", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFrameIndex, "Frame in which to start the backtrace"},
};
#undef LLDB_OPTIONS_thread_backtrace
#endif // thread backtrace command

// Options for thread info
#ifdef LLDB_OPTIONS_thread_info
constexpr static OptionDefinition g_thread_info_options[] = {
  {LLDB_OPT_SET_ALL, false, "json", 'j', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the thread info in JSON format."},
  {LLDB_OPT_SET_ALL, false, "stop-info", 's', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display the extended stop info in JSON format."},
};
#undef LLDB_OPTIONS_thread_info
#endif // thread info command

// Options for thread jump
#ifdef LLDB_OPTIONS_thread_jump
constexpr static OptionDefinition g_thread_jump_options[] = {
  {LLDB_OPT_SET_3, true, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Jumps to a specific address."},
  {LLDB_OPT_SET_2, true, "by", 'b', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOffset, "Jumps by a relative line offset from the current line."},
  {LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eSourceFileCompletion, eArgTypeFilename, "Specifies the source file to jump to."},
  {LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "force", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Allows the PC to leave the current function."},
  {LLDB_OPT_SET_1, true, "line", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "Specifies the line number to jump to."},
};
#undef LLDB_OPTIONS_thread_jump
#endif // thread jump command

// Options for thread plan list
#ifdef LLDB_OPTIONS_thread_plan_list
constexpr static OptionDefinition g_thread_plan_list_options[] = {
  {LLDB_OPT_SET_1, false, "internal", 'i', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display internal as well as user thread plans"},
  {LLDB_OPT_SET_1, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display more information about the thread plans"},
};
#undef LLDB_OPTIONS_thread_plan_list
#endif // thread plan list command

// Options for thread return
#ifdef LLDB_OPTIONS_thread_return
constexpr static OptionDefinition g_thread_return_options[] = {
  {LLDB_OPT_SET_ALL, false, "from-expression", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Return from the innermost expression evaluation."},
};
#undef LLDB_OPTIONS_thread_return
#endif // thread return command

// Options for thread step scope
#ifdef LLDB_OPTIONS_thread_step_scope
constexpr static OptionDefinition g_thread_step_scope_options[] = {
  {LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "How many times to perform the stepping operation - currently only supported for step-inst and next-inst."},
  {LLDB_OPT_SET_1, false, "end-linenumber", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLineNum, "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."},
  {LLDB_OPT_SET_1, false, "run-mode", 'm', OptionParser::eRequiredArgument, nullptr, TriRunningModes(), CommandCompletions::eNoCompletion, eArgTypeRunMode, "Determine how to run other threads while stepping the current thread."},
  {LLDB_OPT_SET_1, false, "step-in-avoids-no-debug", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "A boolean value that sets whether stepping into functions will step over functions with no debug information."},
  {LLDB_OPT_SET_1, false, "step-in-target", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFunctionName, "The name of the directly called function step in should stop at when stepping into."},
  {LLDB_OPT_SET_1, false, "step-out-avoids-no-debug", 'A', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "A boolean value, if true stepping out of functions will continue to step out till it hits a function with debug information."},
  {LLDB_OPT_SET_1, false, "step-over-regexp", 'r', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeRegularExpression, "A regular expression that definesfunction names to not to stop at when stepping in."},
};
#undef LLDB_OPTIONS_thread_step_scope
#endif // thread step scope command

// Options for thread until
#ifdef LLDB_OPTIONS_thread_until
constexpr static OptionDefinition g_thread_until_options[] = {
  {LLDB_OPT_SET_1, false, "address", 'a', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeAddressOrExpression, "Run until we reach the specified address,or leave the function - can be specified multiple times."},
  {LLDB_OPT_SET_1, false, "frame", 'f', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeFrameIndex, "Frame index for until operation - defaults to 0"},
  {LLDB_OPT_SET_1, false, "run-mode", 'm', OptionParser::eRequiredArgument, nullptr, DuoRunningModes(), CommandCompletions::eNoCompletion, eArgTypeRunMode, "Determine how to run otherthreads while stepping this one"},
  {LLDB_OPT_SET_1, false, "thread", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeThreadIndex, "Thread index for the thread for until operation"},
};
#undef LLDB_OPTIONS_thread_until
#endif // thread until command

// Options for type category define
#ifdef LLDB_OPTIONS_type_category_define
constexpr static OptionDefinition g_type_category_define_options[] = {
  {LLDB_OPT_SET_ALL, false, "enabled", 'e', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "If specified, this category will be created enabled."},
  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Specify the language that this category is supported for."},
};
#undef LLDB_OPTIONS_type_category_define
#endif // type category define command

// Options for type category disable
#ifdef LLDB_OPTIONS_type_category_disable
constexpr static OptionDefinition g_type_category_disable_options[] = {
  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Enable the category for this language."},
};
#undef LLDB_OPTIONS_type_category_disable
#endif // type category disable command

// Options for type category enable
#ifdef LLDB_OPTIONS_type_category_enable
constexpr static OptionDefinition g_type_category_enable_options[] = {
  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Enable the category for this language."},
};
#undef LLDB_OPTIONS_type_category_enable
#endif // type category enable command

// Options for type filter add
#ifdef LLDB_OPTIONS_type_filter_add
constexpr static OptionDefinition g_type_filter_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, cascade through typedef chains."},
  {LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Add this to the given category instead of the default one."},
  {LLDB_OPT_SET_ALL, false, "child", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeExpressionPath, "Include this expression path in the synthetic view."},
  {LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Type names are actually regular expressions."},
  {LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for references-to-type objects."},
};
#undef LLDB_OPTIONS_type_filter_add
#endif // type filter add command

// Options for type format add
#ifdef LLDB_OPTIONS_type_format_add
constexpr static OptionDefinition g_type_format_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, cascade through typedef chains."},
  {LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Add this to the given category instead of the default one."},
  {LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Type names are actually regular expressions."},
  {LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for references-to-type objects."},
  {LLDB_OPT_SET_2, false, "type", 't', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Format variables as if they were of this type."},
};
#undef LLDB_OPTIONS_type_format_add
#endif // type format add command

// Options for type formatter clear
#ifdef LLDB_OPTIONS_type_formatter_clear
constexpr static OptionDefinition g_type_formatter_clear_options[] = {
  {LLDB_OPT_SET_ALL, false, "all", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Clear every category."},
};
#undef LLDB_OPTIONS_type_formatter_clear
#endif // type formatter clear command

// Options for type formatter delete
#ifdef LLDB_OPTIONS_type_formatter_delete
constexpr static OptionDefinition g_type_formatter_delete_options[] = {
  {LLDB_OPT_SET_1, false, "all", 'a', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Delete from every category."},
  {LLDB_OPT_SET_2, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Delete from given category."},
  {LLDB_OPT_SET_3, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Delete from given language's category."},
};
#undef LLDB_OPTIONS_type_formatter_delete
#endif // type formatter delete command

// Options for type formatter list
#ifdef LLDB_OPTIONS_type_formatter_list
constexpr static OptionDefinition g_type_formatter_list_options[] = {
  {LLDB_OPT_SET_1, false, "category-regex", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Only show categories matching this filter."},
  {LLDB_OPT_SET_2, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Only show the category for a specific language."},
};
#undef LLDB_OPTIONS_type_formatter_list
#endif // type formatter list command

// Options for type lookup
#ifdef LLDB_OPTIONS_type_lookup
constexpr static OptionDefinition g_type_lookup_options[] = {
  {LLDB_OPT_SET_ALL, false, "language", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeLanguage, "Which language's types should the search scope be"},
  {LLDB_OPT_SET_ALL, false, "show-help", 'h', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Display available help for types"},
};
#undef LLDB_OPTIONS_type_lookup
#endif // type lookup command

// Options for type summary add
#ifdef LLDB_OPTIONS_type_summary_add
constexpr static OptionDefinition g_type_summary_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, cascade through typedef chains."},
  {LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Add this to the given category instead of the default one."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand", 'e', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Expand aggregate data types to show children on separate lines."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "hide-empty", 'h', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Do not expand aggregate data types with no children."},
  {LLDB_OPT_SET_1, true, "inline-children", 'c', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "If true, inline all child values into summary string."},
  {LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Input Python code to use for this type manually."},
  {LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name", 'n', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "A name for this summary string."},
  {LLDB_OPT_SET_ALL, false, "no-value", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't show the value, just show the summary, for this type."},
  {LLDB_OPT_SET_1, false, "omit-names", 'O', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "If true, omit value names in the summary display."},
  {LLDB_OPT_SET_3, false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonFunction, "Give the name of a Python function to use for this type."},
  {LLDB_OPT_SET_3, false, "python-script", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonScript, "Give a one-liner Python script as part of the command."},
  {LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Type names are actually regular expressions."},
  {LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for references-to-type objects."},
  {LLDB_OPT_SET_2, true, "summary-string", 's', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeSummaryString, "Summary string used to display text and object contents."},
};
#undef LLDB_OPTIONS_type_summary_add
#endif // type summary add command

// Options for type synth add
#ifdef LLDB_OPTIONS_type_synth_add
constexpr static OptionDefinition g_type_synth_add_options[] = {
  {LLDB_OPT_SET_ALL, false, "cascade", 'C', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "If true, cascade through typedef chains."},
  {LLDB_OPT_SET_ALL, false, "category", 'w', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeName, "Add this to the given category instead of the default one."},
  {LLDB_OPT_SET_3, false, "input-python", 'P', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Type Python code to generate a class that provides synthetic children."},
  {LLDB_OPT_SET_2, false, "python-class", 'l', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonClass, "Use this Python class to produce synthetic children."},
  {LLDB_OPT_SET_ALL, false, "regex", 'x', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Type names are actually regular expressions."},
  {LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for pointers-to-type objects."},
  {LLDB_OPT_SET_ALL, false, "skip-references", 'r', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Don't use this format for references-to-type objects."},
};
#undef LLDB_OPTIONS_type_synth_add
#endif // type synth add command

// Options for watchpoint command add
#ifdef LLDB_OPTIONS_watchpoint_command_add
constexpr static OptionDefinition g_watchpoint_command_add_options[] = {
  {LLDB_OPT_SET_1, false, "one-liner", 'o', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeOneLiner, "Specify a one-line watchpoint command inline. Be sure to surround it with quotes."},
  {LLDB_OPT_SET_2, false, "python-function", 'F', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypePythonFunction, "Give the name of a Python function to run as command for this watchpoint. Be sure to give a module name if appropriate."},
  {LLDB_OPT_SET_ALL, false, "script-type", 's', OptionParser::eRequiredArgument, nullptr, ScriptOptionEnum(), CommandCompletions::eNoCompletion, eArgTypeNone, "Specify the language for the commands - if none is specified, the lldb command interpreter will be used."},
  {LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeBoolean, "Specify whether watchpoint command execution should terminate on error."},
};
#undef LLDB_OPTIONS_watchpoint_command_add
#endif // watchpoint command add command

// Options for watchpoint ignore
#ifdef LLDB_OPTIONS_watchpoint_ignore
constexpr static OptionDefinition g_watchpoint_ignore_options[] = {
  {LLDB_OPT_SET_ALL, true, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeCount, "Set the number of times this watchpoint is skipped before stopping."},
};
#undef LLDB_OPTIONS_watchpoint_ignore
#endif // watchpoint ignore command

// Options for watchpoint list
#ifdef LLDB_OPTIONS_watchpoint_list
constexpr static OptionDefinition g_watchpoint_list_options[] = {
  {LLDB_OPT_SET_1, false, "brief", 'b', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Give a brief description of the watchpoint (no location info)."},
  {LLDB_OPT_SET_2, false, "full", 'f', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Give a full description of the watchpoint and its locations."},
  {LLDB_OPT_SET_3, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeNone, "Explaineverything we know about the watchpoint (for debugging debugger bugs)."},
};
#undef LLDB_OPTIONS_watchpoint_list
#endif // watchpoint list command

// Options for watchpoint modify
#ifdef LLDB_OPTIONS_watchpoint_modify
constexpr static OptionDefinition g_watchpoint_modify_options[] = {
  {LLDB_OPT_SET_ALL, false, "condition", 'c', OptionParser::eRequiredArgument, nullptr, {}, CommandCompletions::eNoCompletion, eArgTypeExpression, "The watchpoint stops only if this condition expression evaluates to true."},
};
#undef LLDB_OPTIONS_watchpoint_modify
#endif // watchpoint modify command