Settings#

This page lists all possible settings in LLDB. Settings can be set using settings set <name> <value>. Values can be added to arrays and dictionaries with settings append -- <name> <value>.

Note

Some settings only exist for particular LLDB build configurations and so will not be present in all copies of LLDB.

auto-confirmBoolean#

If true all confirmation prompts will receive their default reply.

Default:
false
auto-indentBoolean#

If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true).

Default:
true
auto-one-line-summariesBoolean#

If true, LLDB will automatically display small structs in one-liner format (default: true).

Default:
true
disable-ansi-prefixString#

If something has been disabled in a color-enabled terminal, use the ANSI terminal code specified immediately before whatever has been disabled.

Default:
${ansi.faint}
disable-ansi-suffixString#

When something has been disabled in a color-enabled terminal, use the ANSI terminal code specified immediately after whatever has been disabled.

Default:
${ansi.normal}
disassembly-formatFormatEntity#

The default disassembly format string to use when disassembling instruction sequences.

Default:
{${function.initial-function}{${module.file.basename}}{${function.name-without-args}}:\\n}{${function.changed}\\n{${module.file.basename}}{${function.name-without-args}}:\n}{${ansi.fg.yellow}${current-pc-arrow}${ansi.normal} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}:
dwim-print-verbosityEnum#

The verbosity level used by dwim-print.

escape-non-printablesBoolean#

If true, LLDB will automatically escape non-printable and escape characters when formatting strings.

Default:
true
external-editorString#

External editor to use when use-external-editor is enabled.

frame-formatFormatEntity#

The default frame format string to use when displaying stack frame information for threads.

Default:
frame #${frame.index}: {${ansi.fg.cyan}${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}}}${frame.kind}{${function.is-optimized} [opt]}{${function.is-inlined} [inlined]}{${frame.is-artificial} [artificial]}\n
frame-format-uniqueFormatEntity#

The default frame format string to use when displaying stack frame information for threads from thread backtrace unique.

Default:
frame #${frame.index}: {${ansi.fg.cyan}${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}}}${frame.kind}{${function.is-optimized} [opt]}{${function.is-inlined} [inlined]}{${frame.is-artificial} [artificial]}\n
highlight-sourceBoolean#

If true, LLDB will highlight the displayed source code.

Default:
true
mark-hidden-framesBoolean#

If true, LLDB will add a marker to delimit hidden frames in backtraces.

Default:
true
notify-voidBoolean#

Notify the user explicitly if an expression returns void (default: false).

Default:
false

If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true).

Default:
true
promptString#

The debugger command line prompt displayed for the user.

Default:
(lldb)
prompt-ansi-prefixString#

When in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the prompt.

Default:
${ansi.faint}
prompt-ansi-suffixString#

When in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the prompt.

Default:
${ansi.normal}
repl-langLanguage#

The language to use for the REPL.

script-langEnum#

The script language to be used for evaluating user-written scripts.

separatorString#

A separator used, e.g., in the status line.

Default:
│
show-autosuggestionBoolean#

If true, LLDB will show suggestions to complete the command the user typed. Suggestions may be accepted using Ctrl-F.

Default:
false
show-autosuggestion-ansi-prefixString#

When displaying suggestion in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the suggestion.

Default:
${ansi.faint}
show-autosuggestion-ansi-suffixString#

When displaying suggestion in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the suggestion.

Default:
${ansi.normal}
show-dont-use-po-hintBoolean#

If true, and object description was requested for a type that does not implement it, LLDB will print a hint telling the user to consider using p instead.

Default:
true
show-inline-diagnosticsBoolean#

Controls whether diagnostics can refer directly to the command input, drawing arrows to it. If false, diagnostics will echo the input.

Default:
false
show-progressBoolean#

Whether to show progress using Operating System Command (OSC) Sequences in supporting terminal emulators.

Default:
true
show-progress-ansi-prefixString#

When displaying progress in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the progress message.

Default:
${ansi.faint}
show-progress-ansi-suffixString#

When displaying progress in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the progress message.

Default:
${ansi.normal}
show-regex-match-ansi-prefixString#

When displaying a regex match in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the match.

Default:
${ansi.fg.red}
show-regex-match-ansi-suffixString#

When displaying a regex match in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the match.

Default:
${ansi.normal}
show-statuslineBoolean#

Whether to show a statusline at the bottom of the terminal (not supported on Windows).

Default:
true
statusline-formatFormatEntity#

The default statusline format string.

Default:
${ansi.negative}{${target.file.basename}|no target}{ ${separator}${line.file.basename}:${line.number}:${line.column}}{ ${separator}${thread.stop-reason}}{ ${separator}{${progress.count} }${progress.message}}
stop-disassembly-countUInt64#

The number of disassembly lines to show when displaying a stopped context.

Default:
4
stop-disassembly-displayEnum#

Control when to display disassembly when displaying a stopped context.

stop-disassembly-max-sizeUInt64#

The size limit to use when disassembling large functions (default: 32KB).

Default:
32000
stop-line-count-afterUInt64#

The number of sources lines to display that come after the current source line when displaying a stopped context.

Default:
3
stop-line-count-beforeUInt64#

The number of sources lines to display that come before the current source line when displaying a stopped context.

Default:
3
stop-show-columnEnum#

If true, LLDB will use the column information from the debug info to mark the current position when displaying a stopped context.

stop-show-column-ansi-prefixString#

When displaying the column marker in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the column to be marked.

Default:
${ansi.underline}
stop-show-column-ansi-suffixString#

When displaying the column marker in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the column to be marked.

Default:
${ansi.normal}
stop-show-line-ansi-prefixString#

When displaying the line marker in a color-enabled terminal, use the ANSI terminal code specified in this format immediately before the line to be marked.

Default:
${ansi.fg.yellow}
stop-show-line-ansi-suffixString#

When displaying the line marker in a color-enabled terminal, use the ANSI terminal code specified in this format immediately after the line to be marked.

Default:
${ansi.normal}
tab-sizeUInt64#

The tab size to use when indenting code in multi-line input mode (default: 2).

Default:
2
term-heightUInt64#

The number of rows used for displaying text.

Default:
24
term-widthUInt64#

The maximum number of columns to use for displaying text.

Default:
80
thread-formatFormatEntity#

The default thread format string to use when displaying thread information.

Default:
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
thread-stop-formatFormatEntity#

The default thread format string to use when displaying thread information as part of the stop display.

Default:
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
use-colorBoolean#

Whether to use Ansi color codes or not.

Default:
true
use-external-editorBoolean#

Whether to use an external editor or not.

Default:
false
use-source-cacheBoolean#

Whether to cache source files in memory or not.

Default:
true

interpreter#

interpreter.echo-commandsBoolean#

If true, commands will be echoed before they are evaluated.

Default:
true
interpreter.echo-comment-commandsBoolean#

If true, commands will be echoed even if they are pure comment lines.

Default:
true
interpreter.expand-regex-aliasesBoolean#

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.

Default:
false
interpreter.open-transcript-in-editorBoolean#

If true, LLDB will open the saved session’s transcripts in the external editor.

Default:
true
interpreter.prompt-on-quitBoolean#

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.

Default:
true
interpreter.repeat-previous-commandBoolean#

If true, LLDB will repeat the previous command if no command was passed to the interpreter. If false, LLDB won’t repeat the previous command but only return a new prompt.

Default:
true
interpreter.require-overwriteBoolean#

If true, require –overwrite in ‘command script add’ before overwriting existing user commands.

Default:
true
interpreter.save-session-directoryFileSpec#

A path where LLDB will save the session’s transcripts. This is particularly useful when you can’t set the session file, for example when using save-session-on-quit.

interpreter.save-session-on-quitBoolean#

If true, LLDB will save the session’s transcripts before quitting. Note: transcripts will only be saved if interpreter.save-transcript is true.

Default:
false
interpreter.save-transcriptBoolean#

If true, commands will be saved into a transcript buffer for user access.

Default:
false
interpreter.space-repl-promptsBoolean#

If true, blank lines will be printed between REPL submissions.

Default:
false
interpreter.stop-command-source-on-errorBoolean#

If true, LLDB will stop running a ‘command source’ script upon encountering an error.

Default:
true

language#

language.enable-filter-for-line-breakpointsBoolean#

If true, allow Language plugins to filter locations when setting breakpoints by line number or regex.

Default:
true

platform#

platform.module-cache-directoryFileSpec#

Root directory for cached modules.

platform.use-module-cacheBoolean#

Use module cache.

Default:
true

plugin#

darwin#

platform.plugin.darwin.ignored-exceptionsString#

List the mach exceptions to ignore, separated by ‘|’ (e.g. ‘EXC_BAD_ACCESS|EXC_BAD_INSTRUCTION’). lldb will instead stop on the BSD signal the exception was converted into, if there is one.

darwin-kernel#

platform.plugin.darwin-kernel.kext-directoriesFileSpecList#

Directories/KDKs to search for kexts in when starting a kernel debug session.

qemu-user#

platform.plugin.qemu-user.architectureString#

Architecture to emulate.

platform.plugin.qemu-user.emulator-argsArgs#

Extra arguments to pass to the emulator.

platform.plugin.qemu-user.emulator-env-varsDictionary#

Extra variables to add to the emulator environment.

platform.plugin.qemu-user.emulator-pathFileSpec#

Path to the emulator binary. If the path does not contain a directory separator, the filename is looked up in the PATH environment variable. If empty, the filename is derived from the architecture setting.

platform.plugin.qemu-user.target-env-varsDictionary#

Extra variables to add to emulated target environment.

remote-android#

platform.plugin.remote-android.package-nameString#

Specify package name to run adb shell command with ‘run-as’ as the package user when necessary (e.g. to get file with ‘cat’ and ‘dd’).

wasm#

platform.plugin.wasm.port-argString#

Argument to the WebAssembly runtime to specify the GDB remote port. The port number chosen by LLDB will be concatenated to this argument. For example: -g=127.0.0.1: or --debugger-port .

platform.plugin.wasm.runtime-argsArgs#

Extra arguments to pass to the WebAssembly runtime. For the argument that specifies the GDB remote port, use port-arg instead.

platform.plugin.wasm.runtime-pathFileSpec#

Path to the WebAssembly runtime binary. If the path does not contain a directory separator, the filename is looked up in the PATH environment variable.

plugin#

cplusplus#

display#

plugin.cplusplus.display.function-name-formatFormatEntity#

C++ specific frame format string to use when displaying stack frame information for threads.

Default:
${function.return-left}${function.scope}${ansi.fg.yellow}${function.basename}${ansi.normal}${function.template-arguments}${function.formatted-arguments}${function.return-right}${function.qualifiers}${function.suffix}

dynamic-loader#

darwin-kernel#

plugin.dynamic-loader.darwin-kernel.load-kextsBoolean#

Automatically loads kext images when attaching to a kernel.

Default:
true
plugin.dynamic-loader.darwin-kernel.scan-typeEnum#

Control how many reads lldb will make while searching for a Darwin kernel on attach.

jit-loader#

gdb#

plugin.jit-loader.gdb.enableEnum#

Enable GDB’s JIT compilation interface (default: enabled on all platforms except macOS)

object-file#

pe-coff#

plugin.object-file.pe-coff.abiEnum#

ABI to use when loading a PE/COFF module. This configures the C++ ABI used, which affects things like the handling of class layout. Accepted values are: msvc for the MSVC ABI, gnu for the MinGW / Itanium ABI, and default to follow the default target if it is a Windows triple or use the MSVC ABI by default.

plugin.object-file.pe-coff.module-abiDictionary#

A mapping of ABI override to use for specific modules. The module name is matched by its file name with extension. These versions are checked in sequence: exact, lowercase, exact with ‘.debug’ suffix stripped, lowercase with ‘.debug’ suffix stripped. Accepted values are: msvc for the MSVC ABI, gnu for the MinGW / Itanium ABI, and default to follow the default target if it is a Windows triple or use the MSVC ABI by default.

process#

freebsd-kernel-core#

plugin.process.freebsd-kernel-core.read-onlyBoolean#

Disable memory writes to the core. This is enabled by default for safety reasons.

Default:
true

gdb-remote#

plugin.process.gdb-remote.packet-timeoutUInt64#

Specify the default packet timeout in seconds.

Default:
5
plugin.process.gdb-remote.target-definition-fileFileSpec#

The file that provides the description for remote target registers.

plugin.process.gdb-remote.use-g-packet-for-readingBoolean#

Specify if the server should use ‘g’ packets to read registers.

Default:
false
plugin.process.gdb-remote.use-libraries-svr4Boolean#

If true, the libraries-svr4 feature will be used to get a hold of the process’s loaded modules. This setting is only effective if lldb was build with xml support.

Default:
true

kdp-remote#

plugin.process.kdp-remote.packet-timeoutUInt64#

Specify the default packet timeout in seconds.

Default:
5

structured-data#

darwin-log#

plugin.structured-data.darwin-log.auto-enable-optionsString#

Specify the options to ‘plugin structured-data darwin-log enable’ that should be applied when automatically enabling logging on startup/attach.

plugin.structured-data.darwin-log.enable-on-startupBoolean#

Enable Darwin os_log collection when debugged process is launched or attached.

Default:
false

symbol-file#

dwarf#

plugin.symbol-file.dwarf.ignore-file-indexesBoolean#

Ignore indexes present in the object files and always index DWARF manually.

Default:
false

pdb#

plugin.symbol-file.pdb.readerEnum#

Selects the reader for PDB symbol files. The native PDB reader that uses LLVM’s PDB support is always available (value: ‘native’). Secondly, the DIA PDB reader is only available if LLVM was compiled with Microsoft’s DIA SDK on Windows (value: ‘DIA’). By default, the DIA PDB reader is used if available. The LLDB_USE_NATIVE_PDB_READER environment variable can be used to switch to the native reader when this setting has the default value. Otherwise, the setting always has priority.

symbol-locator#

debuginfod#

plugin.symbol-locator.debuginfod.cache-pathString#

The path where symbol files should be cached. This defaults to LLDB’s system cache location.

plugin.symbol-locator.debuginfod.server-urlsArray#

An ordered list of Debuginfod server URLs to query for symbols. This defaults to the contents of the DEBUGINFOD_URLS environment variable.

plugin.symbol-locator.debuginfod.timeoutUInt64#

Timeout (in seconds) for requests made to a DEBUGINFOD server. A value of zero means we use the debuginfod default timeout: DEBUGINFOD_TIMEOUT if the environment variable is set and 90 seconds otherwise.

Default:
0

trace#

intel-pt#

plugin.trace.intel-pt.extremely-large-decoding-thresholdUInt64#

Specify how many instructions following an individual Intel PT packet must have been decoded before stopping the decoding of the corresponding PSB block. An error is hence emitted in the trace and decoding is resumed in the next PSB block.

Default:
500000
plugin.trace.intel-pt.infinite-decoding-loop-verification-thresholdUInt64#

Specify how many instructions following an individual Intel PT packet must have been decoded before triggering the verification of infinite decoding loops. If no decoding loop has been found after this threshold T, another attempt will be done after 2T instructions, then 4T, 8T and so on, which guarantees a total linear time spent checking this anomaly. If a loop is found, then decoding of the corresponding PSB block is stopped. An error is hence emitted in the trace and decoding is resumed in the next PSB block.

Default:
10000

symbols#

symbols.auto-downloadEnum#

On macOS, automatically download symbols with dsymForUUID (or an equivalent script/binary) for relevant images in the debug session.

symbols.clang-modules-cache-pathFileSpec#

The path to the clang modules cache directory (-fmodules-cache-path).

Debug info path which should be resolved while parsing, relative to the host filesystem.

symbols.enable-background-lookupBoolean#

Alias for backward compatibility: when enabled this is the equivalent to ‘symbols.auto-download background’.

Default:
false
symbols.enable-external-lookupBoolean#

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. If all other methods fail there may be symbol-locator plugins that, if configured properly, will also attempt to acquire symbols. The debuginfod plugin defaults to the DEGUFINFOD_URLS environment variable which is configurable through the ‘plugin.symbol-locator.debuginfod.server_urls’ setting.

Default:
true
symbols.enable-lldb-index-cacheBoolean#

Enable caching for debug sessions in LLDB. LLDB can cache data for each module for improved performance in subsequent debug sessions.

Default:
false
symbols.lldb-index-cache-expiration-daysUInt64#

The expiration time in days for a file. When a file hasn’t been accessed for the specified amount of days, it is removed from the cache. A value of 0 disables the expiration-based pruning.

Default:
7
symbols.lldb-index-cache-max-byte-sizeUInt64#

The maximum size for the LLDB index cache directory in bytes. A value over the amount of available space on the disk will be reduced to the amount of available space. A value of 0 disables the absolute size-based pruning.

Default:
0
symbols.lldb-index-cache-max-percentUInt64#

The maximum size for the cache directory in terms of percentage of the available space on the disk. Set to 100 to indicate no limit, 50 to indicate that the cache size will not be left over half the available disk space. A value over 100 will be reduced to 100. A value of 0 disables the percentage size-based pruning.

Default:
0
symbols.lldb-index-cache-pathFileSpec#

The path to the LLDB index cache directory.

symbols.load-on-demandBoolean#

Enable on demand symbol loading in LLDB. LLDB will load debug info on demand for each module based on various conditions (e.g. matched breakpoint, resolved stack frame addresses and matched global variables/function symbols in symbol table) to improve performance. Please refer to docs/use/ondemand.rst for details.

Default:
false
symbols.shared-cache-binary-loadingEnum#

On macOS, lldb can use its own in-memory shared cache, or operate on shared cache binaries directly, this setting controls which are used.

target#

target.arg0String#

The first argument passed to the program in the argument array which can be different from the executable itself.

target.auto-apply-fixitsBoolean#

Automatically apply fix-it hints to expressions.

Default:
true
target.auto-import-clang-modulesBoolean#

Automatically load Clang modules referred to by the program.

Default:
true
target.auto-install-main-executableBoolean#

Always install the main executable when connected to a remote platform.

Default:
true
target.auto-load-scripts-for-modulesDictionary#

A list of module/image names and whether LLDB should auto-load scripting resources for it from safe paths.

target.auto-source-map-relativeBoolean#

Automatically deduce source path mappings based on source file breakpoint resolution. It only deduces source mapping if source file breakpoint request is using full path and if the debug info contains relative paths.

Default:
true
target.breakpoints-use-platform-avoid-listBoolean#

Consult the platform module avoid list when setting non-module specific breakpoints.

Default:
true
target.clang-module-search-pathsFileSpecList#

List of directories to be searched when locating modules for Clang.

target.debug-file-search-pathsFileSpecList#

List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup.

target.debug-utility-expressionBoolean#

Enable debugging of LLDB-internal utility expressions.

Default:
false
target.default-archArch#

Default architecture to choose, when there’s a choice.

target.detach-on-errorBoolean#

debugserver will detach (rather than killing) a process if it loses connection with lldb.

Default:
true
target.disable-aslrBoolean#

Disable Address Space Layout Randomization (ASLR)

Default:
true
target.disable-stdioBoolean#

Disable stdin/stdout for process (e.g. for a GUI application)

Default:
false
target.disassembly-cpuString#

Override the CPU for disassembling. Takes the same values as the -mcpu clang flag.

target.disassembly-featuresString#

Specify additional CPU features for disassembling.

target.display-expression-in-crashlogsBoolean#

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.

Default:
false
target.display-recognized-argumentsBoolean#

Show recognized arguments in variable listings by default.

Default:
false
target.display-runtime-support-valuesBoolean#

If true, LLDB will show variables that are meant to support the operation of a language’s runtime support.

Default:
false
target.enable-synthetic-valueBoolean#

Should synthetic values be used by default whenever available.

Default:
true
target.env-varsDictionary#

A list of user provided environment variables to be passed to the executable’s environment, and their values.

target.error-pathFileSpec#

The file/path to be used by the executable program for writing its standard error.

target.exec-search-pathsFileSpecList#

Executable search paths to use when locating executable files whose paths don’t match the local file system.

target.expr-alloc-addressUInt64#

Start address within the process address space of memory allocation for expression evaluation.

Default:
0
target.expr-alloc-alignUInt64#

Alignment for each memory allocation for expression evaluation.

Default:
0
target.expr-alloc-sizeUInt64#

Amount of memory in bytes to allocate for expression evaluation.

Default:
0
target.expr-error-limitUInt64#

The maximum amount of errors to emit while parsing an expression. A value of 0 means to always continue parsing if possible.

Default:
5
target.expr-prefixFileSpec#

Path to a file containing expressions to be prepended to all expressions.

target.hex-immediate-styleEnum#

Which style to use for printing hexadecimal disassembly values.

target.import-std-moduleEnum#

Import the ‘std’ C++ module to improve expression parsing involving C++ standard library types.

target.inherit-envBoolean#

Inherit the environment from the process that is running LLDB.

Default:
true
target.inherit-tccBoolean#

Inherit the TCC permissions from the inferior’s parent instead of making the process itself responsible.

Default:
false
target.inline-breakpoint-strategyEnum#

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.

target.input-pathFileSpec#

The file/path to be used by the executable program for reading its standard input.

target.languageLanguage#

The language to use when interpreting expressions entered in commands.

target.launch-working-dirString#

A default value for the working directory to use when launching processes. It is ignored when empty. This setting is only used when the target is launched. If you change this setting, the new value will only apply to subsequent launches. Commands that take an explicit working directory will override this setting.

target.load-cwd-lldbinitEnum#

Allow LLDB to .lldbinit files from the current directory automatically.

target.load-script-from-symbol-fileEnum#

Allow LLDB to load scripting resources embedded in symbol files when available.

target.max-children-countUInt64#

Maximum number of children to expand in any level of depth.

Default:
24
target.max-children-depthUInt64#

Maximum depth to expand children.

Default:
5
target.max-memory-read-sizeUInt64#

Maximum number of bytes that ‘memory read’ will fetch before –force must be specified.

Default:
4294967295
target.max-string-summary-lengthUInt64#

Maximum number of characters to show when using %s in summary strings.

Default:
1024
target.max-zero-padding-in-float-formatUInt64#

The maximum number of zeroes to insert when displaying a very small float before falling back to scientific notation.

Default:
6
target.memory-module-load-levelEnum#

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).

target.move-to-nearest-codeBoolean#

Move breakpoints to nearest code.

Default:
true
target.notify-about-fixitsBoolean#

Print the fixed expression text.

Default:
true
target.objc-dynamic-class-extractorEnum#

Configure how LLDB parses dynamic Objective-C class metadata. By default LLDB will choose the most appropriate method for the target OS.

target.object-mapPathMap#

Object path remappings apply substitutions to the paths of object files, typically needed to debug from a different host than the one that built the target. The object-map property consists of an array of pairs, the first element is a path prefix, and the second is its replacement. The syntax is prefix1 replacement1 prefix2 replacement2.... The pairs are checked in order, the first prefix that matches is used, and that prefix is substituted with the replacement.

target.output-pathFileSpec#

The file/path to be used by the executable program for writing its standard output.

target.parallel-module-loadBoolean#

Enable loading of modules in parallel for the dynamic loader.

Default:
true
target.prefer-dynamic-valueEnum#

Should printed values be shown as their dynamic value.

target.preload-symbolsBoolean#

Enable loading of symbol tables before they are needed.

Default:
true
target.require-hardware-breakpointBoolean#

Require all breakpoints to be hardware breakpoints.

Default:
false
target.retries-with-fixitsUInt64#

Maximum number of attempts to fix an expression with Fix-Its

Default:
1
target.run-argsArgs#

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.

target.save-jit-objects-dirFileSpec#

If specified, the directory to save intermediate object files generated by the LLVM JIT

target.show-hex-variable-values-with-leading-zeroesBoolean#

Whether to display leading zeroes when printing variable values in hex format.

Default:
true
target.skip-prologueBoolean#

Skip function prologues when setting breakpoints by name.

Default:
true
target.source-mapPathMap#

Source path remappings apply substitutions to the paths of source files, typically needed to debug from a different host than the one that built the target. The source-map property consists of an array of pairs, the first element is a path prefix, and the second is its replacement. The syntax is prefix1 replacement1 prefix2 replacement2.... The pairs are checked in order, the first prefix that matches is used, and that prefix is substituted with the replacement. A common pattern is to use source-map in conjunction with the clang -fdebug-prefix-map flag. In the build, use -fdebug-prefix-map=/path/to/build_dir=. to rewrite the host specific build directory to .. Then for debugging, use settings set target.source-map . /path/to/local_dir to convert . to a valid local path.

target.source-realpath-prefixesFileSpecList#

Realpath any source paths that start with one of these prefixes. If the debug info contains symlinks which match the original source file’s basename but don’t match its location that the user will use to set breakpoints, then this setting can help resolve breakpoints correctly. This handles both symlinked files and directories. Wild card prefixes: An empty string matches all paths. A forward slash matches absolute paths.

target.trap-handler-namesArray#

A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.

target.unset-env-varsArray#

A list of environment variable names to be unset in the inferior’s environment. This is most useful to unset some host environment variables when target.inherit-env is true. target.env-vars takes precedence over target.unset-env-vars.

target.use-fast-steppingBoolean#

Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping.

Default:
true
target.use-hex-immediatesBoolean#

Show immediates in disassembly as hexadecimal.

Default:
true
target.x86-disassembly-flavorEnum#

The default disassembly flavor to use for x86 or x86-64 targets.

experimental#

target.experimental.inject-local-varsBoolean#

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.

Default:
true
target.experimental.use-DILBoolean#

If true, use the DIL implementation for frame variable evaluation.

Default:
true

process#

target.process.detach-keeps-stoppedBoolean#

If true, detach will attempt to keep the process stopped.

Default:
false
target.process.disable-language-runtime-unwindplansBoolean#

If true, language runtime augmented/overridden backtraces will not be used when printing a stack trace.

Default:
false
target.process.disable-memory-cacheBoolean#

Disable reading and caching of memory in fixed-size units.

Default:
false
target.process.extra-startup-commandArray#

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;’

target.process.follow-fork-modeEnum#

Debugger’s behavior upon fork or vfork.

target.process.highmem-virtual-addressable-bitsUInt64#

The number of bits used for addressing high memory, when it differs from low memory in the same Process. When this is non-zero, target.process.virtual-addressable-bits will be the value for low memory (0x000… addresses) and this setting will be the value for high memory (0xfff… addresses). When this is zero, target.process.virtual-addressable-bits applies to all addresses. It is very uncommon to use this setting.

Default:
0
target.process.ignore-breakpoints-in-expressionsBoolean#

If true, breakpoints will be ignored during expression evaluation.

Default:
true
target.process.interrupt-timeoutUInt64#

The time in seconds to wait for an interrupt succeed in stopping the target.

Default:
20
target.process.memory-cache-line-sizeUInt64#

The memory cache line size

Default:
512
target.process.optimization-warningsBoolean#

If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.

Default:
true
target.process.python-os-plugin-pathFileSpec#

A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class.

Default:
1
target.process.run-all-threadsBoolean#

If true, stepping operations will run all threads. This is equivalent to setting the run-mode option to ‘all-threads’.

Default:
false
target.process.stop-on-execBoolean#

If true, stop when the inferior exec’s.

Default:
true
target.process.stop-on-sharedlibrary-eventsBoolean#

If true, stop when a shared library is loaded or unloaded.

Default:
false
target.process.track-memory-cache-changesBoolean#

If true, memory cache modifications (which happen often during expressions evaluation) will bump process state ID (and invalidate all synthetic children). Disabling this option helps to avoid synthetic children reevaluation when pretty printers heavily use expressions. The downside of disabled setting is that convenience variables won’t reevaluate synthetic children automatically.

Default:
true
target.process.unsupported-language-warningsBoolean#

If true, warn when stopped in code that is written in a source language that LLDB does not support.

Default:
true
target.process.unwind-on-error-in-expressionsBoolean#

If true, errors in expression evaluation will unwind the stack back to the state before the call.

Default:
true
target.process.utility-expression-timeoutUInt64#

The time in seconds to wait for LLDB-internal utility expressions.

Default:
15
target.process.virtual-addressable-bitsUInt64#

The number of bits used for addressing. If the value is 39, then bits 0..38 are used for addressing. The default value of 0 means unspecified.

Default:
0

experimental#

target.process.experimental.os-plugin-reports-all-threadsBoolean#

Set to False if your Python OS Plugin doesn’t report all threads on each stop.

Default:
true

thread#

target.process.thread.max-backtrace-depthUInt64#

Maximum number of frames to backtrace.

Default:
600000
target.process.thread.single-thread-plan-timeoutUInt64#

The time in milliseconds to wait for single thread ThreadPlan to move forward before resuming all threads to resolve any potential deadlock. Specify value 0 to disable timeout.

Default:
1000
target.process.thread.step-avoid-librariesFileSpecList#

A list of libraries that source stepping won’t stop in.

target.process.thread.step-avoid-regexpRegex#

A regular expression defining functions step-in won’t stop in.

Default:
^std::
target.process.thread.step-in-avoid-nodebugBoolean#

If true, step-in will not stop in functions with no debug information.

Default:
true
target.process.thread.step-out-avoid-nodebugBoolean#

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.

Default:
false
target.process.thread.trace-threadBoolean#

If true, this thread will single-step and log execution.

Default:
false

testing#

testing.inject-variable-location-errorBoolean#

Used for testing LLDB only. Hide locations of local variables.

Default:
false
testing.safe-auto-load-pathsFileSpecList#

List of paths that LLDB will automatically load scripting resources from.