1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
| /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|* *|
|* Property definitions for LLDB. *|
|* *|
|* Automatically generated file, do not edit! *|
|* *|
\*===----------------------------------------------------------------------===*/
// Property definitions for experimental
#ifdef LLDB_PROPERTIES_experimental
static constexpr PropertyDefinition g_experimental_properties[] = {
{"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."},
{"use-modern-type-lookup", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, use Clang's modern type lookup infrastructure."},
};
#undef LLDB_PROPERTIES_experimental
#endif // experimental Property
// Property definitions for platform
#ifdef LLDB_PROPERTIES_platform
static constexpr PropertyDefinition g_platform_properties[] = {
{"module-cache-directory", OptionValue::eTypeFileSpec, true, 0, "", {}, "Root directory for cached modules."},
{"use-module-cache", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "Use module cache."},
};
#undef LLDB_PROPERTIES_platform
#endif // platform Property
// Property definitions for process
#ifdef LLDB_PROPERTIES_process
static constexpr PropertyDefinition g_process_properties[] = {
{"detach-keeps-stopped", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, detach will attempt to keep the process stopped."},
{"disable-memory-cache", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable reading and caching of memory in fixed-size units."},
{"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;'"},
{"ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, breakpoints will be ignored during expression evaluation."},
{"memory-cache-line-size", OptionValue::eTypeUInt64, false, 512, nullptr, {}, "The memory cache line size"},
{"python-os-plugin-path", OptionValue::eTypeFileSpec, false, 1, nullptr, {}, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class."},
{"stop-on-exec", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, stop when a shared library is loaded or unloaded."},
{"stop-on-sharedlibrary-events", OptionValue::eTypeBoolean, true, 0, nullptr, {}, "If true, stop when a shared library is loaded or unloaded."},
{"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."},
{"utility-expression-timeout", OptionValue::eTypeUInt64, false, 15, nullptr, {}, "The time in seconds to wait for LLDB-internal utility expressions."},
{"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."},
};
#undef LLDB_PROPERTIES_process
#endif // process Property
// Property definitions for target
#ifdef LLDB_PROPERTIES_target
static constexpr PropertyDefinition g_target_properties[] = {
{"arg0", OptionValue::eTypeString, false, 0, "", {}, "The first argument passed to the program in the argument array which can be different from the executable itself."},
{"auto-apply-fixits", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Automatically apply fix-it hints to expressions."},
{"auto-import-clang-modules", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Automatically load Clang modules referred to by the program."},
{"breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Consult the platform module avoid list when setting non-module specific breakpoints."},
{"clang-module-search-paths", OptionValue::eTypeFileSpecList, false, 0, "", {}, "List of directories to be searched when locating modules for Clang."},
{"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."},
{"default-arch", OptionValue::eTypeArch, true, 0, "", {}, "Default architecture to choose, when there's a choice."},
{"detach-on-error", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "debugserver will detach (rather than killing) a process if it loses connection with lldb."},
{"disable-aslr", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Disable Address Space Layout Randomization (ASLR)"},
{"disable-stdio", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable stdin/stdout for process (e.g. for a GUI application)"},
{"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."},
{"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."},
{"display-recognized-arguments", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Show recognized arguments in variable listings by default."},
{"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."},
{"enable-synthetic-value", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Should synthetic values be used by default whenever available."},
{"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."},
{"error-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for writing its standard error."},
{"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."},
{"expr-prefix", OptionValue::eTypeFileSpec, false, 0, "", {}, "Path to a file containing expressions to be prepended to all expressions."},
{"hex-immediate-style", OptionValue::eTypeEnum, false, Disassembler::eHexStyleC, nullptr, OptionEnumValues(g_hex_immediate_style_values), "Which style to use for printing hexadecimal disassembly values."},
{"import-std-module", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Import the C++ std module to improve debugging STL containers."},
{"inherit-env", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Inherit the environment from the process that is running LLDB."},
{"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."},
{"input-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for reading its standard input."},
{"language", OptionValue::eTypeLanguage, false, eLanguageTypeUnknown, nullptr, {}, "The language to use when interpreting expressions entered in commands."},
{"load-cwd-lldbinit", OptionValue::eTypeEnum, false, eLoadCWDlldbinitWarn, nullptr, OptionEnumValues(g_load_cwd_lldbinit_values), "Allow LLDB to .lldbinit files from the current directory automatically."},
{"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."},
{"max-children-count", OptionValue::eTypeSInt64, false, 256, nullptr, {}, "Maximum number of children to expand in any level of depth."},
{"max-memory-read-size", OptionValue::eTypeSInt64, false, 1024, nullptr, {}, "Maximum number of bytes that 'memory read' will fetch before --force must be specified."},
{"max-string-summary-length", OptionValue::eTypeSInt64, false, 1024, nullptr, {}, "Maximum number of characters to show when using %s in summary strings."},
{"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."},
{"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). "},
{"move-to-nearest-code", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Move breakpoints to nearest code."},
{"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Disable lock-step debugging, instead control threads independently."},
{"notify-about-fixits", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Print the fixed expression text."},
{"output-path", OptionValue::eTypeFileSpec, false, 0, "", {}, "The file/path to be used by the executable program for writing its standard output."},
{"prefer-dynamic-value", OptionValue::eTypeEnum, false, eDynamicDontRunTarget, nullptr, OptionEnumValues(g_dynamic_value_types), "Should printed values be shown as their dynamic value."},
{"preload-symbols", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Enable loading of symbol tables before they are needed."},
{"require-hardware-breakpoint", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Require all breakpoints to be hardware breakpoints."},
{"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."},
{"save-jit-objects", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "Save intermediate object files generated by the LLVM JIT"},
{"skip-prologue", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Skip function prologues when setting breakpoints by name."},
{"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."},
{"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."},
{"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."},
{"use-hex-immediates", OptionValue::eTypeBoolean, false, 1, nullptr, {}, "Show immediates in disassembly as hexadecimal."},
};
#undef LLDB_PROPERTIES_target
#endif // target Property
// Property definitions for thread
#ifdef LLDB_PROPERTIES_thread
static constexpr PropertyDefinition g_thread_properties[] = {
{"trace-thread", OptionValue::eTypeBoolean, false, 0, nullptr, {}, "If true, this thread will single-step and log execution."},
{"max-backtrace-depth", OptionValue::eTypeUInt64, false, 300000, nullptr, {}, "Maximum number of frames to backtrace."},
{"step-avoid-libraries", OptionValue::eTypeFileSpecList, true, 0, "", {}, "A list of libraries that source stepping won't stop in."},
{"step-avoid-regexp", OptionValue::eTypeRegex, true, 0, "^std::", {}, "A regular expression defining functions step-in won't stop in."},
{"step-in-avoid-nodebug", OptionValue::eTypeBoolean, true, 1, nullptr, {}, "If true, step-in will not stop in functions with no debug information."},
{"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."},
};
#undef LLDB_PROPERTIES_thread
#endif // thread Property
|