1include "../../include/lldb/Core/PropertiesBase.td" 2 3let Definition = "target_experimental" in { 4 def InjectLocalVars : Property<"inject-local-vars", "Boolean">, 5 Global, DefaultTrue, 6 Desc<"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.">; 7} 8 9let Definition = "target" in { 10 def DefaultArch: Property<"default-arch", "Arch">, 11 Global, 12 DefaultStringValue<"">, 13 Desc<"Default architecture to choose, when there's a choice.">; 14 def MoveToNearestCode: Property<"move-to-nearest-code", "Boolean">, 15 DefaultTrue, 16 Desc<"Move breakpoints to nearest code.">; 17 def Language: Property<"language", "Language">, 18 DefaultEnumValue<"eLanguageTypeUnknown">, 19 Desc<"The language to use when interpreting expressions entered in commands.">; 20 def ExprPrefix: Property<"expr-prefix", "FileSpec">, 21 DefaultStringValue<"">, 22 Desc<"Path to a file containing expressions to be prepended to all expressions.">; 23 def ExprErrorLimit: Property<"expr-error-limit", "UInt64">, 24 DefaultUnsignedValue<5>, 25 Desc<"The maximum amount of errors to emit while parsing an expression. " 26 "A value of 0 means to always continue parsing if possible.">; 27 def PreferDynamic: Property<"prefer-dynamic-value", "Enum">, 28 DefaultEnumValue<"eDynamicDontRunTarget">, 29 EnumValues<"OptionEnumValues(g_dynamic_value_types)">, 30 Desc<"Should printed values be shown as their dynamic value.">; 31 def EnableSynthetic: Property<"enable-synthetic-value", "Boolean">, 32 DefaultTrue, 33 Desc<"Should synthetic values be used by default whenever available.">; 34 def SkipPrologue: Property<"skip-prologue", "Boolean">, 35 DefaultTrue, 36 Desc<"Skip function prologues when setting breakpoints by name.">; 37 def SourceMap: Property<"source-map", "PathMap">, 38 DefaultStringValue<"">, 39 Desc<"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.">; 40 def AutoSourceMapRelative: Property<"auto-source-map-relative", "Boolean">, 41 DefaultTrue, 42 Desc<"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.">; 43 def ExecutableSearchPaths: Property<"exec-search-paths", "FileSpecList">, 44 DefaultStringValue<"">, 45 Desc<"Executable search paths to use when locating executable files whose paths don't match the local file system.">; 46 def DebugFileSearchPaths: Property<"debug-file-search-paths", "FileSpecList">, 47 DefaultStringValue<"">, 48 Desc<"List of directories to be searched when locating debug symbol files. See also symbols.enable-external-lookup.">; 49 def ClangModuleSearchPaths: Property<"clang-module-search-paths", "FileSpecList">, 50 DefaultStringValue<"">, 51 Desc<"List of directories to be searched when locating modules for Clang.">; 52 def AutoImportClangModules: Property<"auto-import-clang-modules", "Boolean">, 53 DefaultTrue, 54 Desc<"Automatically load Clang modules referred to by the program.">; 55 def ImportStdModule: Property<"import-std-module", "Enum">, 56 DefaultEnumValue<"eImportStdModuleFalse">, 57 EnumValues<"OptionEnumValues(g_import_std_module_value_types)">, 58 Desc<"Import the 'std' C++ module to improve expression parsing involving " 59 " C++ standard library types.">; 60 def DynamicClassInfoHelper: Property<"objc-dynamic-class-extractor", "Enum">, 61 DefaultEnumValue<"eDynamicClassInfoHelperAuto">, 62 EnumValues<"OptionEnumValues(g_dynamic_class_info_helper_value_types)">, 63 Desc<"Configure how LLDB parses dynamic Objective-C class metadata. By default LLDB will choose the most appropriate method for the target OS.">; 64 def AutoApplyFixIts: Property<"auto-apply-fixits", "Boolean">, 65 DefaultTrue, 66 Desc<"Automatically apply fix-it hints to expressions.">; 67 def RetriesWithFixIts: Property<"retries-with-fixits", "UInt64">, 68 DefaultUnsignedValue<1>, 69 Desc<"Maximum number of attempts to fix an expression with Fix-Its">; 70 def NotifyAboutFixIts: Property<"notify-about-fixits", "Boolean">, 71 DefaultTrue, 72 Desc<"Print the fixed expression text.">; 73 def SaveObjectsDir: Property<"save-jit-objects-dir", "FileSpec">, 74 DefaultStringValue<"">, 75 Desc<"If specified, the directory to save intermediate object files generated by the LLVM JIT">; 76 def MaxZeroPaddingInFloatFormat: Property<"max-zero-padding-in-float-format", "UInt64">, 77 DefaultUnsignedValue<6>, 78 Desc<"The maximum number of zeroes to insert when displaying a very small float before falling back to scientific notation.">; 79 def MaxChildrenCount: Property<"max-children-count", "SInt64">, 80 DefaultUnsignedValue<256>, 81 Desc<"Maximum number of children to expand in any level of depth.">; 82 def MaxChildrenDepth: Property<"max-children-depth", "UInt64">, 83 DefaultUnsignedValue<0xFFFFFFFF>, 84 Desc<"Maximum depth to expand children.">; 85 def MaxSummaryLength: Property<"max-string-summary-length", "SInt64">, 86 DefaultUnsignedValue<1024>, 87 Desc<"Maximum number of characters to show when using %s in summary strings.">; 88 def MaxMemReadSize: Property<"max-memory-read-size", "SInt64">, 89 DefaultUnsignedValue<1024>, 90 Desc<"Maximum number of bytes that 'memory read' will fetch before --force must be specified.">; 91 def BreakpointUseAvoidList: Property<"breakpoints-use-platform-avoid-list", "Boolean">, 92 DefaultTrue, 93 Desc<"Consult the platform module avoid list when setting non-module specific breakpoints.">; 94 def Arg0: Property<"arg0", "String">, 95 DefaultStringValue<"">, 96 Desc<"The first argument passed to the program in the argument array which can be different from the executable itself.">; 97 def RunArgs: Property<"run-args", "Args">, 98 DefaultStringValue<"">, 99 Desc<"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.">; 100 def EnvVars: Property<"env-vars", "Dictionary">, 101 ElementType<"String">, 102 Desc<"A list of user provided environment variables to be passed to the executable's environment, and their values.">; 103 def UnsetEnvVars: Property<"unset-env-vars", "Array">, 104 ElementType<"String">, 105 Desc<"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.">; 106 def InheritEnv: Property<"inherit-env", "Boolean">, 107 DefaultTrue, 108 Desc<"Inherit the environment from the process that is running LLDB.">; 109 def InputPath: Property<"input-path", "FileSpec">, 110 DefaultStringValue<"">, 111 Desc<"The file/path to be used by the executable program for reading its standard input.">; 112 def OutputPath: Property<"output-path", "FileSpec">, 113 DefaultStringValue<"">, 114 Desc<"The file/path to be used by the executable program for writing its standard output.">; 115 def ErrorPath: Property<"error-path", "FileSpec">, 116 DefaultStringValue<"">, 117 Desc<"The file/path to be used by the executable program for writing its standard error.">; 118 def DetachOnError: Property<"detach-on-error", "Boolean">, 119 DefaultTrue, 120 Desc<"debugserver will detach (rather than killing) a process if it loses connection with lldb.">; 121 def PreloadSymbols: Property<"preload-symbols", "Boolean">, 122 DefaultTrue, 123 Desc<"Enable loading of symbol tables before they are needed.">; 124 def DisableASLR: Property<"disable-aslr", "Boolean">, 125 DefaultTrue, 126 Desc<"Disable Address Space Layout Randomization (ASLR)">; 127 def DisableSTDIO: Property<"disable-stdio", "Boolean">, 128 DefaultFalse, 129 Desc<"Disable stdin/stdout for process (e.g. for a GUI application)">; 130 def InheritTCC: Property<"inherit-tcc", "Boolean">, 131 DefaultFalse, 132 Desc<"Inherit the TCC permissions from the inferior's parent instead of making the process itself responsible.">; 133 def InlineStrategy: Property<"inline-breakpoint-strategy", "Enum">, 134 DefaultEnumValue<"eInlineBreakpointsAlways">, 135 EnumValues<"OptionEnumValues(g_inline_breakpoint_enums)">, 136 Desc<"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.">; 137 def DisassemblyFlavor: Property<"x86-disassembly-flavor", "Enum">, 138 DefaultEnumValue<"eX86DisFlavorDefault">, 139 EnumValues<"OptionEnumValues(g_x86_dis_flavor_value_types)">, 140 Desc<"The default disassembly flavor to use for x86 or x86-64 targets.">; 141 def UseHexImmediates: Property<"use-hex-immediates", "Boolean">, 142 DefaultTrue, 143 Desc<"Show immediates in disassembly as hexadecimal.">; 144 def HexImmediateStyle: Property<"hex-immediate-style", "Enum">, 145 DefaultEnumValue<"Disassembler::eHexStyleC">, 146 EnumValues<"OptionEnumValues(g_hex_immediate_style_values)">, 147 Desc<"Which style to use for printing hexadecimal disassembly values.">; 148 def UseFastStepping: Property<"use-fast-stepping", "Boolean">, 149 DefaultTrue, 150 Desc<"Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping.">; 151 def LoadScriptFromSymbolFile: Property<"load-script-from-symbol-file", "Enum">, 152 DefaultEnumValue<"eLoadScriptFromSymFileWarn">, 153 EnumValues<"OptionEnumValues(g_load_script_from_sym_file_values)">, 154 Desc<"Allow LLDB to load scripting resources embedded in symbol files when available.">; 155 def LoadCWDlldbinitFile: Property<"load-cwd-lldbinit", "Enum">, 156 DefaultEnumValue<"eLoadCWDlldbinitWarn">, 157 EnumValues<"OptionEnumValues(g_load_cwd_lldbinit_values)">, 158 Desc<"Allow LLDB to .lldbinit files from the current directory automatically.">; 159 def MemoryModuleLoadLevel: Property<"memory-module-load-level", "Enum">, 160 DefaultEnumValue<"eMemoryModuleLoadLevelComplete">, 161 EnumValues<"OptionEnumValues(g_memory_module_load_level_values)">, 162 Desc<"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). ">; 163 def DisplayExpressionsInCrashlogs: Property<"display-expression-in-crashlogs", "Boolean">, 164 DefaultFalse, 165 Desc<"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.">; 166 def TrapHandlerNames: Property<"trap-handler-names", "Array">, 167 Global, 168 ElementType<"String">, 169 Desc<"A list of trap handler function names, e.g. a common Unix user process one is _sigtramp.">; 170 def DisplayRuntimeSupportValues: Property<"display-runtime-support-values", "Boolean">, 171 DefaultFalse, 172 Desc<"If true, LLDB will show variables that are meant to support the operation of a language's runtime support.">; 173 def DisplayRecognizedArguments: Property<"display-recognized-arguments", "Boolean">, 174 DefaultFalse, 175 Desc<"Show recognized arguments in variable listings by default.">; 176 def RequireHardwareBreakpoints: Property<"require-hardware-breakpoint", "Boolean">, 177 DefaultFalse, 178 Desc<"Require all breakpoints to be hardware breakpoints.">; 179 def AutoInstallMainExecutable: Property<"auto-install-main-executable", "Boolean">, 180 DefaultTrue, 181 Desc<"Always install the main executable when connected to a remote platform.">; 182 def DebugUtilityExpression: Property<"debug-utility-expression", "Boolean">, 183 DefaultFalse, 184 Desc<"Enable debugging of LLDB-internal utility expressions.">; 185} 186 187let Definition = "process_experimental" in { 188 def OSPluginReportsAllThreads: Property<"os-plugin-reports-all-threads", "Boolean">, 189 Global, 190 DefaultTrue, 191 Desc<"Set to False if your OS Plugins doesn't report all threads on each stop.">; 192} 193 194let Definition = "process" in { 195 def DisableMemCache: Property<"disable-memory-cache", "Boolean">, 196 DefaultFalse, 197 Desc<"Disable reading and caching of memory in fixed-size units.">; 198 def ExtraStartCommand: Property<"extra-startup-command", "Array">, 199 ElementType<"String">, 200 Desc<"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;'">; 201 def IgnoreBreakpointsInExpressions: Property<"ignore-breakpoints-in-expressions", "Boolean">, 202 Global, 203 DefaultTrue, 204 Desc<"If true, breakpoints will be ignored during expression evaluation.">; 205 def UnwindOnErrorInExpressions: Property<"unwind-on-error-in-expressions", "Boolean">, 206 Global, 207 DefaultTrue, 208 Desc<"If true, errors in expression evaluation will unwind the stack back to the state before the call.">; 209 def PythonOSPluginPath: Property<"python-os-plugin-path", "FileSpec">, 210 DefaultUnsignedValue<1>, 211 Desc<"A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class.">; 212 def StopOnSharedLibraryEvents: Property<"stop-on-sharedlibrary-events", "Boolean">, 213 Global, 214 DefaultFalse, 215 Desc<"If true, stop when a shared library is loaded or unloaded.">; 216 def DisableLangRuntimeUnwindPlans: Property<"disable-language-runtime-unwindplans", "Boolean">, 217 Global, 218 DefaultFalse, 219 Desc<"If true, LanguageRuntime plugins' UnwindPlans will not be used when backtracing.">; 220 def DetachKeepsStopped: Property<"detach-keeps-stopped", "Boolean">, 221 Global, 222 DefaultFalse, 223 Desc<"If true, detach will attempt to keep the process stopped.">; 224 def MemCacheLineSize: Property<"memory-cache-line-size", "UInt64">, 225 DefaultUnsignedValue<512>, 226 Desc<"The memory cache line size">; 227 def WarningOptimization: Property<"optimization-warnings", "Boolean">, 228 DefaultTrue, 229 Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">; 230 def WarningUnsupportedLanguage: Property<"unsupported-language-warnings", "Boolean">, 231 DefaultTrue, 232 Desc<"If true, warn when stopped in code that is written in a source language that LLDB does not support.">; 233 def StopOnExec: Property<"stop-on-exec", "Boolean">, 234 Global, 235 DefaultTrue, 236 Desc<"If true, stop when the inferior exec's.">; 237 def UtilityExpressionTimeout: Property<"utility-expression-timeout", "UInt64">, 238 DefaultUnsignedValue<15>, 239 Desc<"The time in seconds to wait for LLDB-internal utility expressions.">; 240 def InterruptTimeout: Property<"interrupt-timeout", "UInt64">, 241 DefaultUnsignedValue<20>, 242 Desc<"The time in seconds to wait for an interrupt succeed in stopping the target.">; 243 def SteppingRunsAllThreads: Property<"run-all-threads", "Boolean">, 244 DefaultFalse, 245 Desc<"If true, stepping operations will run all threads. This is equivalent to setting the run-mode option to 'all-threads'.">; 246 def VirtualAddressableBits: Property<"virtual-addressable-bits", "UInt64">, 247 DefaultUnsignedValue<0>, 248 Desc<"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.">; 249 def FollowForkMode: Property<"follow-fork-mode", "Enum">, 250 DefaultEnumValue<"eFollowParent">, 251 EnumValues<"OptionEnumValues(g_follow_fork_mode_values)">, 252 Desc<"Debugger's behavior upon fork or vfork.">; 253} 254 255let Definition = "platform" in { 256 def UseModuleCache: Property<"use-module-cache", "Boolean">, 257 Global, 258 DefaultTrue, 259 Desc<"Use module cache.">; 260 def ModuleCacheDirectory: Property<"module-cache-directory", "FileSpec">, 261 Global, 262 DefaultStringValue<"">, 263 Desc<"Root directory for cached modules.">; 264} 265 266let Definition = "thread" in { 267 def StepInAvoidsNoDebug: Property<"step-in-avoid-nodebug", "Boolean">, 268 Global, 269 DefaultTrue, 270 Desc<"If true, step-in will not stop in functions with no debug information.">; 271 def StepOutAvoidsNoDebug: Property<"step-out-avoid-nodebug", "Boolean">, 272 Global, 273 DefaultFalse, 274 Desc<"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.">; 275 def StepAvoidRegex: Property<"step-avoid-regexp", "Regex">, 276 Global, 277 DefaultStringValue<"^std::">, 278 Desc<"A regular expression defining functions step-in won't stop in.">; 279 def StepAvoidLibraries: Property<"step-avoid-libraries", "FileSpecList">, 280 Global, 281 DefaultStringValue<"">, 282 Desc<"A list of libraries that source stepping won't stop in.">; 283 def EnableThreadTrace: Property<"trace-thread", "Boolean">, 284 DefaultFalse, 285 Desc<"If true, this thread will single-step and log execution.">; 286 def MaxBacktraceDepth: Property<"max-backtrace-depth", "UInt64">, 287 DefaultUnsignedValue<600000>, 288 Desc<"Maximum number of frames to backtrace.">; 289} 290