1 //===-- CommandOptionArgumentTable.h ----------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H 10 #define LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H 11 12 #include "lldb/Interpreter/CommandObject.h" 13 14 namespace lldb_private { 15 16 static constexpr OptionEnumValueElement g_corefile_save_style[] = { 17 {lldb::eSaveCoreFull, "full", "Create a core file with all memory saved"}, 18 {lldb::eSaveCoreDirtyOnly, "modified-memory", 19 "Create a corefile with only modified memory saved"}, 20 {lldb::eSaveCoreStackOnly, "stack", 21 "Create a corefile with only stack memory saved"}, 22 }; 23 24 static constexpr OptionEnumValueElement g_description_verbosity_type[] = { 25 { 26 eLanguageRuntimeDescriptionDisplayVerbosityCompact, 27 "compact", 28 "Only show the description string", 29 }, 30 { 31 eLanguageRuntimeDescriptionDisplayVerbosityFull, 32 "full", 33 "Show the full output, including persistent variable's name and type", 34 }, 35 }; 36 37 static constexpr OptionEnumValueElement g_sort_option_enumeration[] = { 38 { 39 eSortOrderNone, 40 "none", 41 "No sorting, use the original symbol table order.", 42 }, 43 { 44 eSortOrderByAddress, 45 "address", 46 "Sort output by symbol address.", 47 }, 48 { 49 eSortOrderByName, 50 "name", 51 "Sort output by symbol name.", 52 }, 53 }; 54 55 // Note that the negation in the argument name causes a slightly confusing 56 // mapping of the enum values. 57 static constexpr OptionEnumValueElement g_dependents_enumeration[] = { 58 { 59 eLoadDependentsDefault, 60 "default", 61 "Only load dependents when the target is an executable.", 62 }, 63 { 64 eLoadDependentsNo, 65 "true", 66 "Don't load dependents, even if the target is an executable.", 67 }, 68 { 69 eLoadDependentsYes, 70 "false", 71 "Load dependents, even if the target is not an executable.", 72 }, 73 }; 74 75 // FIXME: "script-type" needs to have its contents determined dynamically, so 76 // somebody can add a new scripting language to lldb and have it pickable here 77 // without having to change this enumeration by hand and rebuild lldb proper. 78 static constexpr OptionEnumValueElement g_script_option_enumeration[] = { 79 { 80 lldb::eScriptLanguageNone, 81 "command", 82 "Commands are in the lldb command interpreter language", 83 }, 84 { 85 lldb::eScriptLanguagePython, 86 "python", 87 "Commands are in the Python language.", 88 }, 89 { 90 lldb::eScriptLanguageLua, 91 "lua", 92 "Commands are in the Lua language.", 93 }, 94 { 95 lldb::eScriptLanguageNone, 96 "default", 97 "Commands are in the default scripting language.", 98 }, 99 }; 100 101 static constexpr OptionEnumValueElement g_log_handler_type[] = { 102 { 103 eLogHandlerDefault, 104 "default", 105 "Use the default (stream) log handler", 106 }, 107 { 108 eLogHandlerStream, 109 "stream", 110 "Write log messages to the debugger output stream or to a file if one " 111 "is specified. A buffer size (in bytes) can be specified with -b. If " 112 "no buffer size is specified the output is unbuffered.", 113 }, 114 { 115 eLogHandlerCircular, 116 "circular", 117 "Write log messages to a fixed size circular buffer. A buffer size " 118 "(number of messages) must be specified with -b.", 119 }, 120 { 121 eLogHandlerSystem, 122 "os", 123 "Write log messages to the operating system log.", 124 }, 125 }; 126 127 static constexpr OptionEnumValueElement g_reproducer_provider_type[] = { 128 { 129 eReproducerProviderCommands, 130 "commands", 131 "Command Interpreter Commands", 132 }, 133 { 134 eReproducerProviderFiles, 135 "files", 136 "Files", 137 }, 138 { 139 eReproducerProviderSymbolFiles, 140 "symbol-files", 141 "Symbol Files", 142 }, 143 { 144 eReproducerProviderGDB, 145 "gdb", 146 "GDB Remote Packets", 147 }, 148 { 149 eReproducerProviderProcessInfo, 150 "processes", 151 "Process Info", 152 }, 153 { 154 eReproducerProviderVersion, 155 "version", 156 "Version", 157 }, 158 { 159 eReproducerProviderWorkingDirectory, 160 "cwd", 161 "Working Directory", 162 }, 163 { 164 eReproducerProviderHomeDirectory, 165 "home", 166 "Home Directory", 167 }, 168 { 169 eReproducerProviderNone, 170 "none", 171 "None", 172 }, 173 }; 174 175 static constexpr OptionEnumValueElement g_reproducer_signaltype[] = { 176 { 177 eReproducerCrashSigill, 178 "SIGILL", 179 "Illegal instruction", 180 }, 181 { 182 eReproducerCrashSigsegv, 183 "SIGSEGV", 184 "Segmentation fault", 185 }, 186 }; 187 188 static constexpr OptionEnumValueElement g_script_synchro_type[] = { 189 { 190 eScriptedCommandSynchronicitySynchronous, 191 "synchronous", 192 "Run synchronous", 193 }, 194 { 195 eScriptedCommandSynchronicityAsynchronous, 196 "asynchronous", 197 "Run asynchronous", 198 }, 199 { 200 eScriptedCommandSynchronicityCurrentValue, 201 "current", 202 "Do not alter current setting", 203 }, 204 }; 205 206 static constexpr OptionEnumValueElement g_running_mode[] = { 207 {lldb::eOnlyThisThread, "this-thread", "Run only this thread"}, 208 {lldb::eAllThreads, "all-threads", "Run all threads"}, 209 {lldb::eOnlyDuringStepping, "while-stepping", 210 "Run only this thread while stepping"}, 211 }; 212 213 llvm::StringRef RegisterNameHelpTextCallback(); 214 llvm::StringRef BreakpointIDHelpTextCallback(); 215 llvm::StringRef BreakpointIDRangeHelpTextCallback(); 216 llvm::StringRef BreakpointNameHelpTextCallback(); 217 llvm::StringRef GDBFormatHelpTextCallback(); 218 llvm::StringRef FormatHelpTextCallback(); 219 llvm::StringRef LanguageTypeHelpTextCallback(); 220 llvm::StringRef SummaryStringHelpTextCallback(); 221 llvm::StringRef ExprPathHelpTextCallback(); 222 llvm::StringRef arch_helper(); 223 224 static constexpr CommandObject::ArgumentTableEntry g_argument_table[] = { 225 // clang-format off 226 { lldb::eArgTypeAddress, "address", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A valid address in the target program's execution space." }, 227 { lldb::eArgTypeAddressOrExpression, "address-expression", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An expression that resolves to an address." }, 228 { lldb::eArgTypeAliasName, "alias-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of an abbreviation (alias) for a debugger command." }, 229 { lldb::eArgTypeAliasOptions, "options-for-aliased-command", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Command options to be used as part of an alias (abbreviation) definition. (See 'help commands alias' for more information.)" }, 230 { lldb::eArgTypeArchitecture, "arch", CommandCompletions::eArchitectureCompletion, {}, { arch_helper, true }, "The architecture name, e.g. i386 or x86_64." }, 231 { lldb::eArgTypeBoolean, "boolean", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A Boolean value: 'true' or 'false'" }, 232 { lldb::eArgTypeBreakpointID, "breakpt-id", CommandCompletions::eNoCompletion, {}, { BreakpointIDHelpTextCallback, false }, nullptr }, 233 { lldb::eArgTypeBreakpointIDRange, "breakpt-id-list", CommandCompletions::eNoCompletion, {}, { BreakpointIDRangeHelpTextCallback, false }, nullptr }, 234 { lldb::eArgTypeBreakpointName, "breakpoint-name", CommandCompletions::eBreakpointNameCompletion, {}, { BreakpointNameHelpTextCallback, false }, nullptr }, 235 { lldb::eArgTypeByteSize, "byte-size", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Number of bytes to use." }, 236 { lldb::eArgTypeClassName, "class-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Then name of a class from the debug information in the program." }, 237 { lldb::eArgTypeCommandName, "cmd-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A debugger command (may be multiple words), without any options or arguments." }, 238 { lldb::eArgTypeCount, "count", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An unsigned integer." }, 239 { lldb::eArgTypeDescriptionVerbosity, "description-verbosity", CommandCompletions::eNoCompletion, g_description_verbosity_type, { nullptr, false }, "How verbose the output of 'po' should be." }, 240 { lldb::eArgTypeDirectoryName, "directory", CommandCompletions::eDiskDirectoryCompletion, {}, { nullptr, false }, "A directory name." }, 241 { lldb::eArgTypeDisassemblyFlavor, "disassembly-flavor", CommandCompletions::eDisassemblyFlavorCompletion, {}, { nullptr, false }, "A disassembly flavor recognized by your disassembly plugin. Currently the only valid options are \"att\" and \"intel\" for Intel targets" }, 242 { lldb::eArgTypeEndAddress, "end-address", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 243 { lldb::eArgTypeExpression, "expr", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 244 { lldb::eArgTypeExpressionPath, "expr-path", CommandCompletions::eNoCompletion, {}, { ExprPathHelpTextCallback, true }, nullptr }, 245 { lldb::eArgTypeExprFormat, "expression-format", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]" }, 246 { lldb::eArgTypeFileLineColumn, "linespec", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A source specifier in the form file:line[:column]" }, 247 { lldb::eArgTypeFilename, "filename", CommandCompletions::eDiskFileCompletion, {}, { nullptr, false }, "The name of a file (can include path)." }, 248 { lldb::eArgTypeFormat, "format", CommandCompletions::eNoCompletion, {}, { FormatHelpTextCallback, true }, nullptr }, 249 { lldb::eArgTypeFrameIndex, "frame-index", CommandCompletions::eFrameIndexCompletion, {}, { nullptr, false }, "Index into a thread's list of frames." }, 250 { lldb::eArgTypeFullName, "fullname", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 251 { lldb::eArgTypeFunctionName, "function-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a function." }, 252 { lldb::eArgTypeFunctionOrSymbol, "function-or-symbol", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a function or symbol." }, 253 { lldb::eArgTypeGDBFormat, "gdb-format", CommandCompletions::eNoCompletion, {}, { GDBFormatHelpTextCallback, true }, nullptr }, 254 { lldb::eArgTypeHelpText, "help-text", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Text to be used as help for some other entity in LLDB" }, 255 { lldb::eArgTypeIndex, "index", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An index into a list." }, 256 { lldb::eArgTypeLanguage, "source-language", CommandCompletions::eTypeLanguageCompletion, {}, { LanguageTypeHelpTextCallback, true }, nullptr }, 257 { lldb::eArgTypeLineNum, "linenum", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Line number in a source file." }, 258 { lldb::eArgTypeLogCategory, "log-category", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a category within a log channel, e.g. all (try \"log list\" to see a list of all channels and their categories." }, 259 { lldb::eArgTypeLogChannel, "log-channel", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a log channel, e.g. process.gdb-remote (try \"log list\" to see a list of all channels and their categories)." }, 260 { lldb::eArgTypeMethod, "method", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A C++ method name." }, 261 { lldb::eArgTypeName, "name", CommandCompletions::eTypeCategoryNameCompletion, {}, { nullptr, false }, "Help text goes here." }, 262 { lldb::eArgTypeNewPathPrefix, "new-path-prefix", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 263 { lldb::eArgTypeNumLines, "num-lines", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The number of lines to use." }, 264 { lldb::eArgTypeNumberPerLine, "number-per-line", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The number of items per line to display." }, 265 { lldb::eArgTypeOffset, "offset", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 266 { lldb::eArgTypeOldPathPrefix, "old-path-prefix", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 267 { lldb::eArgTypeOneLiner, "one-line-command", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A command that is entered as a single line of text." }, 268 { lldb::eArgTypePath, "path", CommandCompletions::eDiskFileCompletion, {}, { nullptr, false }, "Path." }, 269 { lldb::eArgTypePermissionsNumber, "perms-numeric", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Permissions given as an octal number (e.g. 755)." }, 270 { lldb::eArgTypePermissionsString, "perms=string", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Permissions given as a string value (e.g. rw-r-xr--)." }, 271 { lldb::eArgTypePid, "pid", CommandCompletions::eProcessIDCompletion, {}, { nullptr, false }, "The process ID number." }, 272 { lldb::eArgTypePlugin, "plugin", CommandCompletions::eProcessPluginCompletion, {}, { nullptr, false }, "Help text goes here." }, 273 { lldb::eArgTypeProcessName, "process-name", CommandCompletions::eProcessNameCompletion, {}, { nullptr, false }, "The name of the process." }, 274 { lldb::eArgTypePythonClass, "python-class", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a Python class." }, 275 { lldb::eArgTypePythonFunction, "python-function", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a Python function." }, 276 { lldb::eArgTypePythonScript, "python-script", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Source code written in Python." }, 277 { lldb::eArgTypeQueueName, "queue-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of the thread queue." }, 278 { lldb::eArgTypeRegisterName, "register-name", CommandCompletions::eNoCompletion, {}, { RegisterNameHelpTextCallback, true }, nullptr }, 279 { lldb::eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A POSIX-compliant extended regular expression." }, 280 { lldb::eArgTypeRunArgs, "run-args", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Arguments to be passed to the target program when it starts executing." }, 281 { lldb::eArgTypeRunMode, "run-mode", CommandCompletions::eNoCompletion, g_running_mode, { nullptr, false }, "Help text goes here." }, 282 { lldb::eArgTypeScriptedCommandSynchronicity, "script-cmd-synchronicity", CommandCompletions::eNoCompletion, g_script_synchro_type, { nullptr, false }, "The synchronicity to use to run scripted commands with regard to LLDB event system." }, 283 { lldb::eArgTypeScriptLang, "script-language", CommandCompletions::eNoCompletion, g_script_option_enumeration, { nullptr, false }, "The scripting language to be used for script-based commands. Supported languages are python and lua." }, 284 { lldb::eArgTypeSearchWord, "search-word", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Any word of interest for search purposes." }, 285 { lldb::eArgTypeSelector, "selector", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An Objective-C selector name." }, 286 { lldb::eArgTypeSettingIndex, "setting-index", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An index into a settings variable that is an array (try 'settings list' to see all the possible settings variables and their types)." }, 287 { lldb::eArgTypeSettingKey, "setting-key", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A key into a settings variables that is a dictionary (try 'settings list' to see all the possible settings variables and their types)." }, 288 { lldb::eArgTypeSettingPrefix, "setting-prefix", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a settable internal debugger variable up to a dot ('.'), e.g. 'target.process.'" }, 289 { lldb::eArgTypeSettingVariableName, "setting-variable-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a settable internal debugger variable. Type 'settings list' to see a complete list of such variables." }, 290 { lldb::eArgTypeShlibName, "shlib-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The name of a shared library." }, 291 { lldb::eArgTypeSourceFile, "source-file", CommandCompletions::eSourceFileCompletion, {}, { nullptr, false }, "The name of a source file.." }, 292 { lldb::eArgTypeSortOrder, "sort-order", CommandCompletions::eNoCompletion, g_sort_option_enumeration, { nullptr, false }, "Specify a sort order when dumping lists." }, 293 { lldb::eArgTypeStartAddress, "start-address", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 294 { lldb::eArgTypeSummaryString, "summary-string", CommandCompletions::eNoCompletion, {}, { SummaryStringHelpTextCallback, true }, nullptr }, 295 { lldb::eArgTypeSymbol, "symbol", CommandCompletions::eSymbolCompletion, {}, { nullptr, false }, "Any symbol name (function name, variable, argument, etc.)" }, 296 { lldb::eArgTypeThreadID, "thread-id", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Thread ID number." }, 297 { lldb::eArgTypeThreadIndex, "thread-index", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Index into the process' list of threads." }, 298 { lldb::eArgTypeThreadName, "thread-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The thread's name." }, 299 { lldb::eArgTypeTypeName, "type-name", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A type name." }, 300 { lldb::eArgTypeUnsignedInteger, "unsigned-integer", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An unsigned integer." }, 301 { lldb::eArgTypeUnixSignal, "unix-signal", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A valid Unix signal name or number (e.g. SIGKILL, KILL or 9)." }, 302 { lldb::eArgTypeVarName, "variable-name", CommandCompletions::eNoCompletion, {} ,{ nullptr, false }, "The name of a variable in your program." }, 303 { lldb::eArgTypeValue, "value", CommandCompletions::eNoCompletion, g_dependents_enumeration, { nullptr, false }, "A value could be anything, depending on where and how it is used." }, 304 { lldb::eArgTypeWidth, "width", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Help text goes here." }, 305 { lldb::eArgTypeNone, "none", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "No help available for this." }, 306 { lldb::eArgTypePlatform, "platform-name", CommandCompletions::ePlatformPluginCompletion, {}, { nullptr, false }, "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." }, 307 { lldb::eArgTypeWatchpointID, "watchpt-id", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Watchpoint IDs are positive integers." }, 308 { lldb::eArgTypeWatchpointIDRange, "watchpt-id-list", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "For example, '1-3' or '1 to 3'." }, 309 { lldb::eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Specify the type for a watchpoint." }, 310 { lldb::eArgRawInput, "raw-input", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Free-form text passed to a command without prior interpretation, allowing spaces without requiring quotes. To pass arguments and free form text put two dashes ' -- ' between the last argument and any raw input." }, 311 { lldb::eArgTypeCommand, "command", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "An LLDB Command line command element." }, 312 { lldb::eArgTypeColumnNum, "column", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "Column number in a source file." }, 313 { lldb::eArgTypeModuleUUID, "module-uuid", CommandCompletions::eModuleUUIDCompletion, {}, { nullptr, false }, "A module UUID value." }, 314 { lldb::eArgTypeSaveCoreStyle, "corefile-style", CommandCompletions::eNoCompletion, g_corefile_save_style, { nullptr, false }, "The type of corefile that lldb will try to create, dependant on this target's capabilities." }, 315 { lldb::eArgTypeLogHandler, "log-handler", CommandCompletions::eNoCompletion, g_log_handler_type ,{ nullptr, false }, "The log handle that will be used to write out log messages." }, 316 { lldb::eArgTypeSEDStylePair, "substitution-pair", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A sed-style pattern and target pair." }, 317 { lldb::eArgTypeRecognizerID, "frame-recognizer-id", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The ID for a stack frame recognizer." }, 318 { lldb::eArgTypeConnectURL, "process-connect-url", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "A URL-style specification for a remote connection." }, 319 { lldb::eArgTypeTargetID, "target-id", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The index ID for an lldb Target." }, 320 { lldb::eArgTypeStopHookID, "stop-hook-id", CommandCompletions::eNoCompletion, {}, { nullptr, false }, "The ID you receive when you create a stop-hook." }, 321 { lldb::eArgTypeReproducerProvider, "reproducer-provider", CommandCompletions::eNoCompletion, g_reproducer_provider_type, { nullptr, false }, "The reproducer provider." }, 322 { lldb::eArgTypeReproducerSignal, "reproducer-signal", CommandCompletions::eNoCompletion, g_reproducer_signaltype, { nullptr, false }, "The signal used to emulate a reproducer crash." }, 323 // clang-format on 324 }; 325 326 static_assert((sizeof(g_argument_table) / 327 sizeof(CommandObject::ArgumentTableEntry)) == 328 lldb::eArgTypeLastArg, 329 "number of elements in g_argument_table doesn't match " 330 "CommandArgumentType enumeration"); 331 332 } // namespace lldb_private 333 334 #endif // LLDB_INTERPRETER_COMMANDOPTIONARGUMENTTABLE_H 335