Settings

This page lists all available 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>.

Root

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

dwim-print-verbosityenum

The verbosity level used by dwim-print.

Enumerations:

• none – Use no verbosity when running dwim-print.

• expression – Use partial verbosity when running dwim-print - display a message when expression evaluation is used.

• full – Use full verbosity when running dwim-print.

Default:

none

disassembly-formatformat-string

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}>}:

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-formatformat-string

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-uniqueformat-string

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

notify-voidboolean

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

Default:

false

print-declsboolean

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.

Default:

unknown

script-langenum

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

Enumerations:

• none – Disable scripting languages.

• python – Select python as the default scripting language.

• default – Select the lldb default as the default scripting language.

Default:

default

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}

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 somehing has been disabled in a color-enabled terminal, use the ANSI terminal code specified immediately after whatever has been disabled.

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:

false

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-formatformat-string

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-countunsigned

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.

Enumerations:

• never – Never show disassembly when displaying a stop context.

• no-debuginfo – Show disassembly when there is no debug information.

• no-source – Show disassembly when there is no source information, or the source file is missing when displaying a stop context.

• always – Always show disassembly when displaying a stop context.

Default:

no-debuginfo

stop-disassembly-max-sizeunsigned

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

Default:

32000

stop-line-count-afterunsigned

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

Default:

3

stop-line-count-beforeunsigned

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.

Enumerations:

• none – Do not highlight the stop column.

• ansi-or-caret – Highlight the stop column with ANSI terminal codes when color/ANSI mode is enabled; otherwise, fall back to using a text-only caret (^) as if “caret-only” mode was selected.

• ansi – Highlight the stop column with ANSI terminal codes when running LLDB with color/ANSI enabled.

• caret – Highlight the stop column with a caret character (^) underneath the stop column. This method introduces a new line in source listings that display thread stop locations.

Default:

ansi-or-caret

stop-show-column-ansi-prefixstring

When displaying the column marker in a color-enabled terminal, use the ANSI terminal code specified in this format at the 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 at the 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-sizeunsigned

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

Default:

2

term-heightunsigned

The number of rows used for displaying text.

Default:

24

Minimum:

10

term-widthunsigned

The maximum number of columns to use for displaying text.

Default:

80

Minimum:

10

thread-formatformat-string

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-formatformat-string

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

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-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-pathsfile-list

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

target.debug-file-search-pathsfile-list

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.

Default:

unknown

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.x86-disassembly-flavorenum

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

Enumerations:

• default – Disassembler default (currently att).

• intel – Intel disassembler flavor.

• att – AT&T disassembler flavor.

Default:

default

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

Enumerations:

• auto – Automatically determine the most appropriate method for the target OS.

• GetRealizedClassList – Prefer using the GetRealizedClassList API.

• RealizedClassesStruct – Prefer using the realized classes struct.

• CopyRealizedClassList – Prefer using the CopyRealizedClassList API.

Default:

auto

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-pathfile

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

target.exec-search-pathsfile-list

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

target.expr-alloc-addressunsigned

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

Default:

0

target.expr-alloc-alignunsigned

Alignment for each memory allocation for expression evaluation.

Default:

0

target.expr-alloc-sizeunsigned

Amount of memory in bytes to allocate for expression evaluation.

Default:

0

target.expr-error-limitunsigned

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-prefixfile

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.

Enumerations:

• c – C-style (0xffff).

• asm – Asm-style (0ffffh).

Default:

c

target.import-std-moduleenum

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

Enumerations:

• fallback – Retry evaluating expressions with an imported ‘std’ C++ module if they failed to parse without the module. This allows evaluating more complex expressions involving C++ standard library types.

• false – Never import the ‘std’ C++ module in the expression parser.

• true – Always import the ‘std’ C++ module. This allows evaluating more complex expressions involving C++ standard library types. This feature is experimental.

Default:

false

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.

Enumerations:

• never – Never look for inline breakpoint locations (fastest). This setting should only be used if you know that no inlining occurs in yourprograms.

• always – Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate).

• headers – Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default).

Default:

always

target.input-pathfile

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.

Default:

unknown

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.

Enumerations:

• warn – Warn about loading .lldbinit files from current directory

• false – Do not load .lldbinit files from current directory

• true – Load .lldbinit files from current directory

Default:

warn

target.load-script-from-symbol-fileenum

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

Enumerations:

• warn – Warn about debug scripts inside symbol files but do not load them.

• false – Do not load debug scripts inside symbol files.

• true – Load debug scripts inside symbol files

Default:

warn

target.max-children-countunsigned

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

Default:

24

target.max-children-depthunsigned

Maximum depth to expand children.

Default:

4

target.max-memory-read-sizeunsigned

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

Default:

4294967295

target.max-string-summary-lengthunsigned

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

Default:

1024

target.max-zero-padding-in-float-formatunsigned

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

Enumerations:

• minimal – Load minimal information when loading modules from memory. Currently this setting loads sections only.

• partial – Load partial information when loading modules from memory. Currently this setting loads sections and function bounds.

• complete – Load complete information when loading modules from memory. Currently this setting loads sections and all symbols.

Default:

complete

target.move-to-nearest-codeboolean

Move breakpoints to nearest code.

Default:

true

target.notify-about-fixitsboolean

Print the fixed expression text.

Default:

true

target.object-mappath-map

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-pathfile

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.

Enumerations:

• no-dynamic-values – Don’t calculate the dynamic type of values

• no-run-target – Calculate the dynamic type of values, but don’t run the target.

• run-target – Calculate the dynamic type of values even if you have to run the target.

Default:

no-run-target

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-fixitsunsigned

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

Default:

1

target.run-argsarguments

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-dirfile

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-mappath-map

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-prefixesfile-list

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

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.

Enumerations:

• parent – Continue tracing the parent process and detach the child.

• child – Trace the child process and detach the parent.

Default:

parent

target.process.highmem-virtual-addressable-bitsunsigned

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-timeoutunsigned

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

Default:

20

target.process.memory-cache-line-sizeunsigned

The memory cache line size

Default:

512

target.process.python-os-plugin-pathfile

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

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

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

Default:

15

target.process.virtual-addressable-bitsunsigned

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

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.unsupported-language-warningsboolean

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

Default:

true

thread

target.process.thread.trace-threadboolean

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

Default:

false

target.process.thread.max-backtrace-depthunsigned

Maximum number of frames to backtrace.

Default:

600000

target.process.thread.single-thread-plan-timeoutunsigned

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-librariesfile-list

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

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

platform

platform.module-cache-directoryfile

Root directory for cached modules.

Default:

~/.lldb/module_cache

platform.use-module-cacheboolean

Use module cache.

Default:

true

plugin

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

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.

qemu-user

platform.plugin.qemu-user.architecturestring

Architecture to emulate.

platform.plugin.qemu-user.emulator-argsarguments

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-pathfile

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.

symbols

symbols.auto-downloadenum

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

Enumerations:

• off – Disable automatically downloading symbols.

• background – Download symbols in the background for images as they appear in the backtrace.

• foreground – Download symbols in the foreground for images as they appear in the backtrace.

Default:

off

symbols.clang-modules-cache-pathfile

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

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-daysunsigned

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-sizeunsigned

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-percentunsigned

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-pathfile

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.debug-info-symlink-pathsfile-list

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

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

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-directoryfile

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

plugin

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.

Enumerations:

• none – Do not read memory looking for a Darwin kernel when attaching.

• basic – Check for the Darwin kernel’s load addr in the lowglo page (boot-args=debug) only.

• exhaustive-scan – Scan through the entire potential address range of Darwin kernel (only on 32-bit targets).

• fast-scan – Scan near the pc value on attach to find the Darwin kernel’s load address.

Default:

fast-scan

jit-loader

gdb

plugin.jit-loader.gdb.enableenum

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

Enumerations:

• off – Disable JIT compilation interface

• default – Enable JIT compilation interface for all platforms except macOS

• on – Enable JIT compilation interface

Default:

default

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.

Enumerations:

• default – Use default target (if it is Windows) or MSVC

• gnu – MinGW / Itanium ABI

• msvc – MSVC ABI

Default:

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

gdb-remote

plugin.process.gdb-remote.packet-timeoutunsigned

Specify the default packet timeout in seconds.

Default:

5

plugin.process.gdb-remote.target-definition-filefile

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

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

Enumerations:

• default – Use native PDB reader unless LLDB_USE_NATIVE_PDB_READER environment is set to 0

• native – Use native PDB reader

• dia – Use DIA PDB reader

Default:

default

symbol-locator

debuginfod

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.cache-pathstring

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

plugin.symbol-locator.debuginfod.timeoutunsigned

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

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

cplusplus

display

plugin.cplusplus.display.function-name-formatformat-string

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}