diff --git a/contrib/llvm-project/lldb/include/lldb/lldb-enumerations.h b/contrib/llvm-project/lldb/include/lldb/lldb-enumerations.h index b3e8d604913f..c9def56ff109 100644 --- a/contrib/llvm-project/lldb/include/lldb/lldb-enumerations.h +++ b/contrib/llvm-project/lldb/include/lldb/lldb-enumerations.h @@ -1,1101 +1,1101 @@ //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef LLDB_LLDB_ENUMERATIONS_H #define LLDB_LLDB_ENUMERATIONS_H #include #ifndef SWIG // Macro to enable bitmask operations on an enum. Without this, Enum | Enum // gets promoted to an int, so you have to say Enum a = Enum(eFoo | eBar). If // you mark Enum with LLDB_MARK_AS_BITMASK_ENUM(Enum), however, you can simply // write Enum a = eFoo | eBar. // Unfortunately, swig<3.0 doesn't recognise the constexpr keyword, so remove // this entire block, as it is not necessary for swig processing. #define LLDB_MARK_AS_BITMASK_ENUM(Enum) \ constexpr Enum operator|(Enum a, Enum b) { \ return static_cast( \ static_cast::type>(a) | \ static_cast::type>(b)); \ } \ constexpr Enum operator&(Enum a, Enum b) { \ return static_cast( \ static_cast::type>(a) & \ static_cast::type>(b)); \ } \ constexpr Enum operator~(Enum a) { \ return static_cast( \ ~static_cast::type>(a)); \ } \ inline Enum &operator|=(Enum &a, Enum b) { \ a = a | b; \ return a; \ } \ inline Enum &operator&=(Enum &a, Enum b) { \ a = a & b; \ return a; \ } #else #define LLDB_MARK_AS_BITMASK_ENUM(Enum) #endif #ifndef SWIG // With MSVC, the default type of an enum is always signed, even if one of the // enumerator values is too large to fit into a signed integer but would // otherwise fit into an unsigned integer. As a result of this, all of LLDB's // flag-style enumerations that specify something like eValueFoo = 1u << 31 // result in negative values. This usually just results in a benign warning, // but in a few places we actually do comparisons on the enum values, which // would cause a real bug. Furthermore, there's no way to silence only this // warning, as it's part of -Wmicrosoft which also catches a whole slew of // other useful issues. // // To make matters worse, early versions of SWIG don't recognize the syntax of // specifying the underlying type of an enum (and Python doesn't care anyway) // so we need a way to specify the underlying type when the enum is being used // from C++ code, but just use a regular enum when swig is pre-processing. #define FLAGS_ENUM(Name) enum Name : unsigned #define FLAGS_ANONYMOUS_ENUM() enum : unsigned #else #define FLAGS_ENUM(Name) enum Name #define FLAGS_ANONYMOUS_ENUM() enum #endif namespace lldb { /// Process and Thread States. enum StateType { eStateInvalid = 0, eStateUnloaded, ///< Process is object is valid, but not currently loaded eStateConnected, ///< Process is connected to remote debug services, but not /// launched or attached to anything yet eStateAttaching, ///< Process is currently trying to attach eStateLaunching, ///< Process is in the process of launching // The state changes eStateAttaching and eStateLaunching are both sent while // the private state thread is either not yet started or paused. For that // reason, they should only be signaled as public state changes, and not // private state changes. eStateStopped, ///< Process or thread is stopped and can be examined. eStateRunning, ///< Process or thread is running and can't be examined. eStateStepping, ///< Process or thread is in the process of stepping and can /// not be examined. eStateCrashed, ///< Process or thread has crashed and can be examined. eStateDetached, ///< Process has been detached and can't be examined. eStateExited, ///< Process has exited and can't be examined. eStateSuspended, ///< Process or thread is in a suspended state as far ///< as the debugger is concerned while other processes ///< or threads get the chance to run. kLastStateType = eStateSuspended }; /// Launch Flags. FLAGS_ENUM(LaunchFlags){ eLaunchFlagNone = 0u, eLaunchFlagExec = (1u << 0), ///< Exec when launching and turn the calling /// process into a new process eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to /// allow the process to be debugged eLaunchFlagStopAtEntry = (1u << 2), ///< Stop at the program entry point /// instead of auto-continuing when /// launching or attaching at entry point eLaunchFlagDisableASLR = (1u << 3), ///< Disable Address Space Layout Randomization eLaunchFlagDisableSTDIO = (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app) eLaunchFlagLaunchInTTY = (1u << 5), ///< Launch the process in a new TTY if supported by the host eLaunchFlagLaunchInShell = (1u << 6), ///< Launch the process inside a shell to get shell expansion eLaunchFlagLaunchInSeparateProcessGroup = (1u << 7), ///< Launch the process in a separate process group ///< If you are going to hand the process off (e.g. to ///< debugserver) eLaunchFlagDontSetExitStatus = (1u << 8), ///< set this flag so lldb & the handee don't race to set its exit status. eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub ///< should detach rather than killing ///< the debugee ///< if it loses connection with lldb. eLaunchFlagShellExpandArguments = (1u << 10), ///< Perform shell-style argument expansion eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit }; /// Thread Run Modes. enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping }; /// Byte ordering definitions. enum ByteOrder { eByteOrderInvalid = 0, eByteOrderBig = 1, eByteOrderPDP = 2, eByteOrderLittle = 4 }; /// Register encoding definitions. enum Encoding { eEncodingInvalid = 0, eEncodingUint, ///< unsigned integer eEncodingSint, ///< signed integer eEncodingIEEE754, ///< float eEncodingVector ///< vector registers }; /// Display format definitions. enum Format { eFormatDefault = 0, eFormatInvalid = 0, eFormatBoolean, eFormatBinary, eFormatBytes, eFormatBytesWithASCII, eFormatChar, eFormatCharPrintable, ///< Only printable characters, space if not printable eFormatComplex, ///< Floating point complex type eFormatComplexFloat = eFormatComplex, eFormatCString, ///< NULL terminated C strings eFormatDecimal, eFormatEnum, eFormatHex, eFormatHexUppercase, eFormatFloat, eFormatOctal, eFormatOSType, ///< OS character codes encoded into an integer 'PICT' 'text' ///< etc... eFormatUnicode16, eFormatUnicode32, eFormatUnsigned, eFormatPointer, eFormatVectorOfChar, eFormatVectorOfSInt8, eFormatVectorOfUInt8, eFormatVectorOfSInt16, eFormatVectorOfUInt16, eFormatVectorOfSInt32, eFormatVectorOfUInt32, eFormatVectorOfSInt64, eFormatVectorOfUInt64, eFormatVectorOfFloat16, eFormatVectorOfFloat32, eFormatVectorOfFloat64, eFormatVectorOfUInt128, eFormatComplexInteger, ///< Integer complex type eFormatCharArray, ///< Print characters with no single quotes, used for ///< character arrays that can contain non printable ///< characters eFormatAddressInfo, ///< Describe what an address points to (func + offset ///< with file/line, symbol + offset, data, etc) eFormatHexFloat, ///< ISO C99 hex float string eFormatInstruction, ///< Disassemble an opcode eFormatVoid, ///< Do not print this eFormatUnicode8, kNumFormats }; /// Description levels for "void GetDescription(Stream *, DescriptionLevel)" /// calls. enum DescriptionLevel { eDescriptionLevelBrief = 0, eDescriptionLevelFull, eDescriptionLevelVerbose, eDescriptionLevelInitial, kNumDescriptionLevels }; /// Script interpreter types. enum ScriptLanguage { eScriptLanguageNone = 0, eScriptLanguagePython, eScriptLanguageLua, eScriptLanguageUnknown, - eScriptLanguageDefault = eScriptLanguagePython + eScriptLanguageDefault = eScriptLanguageLua }; /// Register numbering types. // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of // these to the lldb internal register numbering scheme (eRegisterKindLLDB). enum RegisterKind { eRegisterKindEHFrame = 0, ///< the register numbers seen in eh_frame eRegisterKindDWARF, ///< the register numbers seen DWARF eRegisterKindGeneric, ///< insn ptr reg, stack ptr reg, etc not specific to ///< any particular target eRegisterKindProcessPlugin, ///< num used by the process plugin - e.g. by the ///< remote gdb-protocol stub program eRegisterKindLLDB, ///< lldb's internal register numbers kNumRegisterKinds }; /// Thread stop reasons. enum StopReason { eStopReasonInvalid = 0, eStopReasonNone, eStopReasonTrace, eStopReasonBreakpoint, eStopReasonWatchpoint, eStopReasonSignal, eStopReasonException, eStopReasonExec, ///< Program was re-exec'ed eStopReasonPlanComplete, eStopReasonThreadExiting, eStopReasonInstrumentation }; /// Command Return Status Types. enum ReturnStatus { eReturnStatusInvalid, eReturnStatusSuccessFinishNoResult, eReturnStatusSuccessFinishResult, eReturnStatusSuccessContinuingNoResult, eReturnStatusSuccessContinuingResult, eReturnStatusStarted, eReturnStatusFailed, eReturnStatusQuit }; /// The results of expression evaluation. enum ExpressionResults { eExpressionCompleted = 0, eExpressionSetupError, eExpressionParseError, eExpressionDiscarded, eExpressionInterrupted, eExpressionHitBreakpoint, eExpressionTimedOut, eExpressionResultUnavailable, eExpressionStoppedForDebug, eExpressionThreadVanished }; enum SearchDepth { eSearchDepthInvalid = 0, eSearchDepthTarget, eSearchDepthModule, eSearchDepthCompUnit, eSearchDepthFunction, eSearchDepthBlock, eSearchDepthAddress, kLastSearchDepthKind = eSearchDepthAddress }; /// Connection Status Types. enum ConnectionStatus { eConnectionStatusSuccess, ///< Success eConnectionStatusEndOfFile, ///< End-of-file encountered eConnectionStatusError, ///< Check GetError() for details eConnectionStatusTimedOut, ///< Request timed out eConnectionStatusNoConnection, ///< No connection eConnectionStatusLostConnection, ///< Lost connection while connected to a ///< valid connection eConnectionStatusInterrupted ///< Interrupted read }; enum ErrorType { eErrorTypeInvalid, eErrorTypeGeneric, ///< Generic errors that can be any value. eErrorTypeMachKernel, ///< Mach kernel error codes. eErrorTypePOSIX, ///< POSIX error codes. eErrorTypeExpression, ///< These are from the ExpressionResults enum. eErrorTypeWin32 ///< Standard Win32 error codes. }; enum ValueType { eValueTypeInvalid = 0, eValueTypeVariableGlobal = 1, ///< globals variable eValueTypeVariableStatic = 2, ///< static variable eValueTypeVariableArgument = 3, ///< function argument variables eValueTypeVariableLocal = 4, ///< function local variables eValueTypeRegister = 5, ///< stack frame register value eValueTypeRegisterSet = 6, ///< A collection of stack frame register values eValueTypeConstResult = 7, ///< constant result variables eValueTypeVariableThreadLocal = 8 ///< thread local storage variable }; /// Token size/granularities for Input Readers. enum InputReaderGranularity { eInputReaderGranularityInvalid = 0, eInputReaderGranularityByte, eInputReaderGranularityWord, eInputReaderGranularityLine, eInputReaderGranularityAll }; /// These mask bits allow a common interface for queries that can /// limit the amount of information that gets parsed to only the /// information that is requested. These bits also can indicate what /// actually did get resolved during query function calls. /// /// Each definition corresponds to a one of the member variables /// in this class, and requests that that item be resolved, or /// indicates that the member did get resolved. FLAGS_ENUM(SymbolContextItem){ /// Set when \a target is requested from a query, or was located /// in query results eSymbolContextTarget = (1u << 0), /// Set when \a module is requested from a query, or was located /// in query results eSymbolContextModule = (1u << 1), /// Set when \a comp_unit is requested from a query, or was /// located in query results eSymbolContextCompUnit = (1u << 2), /// Set when \a function is requested from a query, or was located /// in query results eSymbolContextFunction = (1u << 3), /// Set when the deepest \a block is requested from a query, or /// was located in query results eSymbolContextBlock = (1u << 4), /// Set when \a line_entry is requested from a query, or was /// located in query results eSymbolContextLineEntry = (1u << 5), /// Set when \a symbol is requested from a query, or was located /// in query results eSymbolContextSymbol = (1u << 6), /// Indicates to try and lookup everything up during a routine /// symbol context query. eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1u), /// Set when \a global or static variable is requested from a /// query, or was located in query results. /// eSymbolContextVariable is potentially expensive to lookup so /// it isn't included in eSymbolContextEverything which stops it /// from being used during frame PC lookups and many other /// potential address to symbol context lookups. eSymbolContextVariable = (1u << 7), }; LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem) FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0), ePermissionsReadable = (1u << 1), ePermissionsExecutable = (1u << 2)}; LLDB_MARK_AS_BITMASK_ENUM(Permissions) enum InputReaderAction { eInputReaderActivate, ///< reader is newly pushed onto the reader stack eInputReaderAsynchronousOutputWritten, ///< an async output event occurred; ///< the reader may want to do ///< something eInputReaderReactivate, ///< reader is on top of the stack again after another ///< reader was popped off eInputReaderDeactivate, ///< another reader was pushed on the stack eInputReaderGotToken, ///< reader got one of its tokens (granularity) eInputReaderInterrupt, ///< reader received an interrupt signal (probably from ///< a control-c) eInputReaderEndOfFile, ///< reader received an EOF char (probably from a ///< control-d) eInputReaderDone ///< reader was just popped off the stack and is done }; FLAGS_ENUM(BreakpointEventType){ eBreakpointEventTypeInvalidType = (1u << 0), eBreakpointEventTypeAdded = (1u << 1), eBreakpointEventTypeRemoved = (1u << 2), eBreakpointEventTypeLocationsAdded = (1u << 3), ///< Locations added doesn't ///< get sent when the ///< breakpoint is created eBreakpointEventTypeLocationsRemoved = (1u << 4), eBreakpointEventTypeLocationsResolved = (1u << 5), eBreakpointEventTypeEnabled = (1u << 6), eBreakpointEventTypeDisabled = (1u << 7), eBreakpointEventTypeCommandChanged = (1u << 8), eBreakpointEventTypeConditionChanged = (1u << 9), eBreakpointEventTypeIgnoreChanged = (1u << 10), eBreakpointEventTypeThreadChanged = (1u << 11), eBreakpointEventTypeAutoContinueChanged = (1u << 12)}; FLAGS_ENUM(WatchpointEventType){ eWatchpointEventTypeInvalidType = (1u << 0), eWatchpointEventTypeAdded = (1u << 1), eWatchpointEventTypeRemoved = (1u << 2), eWatchpointEventTypeEnabled = (1u << 6), eWatchpointEventTypeDisabled = (1u << 7), eWatchpointEventTypeCommandChanged = (1u << 8), eWatchpointEventTypeConditionChanged = (1u << 9), eWatchpointEventTypeIgnoreChanged = (1u << 10), eWatchpointEventTypeThreadChanged = (1u << 11), eWatchpointEventTypeTypeChanged = (1u << 12)}; /// Programming language type. /// /// These enumerations use the same language enumerations as the DWARF /// specification for ease of use and consistency. /// The enum -> string code is in Language.cpp, don't change this /// table without updating that code as well. enum LanguageType { eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value. eLanguageTypeC89 = 0x0001, ///< ISO C:1989. eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R. eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983. eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998. eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974. eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985. eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77. eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90. eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983. eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996. eLanguageTypeJava = 0x000b, ///< Java. eLanguageTypeC99 = 0x000c, ///< ISO C:1999. eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995. eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95. eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976. eLanguageTypeObjC = 0x0010, ///< Objective-C. eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++. eLanguageTypeUPC = 0x0012, ///< Unified Parallel C. eLanguageTypeD = 0x0013, ///< D. eLanguageTypePython = 0x0014, ///< Python. // NOTE: The below are DWARF5 constants, subject to change upon // completion of the DWARF5 specification eLanguageTypeOpenCL = 0x0015, ///< OpenCL. eLanguageTypeGo = 0x0016, ///< Go. eLanguageTypeModula3 = 0x0017, ///< Modula 3. eLanguageTypeHaskell = 0x0018, ///< Haskell. eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003. eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011. eLanguageTypeOCaml = 0x001b, ///< OCaml. eLanguageTypeRust = 0x001c, ///< Rust. eLanguageTypeC11 = 0x001d, ///< ISO C:2011. eLanguageTypeSwift = 0x001e, ///< Swift. eLanguageTypeJulia = 0x001f, ///< Julia. eLanguageTypeDylan = 0x0020, ///< Dylan. eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014. eLanguageTypeFortran03 = 0x0022, ///< ISO Fortran 2003. eLanguageTypeFortran08 = 0x0023, ///< ISO Fortran 2008. // Vendor Extensions // Note: Language::GetNameForLanguageType // assumes these can be used as indexes into array language_names, and // Language::SetLanguageFromCString and Language::AsCString assume these can // be used as indexes into array g_languages. eLanguageTypeMipsAssembler = 0x0024, ///< Mips_Assembler. eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript. eNumLanguageTypes }; enum InstrumentationRuntimeType { eInstrumentationRuntimeTypeAddressSanitizer = 0x0000, eInstrumentationRuntimeTypeThreadSanitizer = 0x0001, eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002, eInstrumentationRuntimeTypeMainThreadChecker = 0x0003, eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004, eNumInstrumentationRuntimeTypes }; enum DynamicValueType { eNoDynamicValues = 0, eDynamicCanRunTarget = 1, eDynamicDontRunTarget = 2 }; enum StopShowColumn { eStopShowColumnAnsiOrCaret = 0, eStopShowColumnAnsi = 1, eStopShowColumnCaret = 2, eStopShowColumnNone = 3 }; enum AccessType { eAccessNone, eAccessPublic, eAccessPrivate, eAccessProtected, eAccessPackage }; enum CommandArgumentType { eArgTypeAddress = 0, eArgTypeAddressOrExpression, eArgTypeAliasName, eArgTypeAliasOptions, eArgTypeArchitecture, eArgTypeBoolean, eArgTypeBreakpointID, eArgTypeBreakpointIDRange, eArgTypeBreakpointName, eArgTypeByteSize, eArgTypeClassName, eArgTypeCommandName, eArgTypeCount, eArgTypeDescriptionVerbosity, eArgTypeDirectoryName, eArgTypeDisassemblyFlavor, eArgTypeEndAddress, eArgTypeExpression, eArgTypeExpressionPath, eArgTypeExprFormat, eArgTypeFilename, eArgTypeFormat, eArgTypeFrameIndex, eArgTypeFullName, eArgTypeFunctionName, eArgTypeFunctionOrSymbol, eArgTypeGDBFormat, eArgTypeHelpText, eArgTypeIndex, eArgTypeLanguage, eArgTypeLineNum, eArgTypeLogCategory, eArgTypeLogChannel, eArgTypeMethod, eArgTypeName, eArgTypeNewPathPrefix, eArgTypeNumLines, eArgTypeNumberPerLine, eArgTypeOffset, eArgTypeOldPathPrefix, eArgTypeOneLiner, eArgTypePath, eArgTypePermissionsNumber, eArgTypePermissionsString, eArgTypePid, eArgTypePlugin, eArgTypeProcessName, eArgTypePythonClass, eArgTypePythonFunction, eArgTypePythonScript, eArgTypeQueueName, eArgTypeRegisterName, eArgTypeRegularExpression, eArgTypeRunArgs, eArgTypeRunMode, eArgTypeScriptedCommandSynchronicity, eArgTypeScriptLang, eArgTypeSearchWord, eArgTypeSelector, eArgTypeSettingIndex, eArgTypeSettingKey, eArgTypeSettingPrefix, eArgTypeSettingVariableName, eArgTypeShlibName, eArgTypeSourceFile, eArgTypeSortOrder, eArgTypeStartAddress, eArgTypeSummaryString, eArgTypeSymbol, eArgTypeThreadID, eArgTypeThreadIndex, eArgTypeThreadName, eArgTypeTypeName, eArgTypeUnsignedInteger, eArgTypeUnixSignal, eArgTypeVarName, eArgTypeValue, eArgTypeWidth, eArgTypeNone, eArgTypePlatform, eArgTypeWatchpointID, eArgTypeWatchpointIDRange, eArgTypeWatchType, eArgRawInput, eArgTypeCommand, eArgTypeColumnNum, eArgTypeLastArg // Always keep this entry as the last entry in this // enumeration!! }; /// Symbol types. // Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63 // entries you will have to resize that field. enum SymbolType { eSymbolTypeAny = 0, eSymbolTypeInvalid = 0, eSymbolTypeAbsolute, eSymbolTypeCode, eSymbolTypeResolver, eSymbolTypeData, eSymbolTypeTrampoline, eSymbolTypeRuntime, eSymbolTypeException, eSymbolTypeSourceFile, eSymbolTypeHeaderFile, eSymbolTypeObjectFile, eSymbolTypeCommonBlock, eSymbolTypeBlock, eSymbolTypeLocal, eSymbolTypeParam, eSymbolTypeVariable, eSymbolTypeVariableType, eSymbolTypeLineEntry, eSymbolTypeLineHeader, eSymbolTypeScopeBegin, eSymbolTypeScopeEnd, eSymbolTypeAdditional, ///< When symbols take more than one entry, the extra ///< entries get this type eSymbolTypeCompiler, eSymbolTypeInstrumentation, eSymbolTypeUndefined, eSymbolTypeObjCClass, eSymbolTypeObjCMetaClass, eSymbolTypeObjCIVar, eSymbolTypeReExported }; enum SectionType { eSectionTypeInvalid, eSectionTypeCode, eSectionTypeContainer, ///< The section contains child sections eSectionTypeData, eSectionTypeDataCString, ///< Inlined C string data eSectionTypeDataCStringPointers, ///< Pointers to C string data eSectionTypeDataSymbolAddress, ///< Address of a symbol in the symbol table eSectionTypeData4, eSectionTypeData8, eSectionTypeData16, eSectionTypeDataPointers, eSectionTypeDebug, eSectionTypeZeroFill, eSectionTypeDataObjCMessageRefs, ///< Pointer to function pointer + selector eSectionTypeDataObjCCFStrings, ///< Objective-C const CFString/NSString ///< objects eSectionTypeDWARFDebugAbbrev, eSectionTypeDWARFDebugAddr, eSectionTypeDWARFDebugAranges, eSectionTypeDWARFDebugCuIndex, eSectionTypeDWARFDebugFrame, eSectionTypeDWARFDebugInfo, eSectionTypeDWARFDebugLine, eSectionTypeDWARFDebugLoc, eSectionTypeDWARFDebugMacInfo, eSectionTypeDWARFDebugMacro, eSectionTypeDWARFDebugPubNames, eSectionTypeDWARFDebugPubTypes, eSectionTypeDWARFDebugRanges, eSectionTypeDWARFDebugStr, eSectionTypeDWARFDebugStrOffsets, eSectionTypeDWARFAppleNames, eSectionTypeDWARFAppleTypes, eSectionTypeDWARFAppleNamespaces, eSectionTypeDWARFAppleObjC, eSectionTypeELFSymbolTable, ///< Elf SHT_SYMTAB section eSectionTypeELFDynamicSymbols, ///< Elf SHT_DYNSYM section eSectionTypeELFRelocationEntries, ///< Elf SHT_REL or SHT_REL section eSectionTypeELFDynamicLinkInfo, ///< Elf SHT_DYNAMIC section eSectionTypeEHFrame, eSectionTypeARMexidx, eSectionTypeARMextab, eSectionTypeCompactUnwind, ///< compact unwind section in Mach-O, ///< __TEXT,__unwind_info eSectionTypeGoSymtab, eSectionTypeAbsoluteAddress, ///< Dummy section for symbols with absolute ///< address eSectionTypeDWARFGNUDebugAltLink, eSectionTypeDWARFDebugTypes, ///< DWARF .debug_types section eSectionTypeDWARFDebugNames, ///< DWARF v5 .debug_names eSectionTypeOther, eSectionTypeDWARFDebugLineStr, ///< DWARF v5 .debug_line_str eSectionTypeDWARFDebugRngLists, ///< DWARF v5 .debug_rnglists eSectionTypeDWARFDebugLocLists, ///< DWARF v5 .debug_loclists eSectionTypeDWARFDebugAbbrevDwo, eSectionTypeDWARFDebugInfoDwo, eSectionTypeDWARFDebugStrDwo, eSectionTypeDWARFDebugStrOffsetsDwo, eSectionTypeDWARFDebugTypesDwo, eSectionTypeDWARFDebugRngListsDwo, eSectionTypeDWARFDebugLocDwo, eSectionTypeDWARFDebugLocListsDwo, eSectionTypeDWARFDebugTuIndex, }; FLAGS_ENUM(EmulateInstructionOptions){ eEmulateInstructionOptionNone = (0u), eEmulateInstructionOptionAutoAdvancePC = (1u << 0), eEmulateInstructionOptionIgnoreConditions = (1u << 1)}; FLAGS_ENUM(FunctionNameType){ eFunctionNameTypeNone = 0u, eFunctionNameTypeAuto = (1u << 1), ///< Automatically figure out which FunctionNameType ///< bits to set based on the function name. eFunctionNameTypeFull = (1u << 2), ///< The function name. ///< For C this is the same as just the name of the function For C++ this is ///< the mangled or demangled version of the mangled name. For ObjC this is ///< the full function signature with the + or - and the square brackets and ///< the class and selector eFunctionNameTypeBase = (1u << 3), ///< The function name only, no namespaces ///< or arguments and no class ///< methods or selectors will be searched. eFunctionNameTypeMethod = (1u << 4), ///< Find function by method name (C++) ///< with no namespace or arguments eFunctionNameTypeSelector = (1u << 5), ///< Find function by selector name (ObjC) names eFunctionNameTypeAny = eFunctionNameTypeAuto ///< DEPRECATED: use eFunctionNameTypeAuto }; LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType) /// Basic types enumeration for the public API SBType::GetBasicType(). enum BasicType { eBasicTypeInvalid = 0, eBasicTypeVoid = 1, eBasicTypeChar, eBasicTypeSignedChar, eBasicTypeUnsignedChar, eBasicTypeWChar, eBasicTypeSignedWChar, eBasicTypeUnsignedWChar, eBasicTypeChar16, eBasicTypeChar32, eBasicTypeShort, eBasicTypeUnsignedShort, eBasicTypeInt, eBasicTypeUnsignedInt, eBasicTypeLong, eBasicTypeUnsignedLong, eBasicTypeLongLong, eBasicTypeUnsignedLongLong, eBasicTypeInt128, eBasicTypeUnsignedInt128, eBasicTypeBool, eBasicTypeHalf, eBasicTypeFloat, eBasicTypeDouble, eBasicTypeLongDouble, eBasicTypeFloatComplex, eBasicTypeDoubleComplex, eBasicTypeLongDoubleComplex, eBasicTypeObjCID, eBasicTypeObjCClass, eBasicTypeObjCSel, eBasicTypeNullPtr, eBasicTypeOther }; enum TraceType { eTraceTypeNone = 0, // Hardware Trace generated by the processor. eTraceTypeProcessorTrace }; enum StructuredDataType { eStructuredDataTypeInvalid = -1, eStructuredDataTypeNull = 0, eStructuredDataTypeGeneric, eStructuredDataTypeArray, eStructuredDataTypeInteger, eStructuredDataTypeFloat, eStructuredDataTypeBoolean, eStructuredDataTypeString, eStructuredDataTypeDictionary }; FLAGS_ENUM(TypeClass){ eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0), eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2), eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4), eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6), eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8), eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10), eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12), eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14), eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16), eTypeClassVector = (1u << 17), // Define the last type class as the MSBit of a 32 bit value eTypeClassOther = (1u << 31), // Define a mask that can be used for any type when finding types eTypeClassAny = (0xffffffffu)}; LLDB_MARK_AS_BITMASK_ENUM(TypeClass) enum TemplateArgumentKind { eTemplateArgumentKindNull = 0, eTemplateArgumentKindType, eTemplateArgumentKindDeclaration, eTemplateArgumentKindIntegral, eTemplateArgumentKindTemplate, eTemplateArgumentKindTemplateExpansion, eTemplateArgumentKindExpression, eTemplateArgumentKindPack, eTemplateArgumentKindNullPtr, }; /// Options that can be set for a formatter to alter its behavior. Not /// all of these are applicable to all formatter types. FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u), eTypeOptionCascade = (1u << 0), eTypeOptionSkipPointers = (1u << 1), eTypeOptionSkipReferences = (1u << 2), eTypeOptionHideChildren = (1u << 3), eTypeOptionHideValue = (1u << 4), eTypeOptionShowOneLiner = (1u << 5), eTypeOptionHideNames = (1u << 6), eTypeOptionNonCacheable = (1u << 7), eTypeOptionHideEmptyAggregates = (1u << 8), eTypeOptionFrontEndWantsDereference = (1u << 9)}; /// This is the return value for frame comparisons. If you are comparing frame /// A to frame B the following cases arise: /// /// 1) When frame A pushes frame B (or a frame that ends up pushing /// B) A is Older than B. /// /// 2) When frame A pushed frame B (or if frameA is on the stack /// but B is not) A is Younger than B. /// /// 3) When frame A and frame B have the same StackID, they are /// Equal. /// /// 4) When frame A and frame B have the same immediate parent /// frame, but are not equal, the comparison yields SameParent. /// /// 5) If the two frames are on different threads or processes the /// comparison is Invalid. /// /// 6) If for some reason we can't figure out what went on, we /// return Unknown. enum FrameComparison { eFrameCompareInvalid, eFrameCompareUnknown, eFrameCompareEqual, eFrameCompareSameParent, eFrameCompareYounger, eFrameCompareOlder }; /// File Permissions. /// /// Designed to mimic the unix file permission bits so they can be used with /// functions that set 'mode_t' to certain values for permissions. FLAGS_ENUM(FilePermissions){ eFilePermissionsUserRead = (1u << 8), eFilePermissionsUserWrite = (1u << 7), eFilePermissionsUserExecute = (1u << 6), eFilePermissionsGroupRead = (1u << 5), eFilePermissionsGroupWrite = (1u << 4), eFilePermissionsGroupExecute = (1u << 3), eFilePermissionsWorldRead = (1u << 2), eFilePermissionsWorldWrite = (1u << 1), eFilePermissionsWorldExecute = (1u << 0), eFilePermissionsUserRW = (eFilePermissionsUserRead | eFilePermissionsUserWrite | 0), eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 | eFilePermissionsUserExecute), eFilePermissionsUserRWX = (eFilePermissionsUserRead | eFilePermissionsUserWrite | eFilePermissionsUserExecute), eFilePermissionsGroupRW = (eFilePermissionsGroupRead | eFilePermissionsGroupWrite | 0), eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 | eFilePermissionsGroupExecute), eFilePermissionsGroupRWX = (eFilePermissionsGroupRead | eFilePermissionsGroupWrite | eFilePermissionsGroupExecute), eFilePermissionsWorldRW = (eFilePermissionsWorldRead | eFilePermissionsWorldWrite | 0), eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 | eFilePermissionsWorldExecute), eFilePermissionsWorldRWX = (eFilePermissionsWorldRead | eFilePermissionsWorldWrite | eFilePermissionsWorldExecute), eFilePermissionsEveryoneR = (eFilePermissionsUserRead | eFilePermissionsGroupRead | eFilePermissionsWorldRead), eFilePermissionsEveryoneW = (eFilePermissionsUserWrite | eFilePermissionsGroupWrite | eFilePermissionsWorldWrite), eFilePermissionsEveryoneX = (eFilePermissionsUserExecute | eFilePermissionsGroupExecute | eFilePermissionsWorldExecute), eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR | eFilePermissionsEveryoneW | 0), eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 | eFilePermissionsEveryoneX), eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR | eFilePermissionsEveryoneW | eFilePermissionsEveryoneX), eFilePermissionsFileDefault = eFilePermissionsUserRW, eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX, }; /// Queue work item types. /// /// The different types of work that can be enqueued on a libdispatch aka Grand /// Central Dispatch (GCD) queue. enum QueueItemKind { eQueueItemKindUnknown = 0, eQueueItemKindFunction, eQueueItemKindBlock }; /// Queue type. /// /// libdispatch aka Grand Central Dispatch (GCD) queues can be either /// serial (executing on one thread) or concurrent (executing on /// multiple threads). enum QueueKind { eQueueKindUnknown = 0, eQueueKindSerial, eQueueKindConcurrent }; /// Expression Evaluation Stages. /// /// These are the cancellable stages of expression evaluation, passed /// to the expression evaluation callback, so that you can interrupt /// expression evaluation at the various points in its lifecycle. enum ExpressionEvaluationPhase { eExpressionEvaluationParse = 0, eExpressionEvaluationIRGen, eExpressionEvaluationExecution, eExpressionEvaluationComplete }; /// Watchpoint Kind. /// /// Indicates what types of events cause the watchpoint to fire. Used by Native /// *Protocol-related classes. FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0), eWatchpointKindRead = (1u << 1)}; enum GdbSignal { eGdbSignalBadAccess = 0x91, eGdbSignalBadInstruction = 0x92, eGdbSignalArithmetic = 0x93, eGdbSignalEmulation = 0x94, eGdbSignalSoftware = 0x95, eGdbSignalBreakpoint = 0x96 }; /// Used with SBHost::GetPath (lldb::PathType) to find files that are /// related to LLDB on the current host machine. Most files are /// relative to LLDB or are in known locations. enum PathType { ePathTypeLLDBShlibDir, ///< The directory where the lldb.so (unix) or LLDB ///< mach-o file in LLDB.framework (MacOSX) exists ePathTypeSupportExecutableDir, ///< Find LLDB support executable directory ///< (debugserver, etc) ePathTypeHeaderDir, ///< Find LLDB header file directory ePathTypePythonDir, ///< Find Python modules (PYTHONPATH) directory ePathTypeLLDBSystemPlugins, ///< System plug-ins directory ePathTypeLLDBUserPlugins, ///< User plug-ins directory ePathTypeLLDBTempSystemDir, ///< The LLDB temp directory for this system that ///< will be cleaned up on exit ePathTypeGlobalLLDBTempSystemDir, ///< The LLDB temp directory for this ///< system, NOT cleaned up on a process ///< exit. ePathTypeClangDir ///< Find path to Clang builtin headers }; /// Kind of member function. /// /// Used by the type system. enum MemberFunctionKind { eMemberFunctionKindUnknown = 0, ///< Not sure what the type of this is eMemberFunctionKindConstructor, ///< A function used to create instances eMemberFunctionKindDestructor, ///< A function used to tear down existing ///< instances eMemberFunctionKindInstanceMethod, ///< A function that applies to a specific ///< instance eMemberFunctionKindStaticMethod ///< A function that applies to a type rather ///< than any instance }; /// String matching algorithm used by SBTarget. enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith }; /// Bitmask that describes details about a type. FLAGS_ENUM(TypeFlags){ eTypeHasChildren = (1u << 0), eTypeHasValue = (1u << 1), eTypeIsArray = (1u << 2), eTypeIsBlock = (1u << 3), eTypeIsBuiltIn = (1u << 4), eTypeIsClass = (1u << 5), eTypeIsCPlusPlus = (1u << 6), eTypeIsEnumeration = (1u << 7), eTypeIsFuncPrototype = (1u << 8), eTypeIsMember = (1u << 9), eTypeIsObjC = (1u << 10), eTypeIsPointer = (1u << 11), eTypeIsReference = (1u << 12), eTypeIsStructUnion = (1u << 13), eTypeIsTemplate = (1u << 14), eTypeIsTypedef = (1u << 15), eTypeIsVector = (1u << 16), eTypeIsScalar = (1u << 17), eTypeIsInteger = (1u << 18), eTypeIsFloat = (1u << 19), eTypeIsComplex = (1u << 20), eTypeIsSigned = (1u << 21), eTypeInstanceIsPointer = (1u << 22)}; FLAGS_ENUM(CommandFlags){ /// eCommandRequiresTarget /// /// Ensures a valid target is contained in m_exe_ctx prior to executing the /// command. If a target doesn't exist or is invalid, the command will fail /// and CommandObject::GetInvalidTargetDescription() will be returned as the /// error. CommandObject subclasses can override the virtual function for /// GetInvalidTargetDescription() to provide custom strings when needed. eCommandRequiresTarget = (1u << 0), /// eCommandRequiresProcess /// /// Ensures a valid process is contained in m_exe_ctx prior to executing the /// command. If a process doesn't exist or is invalid, the command will fail /// and CommandObject::GetInvalidProcessDescription() will be returned as /// the error. CommandObject subclasses can override the virtual function /// for GetInvalidProcessDescription() to provide custom strings when /// needed. eCommandRequiresProcess = (1u << 1), /// eCommandRequiresThread /// /// Ensures a valid thread is contained in m_exe_ctx prior to executing the /// command. If a thread doesn't exist or is invalid, the command will fail /// and CommandObject::GetInvalidThreadDescription() will be returned as the /// error. CommandObject subclasses can override the virtual function for /// GetInvalidThreadDescription() to provide custom strings when needed. eCommandRequiresThread = (1u << 2), /// eCommandRequiresFrame /// /// Ensures a valid frame is contained in m_exe_ctx prior to executing the /// command. If a frame doesn't exist or is invalid, the command will fail /// and CommandObject::GetInvalidFrameDescription() will be returned as the /// error. CommandObject subclasses can override the virtual function for /// GetInvalidFrameDescription() to provide custom strings when needed. eCommandRequiresFrame = (1u << 3), /// eCommandRequiresRegContext /// /// Ensures a valid register context (from the selected frame if there is a /// frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is /// available from m_exe_ctx prior to executing the command. If a target /// doesn't exist or is invalid, the command will fail and /// CommandObject::GetInvalidRegContextDescription() will be returned as the /// error. CommandObject subclasses can override the virtual function for /// GetInvalidRegContextDescription() to provide custom strings when needed. eCommandRequiresRegContext = (1u << 4), /// eCommandTryTargetAPILock /// /// Attempts to acquire the target lock if a target is selected in the /// command interpreter. If the command object fails to acquire the API /// lock, the command will fail with an appropriate error message. eCommandTryTargetAPILock = (1u << 5), /// eCommandProcessMustBeLaunched /// /// Verifies that there is a launched process in m_exe_ctx, if there isn't, /// the command will fail with an appropriate error message. eCommandProcessMustBeLaunched = (1u << 6), /// eCommandProcessMustBePaused /// /// Verifies that there is a paused process in m_exe_ctx, if there isn't, /// the command will fail with an appropriate error message. eCommandProcessMustBePaused = (1u << 7)}; /// Whether a summary should cap how much data it returns to users or not. enum TypeSummaryCapping { eTypeSummaryCapped = true, eTypeSummaryUncapped = false }; /// The result from a command interpreter run. enum CommandInterpreterResult { /// Command interpreter finished successfully. eCommandInterpreterResultSuccess, /// Stopped because the corresponding option was set and the inferior /// crashed. eCommandInterpreterResultInferiorCrash, /// Stopped because the corresponding option was set and a command returned /// an error. eCommandInterpreterResultCommandError, /// Stopped because quit was requested. eCommandInterpreterResultQuitRequested, }; } // namespace lldb #endif // LLDB_LLDB_ENUMERATIONS_H diff --git a/contrib/llvm-project/lldb/source/Core/CoreProperties.td b/contrib/llvm-project/lldb/source/Core/CoreProperties.td index b04738175f34..8b05b126fe6f 100644 --- a/contrib/llvm-project/lldb/source/Core/CoreProperties.td +++ b/contrib/llvm-project/lldb/source/Core/CoreProperties.td @@ -1,134 +1,134 @@ include "../../include/lldb/Core/PropertiesBase.td" let Definition = "modulelist" in { def EnableExternalLookup: Property<"enable-external-lookup", "Boolean">, Global, DefaultTrue, Desc<"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.">; def ClangModulesCachePath: Property<"clang-modules-cache-path", "FileSpec">, Global, DefaultStringValue<"">, Desc<"The path to the clang modules cache directory (-fmodules-cache-path).">; def SymLinkPaths: Property<"debug-info-symlink-paths", "FileSpecList">, Global, DefaultStringValue<"">, Desc<"Debug info path which should be resolved while parsing, relative to the host filesystem.">; } let Definition = "debugger" in { def AutoConfirm: Property<"auto-confirm", "Boolean">, Global, DefaultFalse, Desc<"If true all confirmation prompts will receive their default reply.">; def DisassemblyFormat: Property<"disassembly-format", "FormatEntity">, Global, DefaultStringValue<"{${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}>}: ">, Desc<"The default disassembly format string to use when disassembling instruction sequences.">; def FrameFormat: Property<"frame-format", "FormatEntity">, Global, DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${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}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">, Desc<"The default frame format string to use when displaying stack frame information for threads.">; def NotiftVoid: Property<"notify-void", "Boolean">, Global, DefaultFalse, Desc<"Notify the user explicitly if an expression returns void (default: false).">; def Prompt: Property<"prompt", "String">, Global, DefaultEnumValue<"OptionValueString::eOptionEncodeCharacterEscapeSequences">, DefaultStringValue<"(lldb) ">, Desc<"The debugger command line prompt displayed for the user.">; def ScriptLanguage: Property<"script-lang", "Enum">, Global, - DefaultEnumValue<"eScriptLanguagePython">, + DefaultEnumValue<"eScriptLanguageLua">, EnumValues<"OptionEnumValues(g_language_enumerators)">, Desc<"The script language to be used for evaluating user-written scripts.">; def StopDisassemblyCount: Property<"stop-disassembly-count", "SInt64">, Global, DefaultUnsignedValue<4>, Desc<"The number of disassembly lines to show when displaying a stopped context.">; def StopDisassemblyDisplay: Property<"stop-disassembly-display", "Enum">, Global, DefaultEnumValue<"Debugger::eStopDisassemblyTypeNoDebugInfo">, EnumValues<"OptionEnumValues(g_show_disassembly_enum_values)">, Desc<"Control when to display disassembly when displaying a stopped context.">; def StopLineCountAfter: Property<"stop-line-count-after", "SInt64">, Global, DefaultUnsignedValue<3>, Desc<"The number of sources lines to display that come after the current source line when displaying a stopped context.">; def StopLineCountBefore: Property<"stop-line-count-before", "SInt64">, Global, DefaultUnsignedValue<3>, Desc<"The number of sources lines to display that come before the current source line when displaying a stopped context.">; def HighlightSource: Property<"highlight-source", "Boolean">, Global, DefaultTrue, Desc<"If true, LLDB will highlight the displayed source code.">; def StopShowColumn: Property<"stop-show-column", "Enum">, DefaultEnumValue<"eStopShowColumnAnsiOrCaret">, EnumValues<"OptionEnumValues(s_stop_show_column_values)">, Desc<"If true, LLDB will use the column information from the debug info to mark the current position when displaying a stopped context.">; def StopShowColumnAnsiPrefix: Property<"stop-show-column-ansi-prefix", "String">, Global, DefaultStringValue<"${ansi.underline}">, Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the column to be marked.">; def StopShowColumnAnsiSuffix: Property<"stop-show-column-ansi-suffix", "String">, Global, DefaultStringValue<"${ansi.normal}">, Desc<"When displaying the column marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the column to be marked.">; def StopShowLineMarkerAnsiPrefix: Property<"stop-show-line-ansi-prefix", "String">, Global, DefaultStringValue<"${ansi.fg.yellow}">, Desc<"When displaying the line marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format at the immediately before the line to be marked.">; def StopShowLineMarkerAnsiSuffix: Property<"stop-show-line-ansi-suffix", "String">, Global, DefaultStringValue<"${ansi.normal}">, Desc<"When displaying the line marker in a color-enabled (i.e. ANSI) terminal, use the ANSI terminal code specified in this format immediately after the line to be marked.">; def TerminalWidth: Property<"term-width", "SInt64">, Global, DefaultUnsignedValue<80>, Desc<"The maximum number of columns to use for displaying text.">; def ThreadFormat: Property<"thread-format", "FormatEntity">, Global, DefaultStringValue<"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">, Desc<"The default thread format string to use when displaying thread information.">; def ThreadStopFormat: Property<"thread-stop-format", "FormatEntity">, Global, DefaultStringValue<"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">, Desc<"The default thread format string to use when displaying thread information as part of the stop display.">; def UseExternalEditor: Property<"use-external-editor", "Boolean">, Global, DefaultFalse, Desc<"Whether to use an external editor or not.">; def UseColor: Property<"use-color", "Boolean">, Global, DefaultTrue, Desc<"Whether to use Ansi color codes or not.">; def UseSourceCache: Property<"use-source-cache", "Boolean">, Global, DefaultTrue, Desc<"Whether to cache source files in memory or not.">; def AutoOneLineSummaries: Property<"auto-one-line-summaries", "Boolean">, Global, DefaultTrue, Desc<"If true, LLDB will automatically display small structs in one-liner format (default: true).">; def AutoIndent: Property<"auto-indent", "Boolean">, Global, DefaultTrue, Desc<"If true, LLDB will auto indent/outdent code. Currently only supported in the REPL (default: true).">; def PrintDecls: Property<"print-decls", "Boolean">, Global, DefaultTrue, Desc<"If true, LLDB will print the values of variables declared in an expression. Currently only supported in the REPL (default: true).">; def TabSize: Property<"tab-size", "UInt64">, Global, DefaultUnsignedValue<4>, Desc<"The tab size to use when indenting code in multi-line input mode (default: 4).">; def EscapeNonPrintables: Property<"escape-non-printables", "Boolean">, Global, DefaultTrue, Desc<"If true, LLDB will automatically escape non-printable and escape characters when formatting strings.">; def FrameFormatUnique: Property<"frame-format-unique", "FormatEntity">, Global, DefaultStringValue<"frame #${frame.index}: ${ansi.fg.yellow}${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}}}{${function.is-optimized} [opt]}{${frame.is-artificial} [artificial]}\\\\n">, Desc<"The default frame format string to use when displaying stack frameinformation for threads from thread backtrace unique.">; }