lldb/source/Target/TargetProperties.td

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