|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/lldb/include/lldb/Interpreter/OptionValueArch.h 18 class OptionValueArch : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueArray.h 18 class OptionValueArray : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueBoolean.h 16 class OptionValueBoolean : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueChar.h 16 class OptionValueChar : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueDictionary.h 18 class OptionValueDictionary : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueEnumeration.h 22 class OptionValueEnumeration : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueFileSpec.h 19 class OptionValueFileSpec : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueFileSpecList.h 19 class OptionValueFileSpecList : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueFormat.h 16 class OptionValueFormat : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueFormatEntity.h 17 class OptionValueFormatEntity : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueLanguage.h 18 class OptionValueLanguage : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValuePathMappings.h 17 class OptionValuePathMappings : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueProperties.h 22 class OptionValueProperties
tools/lldb/include/lldb/Interpreter/OptionValueRegex.h 17 class OptionValueRegex : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueSInt64.h 17 class OptionValueSInt64 : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueString.h 20 class OptionValueString : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueUInt64.h 17 class OptionValueUInt64 : public OptionValue {
tools/lldb/include/lldb/Interpreter/OptionValueUUID.h 17 class OptionValueUUID : public OptionValue {
Declarations
tools/lldb/include/lldb/lldb-forward.h 143 class OptionValue;
References
gen/tools/lldb/source/Core/CoreProperties.inc 12 {"auto-confirm", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true all confirmation prompts will receive their default reply."},
13 {"auto-indent", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true)."},
14 {"auto-one-line-summaries", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will automatically display small structs in one-liner format (default: true)."},
15 {"disassembly-format", OptionValue::eTypeFormatEntity, true, 0, "{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\\n}{${function.changed}\\n{${module.file.basename}`}{${function.name-without-args}}:\\n}{${current-pc-arrow} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}: ", {}, "The default disassembly format string to use when disassembling instruction sequences."},
16 {"escape-non-printables", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will automatically escape non-printable and escape characters when formatting strings."},
17 {"frame-format", OptionValue::eTypeFormatEntity, true, 0, "frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\n", {}, "The default frame format string to use when displaying stack frame information for threads."},
18 {"frame-format-unique", OptionValue::eTypeFormatEntity, true, 0, "frame #${frame.index}: ${ansi.fg.yellow}${frame.pc}${ansi.normal}{ ${module.file.basename}{`${function.name-without-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\n", {}, "The default frame format string to use when displaying stack frameinformation for threads from thread backtrace unique."},
19 {"highlight-source", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will highlight the displayed source code."},
20 {"notify-void", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "Notify the user explicitly if an expression returns void (default: false)."},
21 {"print-decls", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true)."},
22 {"prompt", OptionValue::eTypeString, true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", {}, "The debugger command line prompt displayed for the user."},
23 {"script-lang", OptionValue::eTypeEnum, true, eScriptLanguagePython, nullptr, OptionEnumValues(g_language_enumerators), "The script language to be used for evaluating user-written scripts."},
24 {"stop-disassembly-count", OptionValue::eTypeSInt64, true, 4, nullptr, {}, "The number of disassembly lines to show when displaying a stopped context."},
25 {"stop-disassembly-display", OptionValue::eTypeEnum, true, Debugger::eStopDisassemblyTypeNoDebugInfo, nullptr, OptionEnumValues(g_show_disassembly_enum_values), "Control when to display disassembly when displaying a stopped context."},
26 {"stop-line-count-after", OptionValue::eTypeSInt64, true, 3, nullptr, {}, "The number of sources lines to display that come after the current source line when displaying a stopped context."},
27 {"stop-line-count-before", OptionValue::eTypeSInt64, true, 3, nullptr, {}, "The number of sources lines to display that come before the current source line when displaying a stopped context."},
28 {"stop-show-column", OptionValue::eTypeEnum, false, eStopShowColumnAnsiOrCaret, nullptr, OptionEnumValues(s_stop_show_column_values), "If true, LLDB will use the column information from the debug info to mark the current position when displaying a stopped context."},
29 {"stop-show-column-ansi-prefix", OptionValue::eTypeString, true, 0, "${ansi.underline}", {}, "When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the column to be marked."},
30 {"stop-show-column-ansi-suffix", OptionValue::eTypeString, true, 0, "${ansi.normal}", {}, "When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the column to be marked."},
31 {"tab-size", OptionValue::eTypeUInt64, true, 4, nullptr, {}, "The tab size to use when indenting code in multi-line input mode (default: 4)."},
32 {"term-width", OptionValue::eTypeSInt64, true, 80, nullptr, {}, "The maximum number of columns to use for displaying text."},
33 {"thread-format", OptionValue::eTypeFormatEntity, true, 0, "thread #${thread.index}: tid = ${thread.id%tid}{, ${frame.pc}}{ ${module.file.basename}{`${function.name-with-args}{${frame.no-debug}${function.pc-offset}}}}{ at ${ansi.fg.cyan}${line.file.basename}${ansi.normal}:${ansi.fg.yellow}${line.number}${ansi.normal}{:${ansi.fg.yellow}${line.column}${ansi.normal}}}{, name = ${ansi.fg.green}'${thread.name}'${ansi.normal}}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\nReturn value: ${thread.return-value}}{\\nCompleted expression: ${thread.completed-expression}}\\n", {}, "The default thread format string to use when displaying thread information."},
34 {"thread-stop-format", OptionValue::eTypeFormatEntity, true, 0, "thread #${thread.index}{, name = '${thread.name}'}{, queue = ${ansi.fg.green}'${thread.queue}'${ansi.normal}}{, activity = ${ansi.fg.green}'${thread.info.activity.name}'${ansi.normal}}{, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}${thread.stop-reason}${ansi.normal}}{\\nReturn value: ${thread.return-value}}{\\nCompleted expression: ${thread.completed-expression}}\\n", {}, "The default thread format string to use when displaying thread information as part of the stop display."},
35 {"use-color", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "Whether to use Ansi color codes or not."},
36 {"use-external-editor", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "Whether to use an external editor or not."},
44 {"clang-modules-cache-path", OptionValue::eTypeFileSpec, true, 0, "", {}, "The path to the clang modules cache directory (-fmodules-cache-path)."},
45 {"enable-external-lookup", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "Control the use of external tools and repositories to locate symbol files. Directories listed in target.debug-file-search-paths and directory of the executable are always checked first for separate debug info files. Then depending on this setting: On macOS, Spotlight would be also used to locate a matching .dSYM bundle based on the UUID of the executable. On NetBSD, directory /usr/libdata/debug would be also searched. On platforms other than NetBSD directory /usr/lib/debug would be also searched."},
gen/tools/lldb/source/Interpreter/InterpreterProperties.inc 12 {"echo-commands", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, commands will be echoed before they are evaluated."},
13 {"echo-comment-commands", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, commands will be echoed even if they are pure comment lines."},
14 {"expand-regex-aliases", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands."},
15 {"prompt-on-quit", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case."},
16 {"space-repl-prompts", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, blank lines will be printed between between REPL submissions."},
17 {"stop-command-source-on-error", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, LLDB will stop running a 'command source' script upon encountering an error."},
gen/tools/lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernelProperties.inc 12 {"load-kexts", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "Automatically loads kext images when attaching to a kernel."},
13 {"scan-type", OptionValue::eTypeEnum, true, eKASLRScanNearPC, nullptr, OptionEnumValues(g_kaslr_kernel_scan_enum_values), "Control how many reads lldb will make while searching for a Darwin kernel on attach."},
gen/tools/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDBProperties.inc 12 {"enable", OptionValue::eTypeEnum, true, eEnableJITLoaderGDBDefault, nullptr, OptionEnumValues(g_enable_jit_loader_gdb_enumerators), "Enable GDB's JIT compilation interface (default: enabled on all platforms except macOS)"},
gen/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemoteProperties.inc 12 {"packet-timeout", OptionValue::eTypeUInt64, true, 5, nullptr, {}, "Specify the default packet timeout in seconds."},
13 {"target-definition-file", OptionValue::eTypeFileSpec, true, 0, "", {}, "The file that provides the description for remote target registers."},
14 {"use-libraries-svr4", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, the libraries-svr4 feature will be used to get a hold of the process's loaded modules."},
gen/tools/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLogProperties.inc 12 {"auto-enable-options", OptionValue::eTypeString, true, 0, "", {}, "Specify the options to 'plugin structured-data darwin-log enable' that should be applied when automatically enabling logging on startup/attach."},
13 {"enable-on-startup", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "Enable Darwin os_log collection when debugged process is launched or attached."},
gen/tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFProperties.inc 12 {"ignore-file-indexes", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "Ignore indexes present in the object files and always index DWARF manually."},
13 {"comp-dir-symlink-paths", OptionValue::eTypeFileSpecList, true, 0, "", {}, "If the DW_AT_comp_dir matches any of these paths the symbolic links will be resolved at DWARF parse time."},
gen/tools/lldb/source/Target/TargetProperties.inc 12 {"inject-local-vars", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, inject local variables explicitly into the expression text. This will fix symbol resolution when there are name collisions between ivars and local variables. But it can make expressions run much more slowly."},
13 {"use-modern-type-lookup", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, use Clang's modern type lookup infrastructure."},
21 {"module-cache-directory", OptionValue::eTypeFileSpec, true, 0, "", {}, "Root directory for cached modules."},
22 {"use-module-cache", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "Use module cache."},
30 {"detach-keeps-stopped", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, detach will attempt to keep the process stopped."},
31 {"disable-memory-cache", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable reading and caching of memory in fixed-size units."},
32 {"extra-startup-command", OptionValue::eTypeArray, false, 16, nullptr, {}, "A list containing extra commands understood by the particular process plugin used. For instance, to turn on debugserver logging set this to 'QSetLogging:bitmask=LOG_DEFAULT;'"},
33 {"ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, breakpoints will be ignored during expression evaluation."},
34 {"memory-cache-line-size", OptionValue::eTypeUInt64, false, 512, nullptr, {}, "The memory cache line size"},
35 {"python-os-plugin-path", OptionValue::eTypeFileSpec, false, 1, nullptr, {}, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class."},
36 {"stop-on-exec", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, stop when a shared library is loaded or unloaded."},
37 {"stop-on-sharedlibrary-events", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, stop when a shared library is loaded or unloaded."},
38 {"unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, errors in expression evaluation will unwind the stack back to the state before the call."},
39 {"utility-expression-timeout", OptionValue::eTypeUInt64, false, 15, nullptr, {}, "The time in seconds to wait for LLDB-internal utility expressions."},
40 {"optimization-warnings", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected."},
48 {"arg0", OptionValue::eTypeString, false, 0, "", {}, "The first argument passed to the program in the argument array which can be different from the executable itself."},
49 {"auto-apply-fixits", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Automatically apply fix-it hints to expressions."},
50 {"auto-import-clang-modules", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Automatically load Clang modules referred to by the program."},
51 {"breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Consult the platform module avoid list when setting non-module specific breakpoints."},
52 {"clang-module-search-paths", OptionValue::eTypeFileSpecList, false, 0, "", {}, "List of directories to be searched when locating modules for Clang."},
53 {"debug-file-search-paths", OptionValue::eTypeFileSpecList, false, 0, "", {}, "List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup."},
54 {"default-arch", OptionValue::eTypeArch, true, 0, "", {}, "Default architecture to choose, when there's a choice."},
55 {"detach-on-error", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "debugserver will detach (rather than killing) a process if it loses connection with lldb."},
56 {"disable-aslr", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Disable Address Space Layout Randomization (ASLR)"},
57 {"disable-stdio", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable stdin/stdout for process (e.g. for a GUI application)"},
58 {"x86-disassembly-flavor", OptionValue::eTypeEnum, false, eX86DisFlavorDefault, nullptr, OptionEnumValues(g_x86_dis_flavor_value_types), "The default disassembly flavor to use for x86 or x86-64 targets."},
59 {"display-expression-in-crashlogs", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true."},
60 {"display-recognized-arguments", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Show recognized arguments in variable listings by default."},
61 {"display-runtime-support-values", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "If true, LLDB will show variables that are meant to support the operation of a language's runtime support."},
62 {"enable-synthetic-value", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Should synthetic values be used by default whenever available."},
63 {"env-vars", OptionValue::eTypeDictionary, false, 16, nullptr, {}, "A list of all the environment variables to be passed to the executable's environment, and their values."},
64 {"error-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for writing its standard error."},
65 {"exec-search-paths", OptionValue::eTypeFileSpecList, false, 0, "", {}, "Executable search paths to use when locating executable files whose paths don't match the local file system."},
66 {"expr-prefix", OptionValue::eTypeFileSpec, false, 0, "", {}, "Path to a file containing expressions to be prepended to all expressions."},
67 {"hex-immediate-style", OptionValue::eTypeEnum, false, Disassembler::eHexStyleC, nullptr, OptionEnumValues(g_hex_immediate_style_values), "Which style to use for printing hexadecimal disassembly values."},
68 {"import-std-module", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Import the C++ std module to improve debugging STL containers."},
69 {"inherit-env", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Inherit the environment from the process that is running LLDB."},
70 {"inline-breakpoint-strategy", OptionValue::eTypeEnum, false, eInlineBreakpointsAlways, nullptr, OptionEnumValues(g_inline_breakpoint_enums), "The strategy to use when settings breakpoints by file and line. Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers and find that setting breakpoints is slow, then you can change this setting to headers. This setting allows you to control exactly which strategy is used when setting file and line breakpoints."},
71 {"input-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for reading its standard input."},
72 {"language", OptionValue::eTypeLanguage, false, eLanguageTypeUnknown, nullptr, {}, "The language to use when interpreting expressions entered in commands."},
73 {"load-cwd-lldbinit", OptionValue::eTypeEnum, false, eLoadCWDlldbinitWarn, nullptr, OptionEnumValues(g_load_cwd_lldbinit_values), "Allow LLDB to .lldbinit files from the current directory automatically."},
74 {"load-script-from-symbol-file", OptionValue::eTypeEnum, false, eLoadScriptFromSymFileWarn, nullptr, OptionEnumValues(g_load_script_from_sym_file_values), "Allow LLDB to load scripting resources embedded in symbol files when available."},
75 {"max-children-count", OptionValue::eTypeSInt64, false, 256, nullptr, {}, "Maximum number of children to expand in any level of depth."},
76 {"max-memory-read-size", OptionValue::eTypeSInt64, false, 1024, nullptr, {}, "Maximum number of bytes that 'memory read' will fetch before --force must be specified."},
77 {"max-string-summary-length", OptionValue::eTypeSInt64, false, 1024, nullptr, {}, "Maximum number of characters to show when using %s in summary strings."},
78 {"max-zero-padding-in-float-format", OptionValue::eTypeUInt64, false, 6, nullptr, {}, "The maximum number of zeroes to insert when displaying a very small float before falling back to scientific notation."},
79 {"memory-module-load-level", OptionValue::eTypeEnum, false, eMemoryModuleLoadLevelComplete, nullptr, OptionEnumValues(g_memory_module_load_level_values), "Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. This setting helps users control how much information gets loaded when loading modules from memory.'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). 'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). 'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). "},
80 {"move-to-nearest-code", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Move breakpoints to nearest code."},
81 {"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable lock-step debugging, instead control threads independently."},
82 {"notify-about-fixits", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Print the fixed expression text."},
83 {"output-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for writing its standard output."},
84 {"prefer-dynamic-value", OptionValue::eTypeEnum, false, eDynamicDontRunTarget, nullptr, OptionEnumValues(g_dynamic_value_types), "Should printed values be shown as their dynamic value."},
85 {"preload-symbols", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Enable loading of symbol tables before they are needed."},
86 {"require-hardware-breakpoint", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Require all breakpoints to be hardware breakpoints."},
87 {"run-args", OptionValue::eTypeArgs, false, 0, "", {}, "A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0."},
88 {"save-jit-objects", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Save intermediate object files generated by the LLVM JIT"},
89 {"skip-prologue", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Skip function prologues when setting breakpoints by name."},
90 {"source-map", OptionValue::eTypePathMap, false, 0, "", {}, "Source path remappings are used to track the change of location between a source file when built, and where it exists on the current system. It consists of an array of duples, the first element of each duple is some part (starting at the root) of the path to the file when it was built, and the second is where the remainder of the original build hierarchy is rooted on the local system. Each element of the array is checked in order and the first one that results in a match wins."},
91 {"trap-handler-names", OptionValue::eTypeArray, true, 16, nullptr, {}, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp."},
92 {"use-fast-stepping", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping."},
93 {"use-hex-immediates", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Show immediates in disassembly as hexadecimal."},
101 {"trace-thread", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "If true, this thread will single-step and log execution."},
102 {"max-backtrace-depth", OptionValue::eTypeUInt64, false, 300000, nullptr, {}, "Maximum number of frames to backtrace."},
103 {"step-avoid-libraries", OptionValue::eTypeFileSpecList, true, 0, "", {}, "A list of libraries that source stepping won't stop in."},
104 {"step-avoid-regexp", OptionValue::eTypeRegex, true, 0, "^std::", {}, "A regular expression defining functions step-in won't stop in."},
105 {"step-in-avoid-nodebug", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, step-in will not stop in functions with no debug information."},
106 {"step-out-avoid-nodebug", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, when step-in/step-out/step-over leave the current frame, they will continue to step out till they come to a function with debug information. Passing a frame argument to step-out will override this option."},
tools/lldb/include/lldb/Core/Disassembler.h 162 OptionValue::Type data_type);
tools/lldb/include/lldb/Interpreter/OptionValue.h 64 OptionValue(const OptionValue &rhs)
122 static uint32_t ConvertTypeToMask(OptionValue::Type type) {
126 static OptionValue::Type ConvertTypeMaskToType(uint32_t type_mask) {
tools/lldb/include/lldb/Interpreter/OptionValueArch.h 18 class OptionValueArch : public OptionValue {
38 OptionValue::Type GetType() const override { return eTypeArch; }
tools/lldb/include/lldb/Interpreter/OptionValueArgs.h 20 OptionValue::ConvertTypeToMask(OptionValue::eTypeString)) {}
20 OptionValue::ConvertTypeToMask(OptionValue::eTypeString)) {}
tools/lldb/include/lldb/Interpreter/OptionValueArray.h 18 class OptionValueArray : public OptionValue {
27 OptionValue::Type GetType() const override { return eTypeArray; }
tools/lldb/include/lldb/Interpreter/OptionValueBoolean.h 16 class OptionValueBoolean : public OptionValue {
28 OptionValue::Type GetType() const override { return eTypeBoolean; }
tools/lldb/include/lldb/Interpreter/OptionValueChar.h 16 class OptionValueChar : public OptionValue {
29 OptionValue::Type GetType() const override { return eTypeChar; }
tools/lldb/include/lldb/Interpreter/OptionValueDictionary.h 18 class OptionValueDictionary : public OptionValue {
29 OptionValue::Type GetType() const override { return eTypeDictionary; }
tools/lldb/include/lldb/Interpreter/OptionValueEnumeration.h 22 class OptionValueEnumeration : public OptionValue {
38 OptionValue::Type GetType() const override { return eTypeEnum; }
tools/lldb/include/lldb/Interpreter/OptionValueFileSpec.h 19 class OptionValueFileSpec : public OptionValue {
32 OptionValue::Type GetType() const override { return eTypeFileSpec; }
tools/lldb/include/lldb/Interpreter/OptionValueFileSpecList.h 19 class OptionValueFileSpecList : public OptionValue {
30 OptionValue::Type GetType() const override { return eTypeFileSpecList; }
tools/lldb/include/lldb/Interpreter/OptionValueFormat.h 16 class OptionValueFormat : public OptionValue {
29 OptionValue::Type GetType() const override { return eTypeFormat; }
tools/lldb/include/lldb/Interpreter/OptionValueFormatEntity.h 17 class OptionValueFormatEntity : public OptionValue {
25 OptionValue::Type GetType() const override { return eTypeFormatEntity; }
tools/lldb/include/lldb/Interpreter/OptionValueLanguage.h 18 class OptionValueLanguage : public OptionValue {
32 OptionValue::Type GetType() const override { return eTypeLanguage; }
tools/lldb/include/lldb/Interpreter/OptionValuePathMappings.h 17 class OptionValuePathMappings : public OptionValue {
26 OptionValue::Type GetType() const override { return eTypePathMap; }
tools/lldb/include/lldb/Interpreter/OptionValueProperties.h 23 : public OptionValue,
tools/lldb/include/lldb/Interpreter/OptionValueRegex.h 17 class OptionValueRegex : public OptionValue {
26 OptionValue::Type GetType() const override { return eTypeRegex; }
tools/lldb/include/lldb/Interpreter/OptionValueSInt64.h 17 class OptionValueSInt64 : public OptionValue {
41 OptionValue::Type GetType() const override { return eTypeSInt64; }
tools/lldb/include/lldb/Interpreter/OptionValueString.h 20 class OptionValueString : public OptionValue {
76 OptionValue::Type GetType() const override { return eTypeString; }
tools/lldb/include/lldb/Interpreter/OptionValueUInt64.h 17 class OptionValueUInt64 : public OptionValue {
38 OptionValue::Type GetType() const override { return eTypeUInt64; }
tools/lldb/include/lldb/Interpreter/OptionValueUUID.h 17 class OptionValueUUID : public OptionValue {
27 OptionValue::Type GetType() const override { return eTypeUUID; }
tools/lldb/include/lldb/Interpreter/Property.h 26 OptionValue::Type type;
tools/lldb/include/lldb/Target/Process.h 89 OptionValue *option_value);
tools/lldb/include/lldb/Target/Target.h 215 OptionValue *);
217 OptionValue *);
219 OptionValue *);
221 OptionValue *);
223 OptionValue *);
225 OptionValue *);
227 OptionValue *);
229 OptionValue *);
231 OptionValue *);
233 OptionValue *);
tools/lldb/include/lldb/lldb-forward.h 366 typedef std::shared_ptr<lldb_private::OptionValue> OptionValueSP;
367 typedef std::weak_ptr<lldb_private::OptionValue> OptionValueWP;
tools/lldb/include/lldb/lldb-private-interfaces.h 86 OptionValue *option_value);
tools/lldb/source/API/SBDebugger.cpp 1274 value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
tools/lldb/source/Commands/CommandCompletions.cpp 305 properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
tools/lldb/source/Commands/CommandObjectRegister.cpp 231 set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
231 set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
tools/lldb/source/Commands/CommandObjectSettings.cpp 284 OptionValue::eDumpGroupValue));
294 OptionValue::eDumpGroupValue);
398 OptionValue::eDumpGroupExport);
404 &clean_ctx, out_file, arg.ref(), OptionValue::eDumpGroupExport));
tools/lldb/source/Core/Disassembler.cpp 362 if (value_sp && value_sp->GetType() == OptionValue::eTypeRegex) {
777 OptionValue::Type data_type) {
817 case OptionValue::eTypeUInt64:
841 OptionValue::Type data_type = OptionValue::eTypeInvalid;
841 OptionValue::Type data_type = OptionValue::eTypeInvalid;
912 data_type = OptionValue::eTypeInvalid;
929 data_type = OptionValue::eTypeUInt64;
tools/lldb/source/Interpreter/OptionValue.cpp 23 case OptionValue::eTypeBoolean:
25 case OptionValue::eTypeSInt64:
27 case OptionValue::eTypeUInt64:
46 if (GetType() == OptionValue::eTypeBoolean)
52 if (GetType() == OptionValue::eTypeBoolean)
58 if (GetType() == OptionValue::eTypeChar)
64 if (GetType() == OptionValue::eTypeChar)
70 if (GetType() == OptionValue::eTypeFileSpec)
76 if (GetType() == OptionValue::eTypeFileSpec)
82 if (GetType() == OptionValue::eTypeFileSpecList)
88 if (GetType() == OptionValue::eTypeFileSpecList)
94 if (GetType() == OptionValue::eTypeArch)
100 if (GetType() == OptionValue::eTypeArch)
106 if (GetType() == OptionValue::eTypeArray)
112 if (GetType() == OptionValue::eTypeArray)
118 if (GetType() == OptionValue::eTypeArgs)
124 if (GetType() == OptionValue::eTypeArgs)
130 if (GetType() == OptionValue::eTypeDictionary)
136 if (GetType() == OptionValue::eTypeDictionary)
142 if (GetType() == OptionValue::eTypeEnum)
148 if (GetType() == OptionValue::eTypeEnum)
154 if (GetType() == OptionValue::eTypeFormat)
160 if (GetType() == OptionValue::eTypeFormat)
166 if (GetType() == OptionValue::eTypeLanguage)
172 if (GetType() == OptionValue::eTypeLanguage)
178 if (GetType() == OptionValue::eTypeFormatEntity)
184 if (GetType() == OptionValue::eTypeFormatEntity)
190 if (GetType() == OptionValue::eTypePathMap)
196 if (GetType() == OptionValue::eTypePathMap)
202 if (GetType() == OptionValue::eTypeProperties)
208 if (GetType() == OptionValue::eTypeProperties)
214 if (GetType() == OptionValue::eTypeRegex)
220 if (GetType() == OptionValue::eTypeRegex)
226 if (GetType() == OptionValue::eTypeSInt64)
232 if (GetType() == OptionValue::eTypeSInt64)
238 if (GetType() == OptionValue::eTypeString)
244 if (GetType() == OptionValue::eTypeString)
250 if (GetType() == OptionValue::eTypeUInt64)
256 if (GetType() == OptionValue::eTypeUInt64)
262 if (GetType() == OptionValue::eTypeUUID)
268 if (GetType() == OptionValue::eTypeUUID)
tools/lldb/source/Interpreter/OptionValueDictionary.cpp 41 OptionValue *option_value = pos->second.get();
tools/lldb/source/Interpreter/OptionValueProperties.cpp 286 OptionValue *value = property->GetValue().get();
305 OptionValue *value = property->GetValue().get();
324 OptionValue *value = property->GetValue().get();
335 OptionValue *value = property->GetValue().get();
357 OptionValue *value = property->GetValue().get();
368 OptionValue *value = property->GetValue().get();
380 OptionValue *value = property->GetValue().get();
392 OptionValue *value = property->GetValue().get();
403 OptionValue *value = property->GetValue().get();
415 OptionValue *value = property->GetValue().get();
427 OptionValue *value = property->GetValue().get();
438 OptionValue *value = property->GetValue().get();
449 OptionValue *value = property->GetValue().get();
460 OptionValue *value = property->GetValue().get();
472 OptionValue *value = property->GetValue().get();
483 OptionValue *value = property->GetValue().get();
502 OptionValue *value = property->GetValue().get();
513 OptionValue *value = property->GetValue().get();
558 OptionValue *option_value = property->GetValue().get();
tools/lldb/source/Interpreter/Property.cpp 27 case OptionValue::eTypeInvalid:
28 case OptionValue::eTypeProperties:
30 case OptionValue::eTypeArch:
38 case OptionValue::eTypeArgs:
43 case OptionValue::eTypeArray:
46 std::make_shared<OptionValueArray>(OptionValue::ConvertTypeToMask(
50 case OptionValue::eTypeBoolean:
64 case OptionValue::eTypeChar: {
70 case OptionValue::eTypeDictionary:
73 std::make_shared<OptionValueDictionary>(OptionValue::ConvertTypeToMask(
77 case OptionValue::eTypeEnum:
102 case OptionValue::eTypeFileSpec: {
113 case OptionValue::eTypeFileSpecList:
119 case OptionValue::eTypeFormat:
135 case OptionValue::eTypeLanguage:
151 case OptionValue::eTypeFormatEntity:
158 case OptionValue::eTypePathMap:
165 case OptionValue::eTypeRegex:
173 case OptionValue::eTypeSInt64:
184 case OptionValue::eTypeUInt64:
195 case OptionValue::eTypeUUID:
206 case OptionValue::eTypeString:
239 const bool dump_desc = dump_mask & OptionValue::eDumpOptionDescription;
240 const bool dump_cmd = dump_mask & OptionValue::eDumpOptionCommand;
245 if ((dump_mask & OptionValue::eDumpOptionName) && m_name) {
247 if (dump_mask & ~OptionValue::eDumpOptionName)
256 if (transparent && (dump_mask == (OptionValue::eDumpOptionName |
257 OptionValue::eDumpOptionDescription)))
tools/lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp14404 (value_sp->GetType() != OptionValue::eTypeUInt64)) {
14430 (value_sp->GetType() != OptionValue::eTypeDictionary)) {
14443 (value_sp->GetType() != OptionValue::eTypeDictionary)) {
tools/lldb/source/Target/Process.cpp 147 OptionValue *option_value) {
tools/lldb/source/Target/Target.cpp 4000 OptionValue *) {
4007 OptionValue *) {
4016 OptionValue *) {
4023 OptionValue *) {
4031 OptionValue *) {
4039 OptionValue *) {
4047 void *target_property_ptr, OptionValue *) {
4057 void *target_property_ptr, OptionValue *) {
4067 void *target_property_ptr, OptionValue *) {
usr/include/c++/7.4.0/bits/shared_ptr.h 93 class shared_ptr : public __shared_ptr<_Tp>
107 using element_type = typename __shared_ptr<_Tp>::element_type;
236 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
253 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
299 _Assignable<const shared_ptr<_Yp>&>
300 operator=(const shared_ptr<_Yp>& __r) noexcept
324 _Assignable<shared_ptr<_Yp>>
325 operator=(shared_ptr<_Yp>&& __r) noexcept
352 shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
520 class weak_ptr : public __weak_ptr<_Tp>
537 weak_ptr(const shared_ptr<_Yp>& __r) noexcept
556 _Assignable<const weak_ptr<_Yp>&>
557 operator=(const weak_ptr<_Yp>& __r) noexcept
564 _Assignable<const shared_ptr<_Yp>&>
565 operator=(const shared_ptr<_Yp>& __r) noexcept
575 _Assignable<weak_ptr<_Yp>>
576 operator=(weak_ptr<_Yp>&& __r) noexcept
582 shared_ptr<_Tp>
usr/include/c++/7.4.0/bits/shared_ptr_base.h 882 : is_convertible<_Yp*, _Tp*>::type
882 : is_convertible<_Yp*, _Tp*>::type
946 : is_convertible<_Yp*, _Tp*>::type
956 using element_type = _Tp;
1035 : public __shared_ptr_access<_Tp, _Lp>
1038 using element_type = typename remove_extent<_Tp>::type;
1126 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1138 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1192 _Assignable<_Yp>
1193 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1218 _Assignable<_Yp>
1219 operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1272 swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
1344 __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
1601 using element_type = typename remove_extent<_Tp>::type;
1626 __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
1631 __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1640 __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
1648 _Assignable<_Yp>
1649 operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
1657 _Assignable<_Yp>
1658 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1675 _Assignable<_Yp>
1676 operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
1684 __shared_ptr<_Tp, _Lp>
1720 _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1942 { typedef _Tp type; };