| //===-- 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 <type_traits> |
| |
| #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<Enum>( \ |
| static_cast<std::underlying_type<Enum>::type>(a) | \ |
| static_cast<std::underlying_type<Enum>::type>(b)); \ |
| } \ |
| constexpr Enum operator&(Enum a, Enum b) { \ |
| return static_cast<Enum>( \ |
| static_cast<std::underlying_type<Enum>::type>(a) & \ |
| static_cast<std::underlying_type<Enum>::type>(b)); \ |
| } \ |
| constexpr Enum operator~(Enum a) { \ |
| return static_cast<Enum>( \ |
| ~static_cast<std::underlying_type<Enum>::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 |
| eLaunchFlagInheritTCCFromParent = |
| (1u << 12), ///< Don't make the inferior responsible for its own TCC |
| ///< permissions but instead inherit them from its parent. |
| }; |
| |
| /// 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, '.' 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 |
| }; |
| |
| /// 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, |
| eStopReasonProcessorTrace, |
| eStopReasonFork, |
| eStopReasonVFork, |
| eStopReasonVForkDone, |
| }; |
| |
| /// 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, |
| eArgTypeFileLineColumn, |
| 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, |
| eArgTypeModuleUUID, |
| eArgTypeSaveCoreStyle, |
| 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 |
| }; |
| |
| /// Deprecated |
| enum TraceType { |
| eTraceTypeNone = 0, |
| |
| /// Intel Processor Trace |
| 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 |
| }; |
| |
| /// Architecture-agnostic categorization of instructions for traversing the |
| /// control flow of a trace. |
| /// |
| /// A single instruction can match one or more of these categories. |
| FLAGS_ENUM(TraceInstructionControlFlowType){ |
| /// Any instruction. |
| eTraceInstructionControlFlowTypeInstruction = (1u << 1), |
| /// A conditional or unconditional branch/jump. |
| eTraceInstructionControlFlowTypeBranch = (1u << 2), |
| /// A conditional or unconditional branch/jump that changed |
| /// the control flow of the program. |
| eTraceInstructionControlFlowTypeTakenBranch = (1u << 3), |
| /// A call to a function. |
| eTraceInstructionControlFlowTypeCall = (1u << 4), |
| /// A return from a function. |
| eTraceInstructionControlFlowTypeReturn = (1u << 5)}; |
| |
| LLDB_MARK_AS_BITMASK_ENUM(TraceInstructionControlFlowType) |
| |
| /// 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 SBHostOS::GetLLDBPath (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), |
| /// eCommandProcessMustBeTraced |
| /// |
| /// Verifies that the process is being traced by a Trace plug-in, if it |
| /// isn't the command will fail with an appropriate error message. |
| eCommandProcessMustBeTraced = (1u << 8)}; |
| |
| /// 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, |
| }; |
| |
| // Style of core file to create when calling SaveCore. |
| enum SaveCoreStyle { |
| eSaveCoreUnspecified = 0, |
| eSaveCoreFull = 1, |
| eSaveCoreDirtyOnly = 2, |
| eSaveCoreStackOnly = 3, |
| }; |
| |
| } // namespace lldb |
| |
| #endif // LLDB_LLDB_ENUMERATIONS_H |
