| //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_lldb_enumerations_h_ |
| #define LLDB_lldb_enumerations_h_ |
| |
| #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. |
| }; |
| |
| //---------------------------------------------------------------------- |
| // 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 |
| eLaunchFlagDontSetExitStatus = (1u << 8), ///< If you are going to hand the |
| ///process off (e.g. to |
| ///debugserver) |
| ///< 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 |
| kNumFormats |
| }; |
| |
| //---------------------------------------------------------------------- |
| // Description levels for "void GetDescription(Stream *, DescriptionLevel)" |
| // calls |
| //---------------------------------------------------------------------- |
| enum DescriptionLevel { |
| eDescriptionLevelBrief = 0, |
| eDescriptionLevelFull, |
| eDescriptionLevelVerbose, |
| eDescriptionLevelInitial, |
| kNumDescriptionLevels |
| }; |
| |
| //---------------------------------------------------------------------- |
| // Script interpreter types |
| //---------------------------------------------------------------------- |
| enum ScriptLanguage { |
| eScriptLanguageNone, |
| eScriptLanguagePython, |
| eScriptLanguageDefault = eScriptLanguagePython, |
| eScriptLanguageUnknown |
| }; |
| |
| //---------------------------------------------------------------------- |
| // 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 |
| }; |
| |
| //---------------------------------------------------------------------- |
| // 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){ |
| eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from |
| ///a query, or was located in query |
| ///results |
| eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from |
| ///a query, or was located in query |
| ///results |
| eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested |
| ///from a query, or was located in query |
| ///results |
| eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested |
| ///from a query, or was located in query |
| ///results |
| eSymbolContextBlock = (1u << 4), ///< Set when the deepest \a block is |
| ///requested from a query, or was located |
| ///in query results |
| eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is |
| ///requested from a query, or was |
| ///located in query results |
| eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from |
| ///a query, or was located in query |
| ///results |
| eSymbolContextEverything = ((eSymbolContextSymbol << 1) - |
| 1u), ///< Indicates to try and lookup everything |
| ///up during a routine symbol context |
| ///query. |
| eSymbolContextVariable = (1u << 7) ///< 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. |
| }; |
| |
| FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0), |
| ePermissionsReadable = (1u << 1), |
| ePermissionsExecutable = (1u << 2)}; |
| |
| 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, |
| eArgTypeLastArg // Always keep this entry as the last entry in this |
| // enumeration!! |
| }; |
| |
| //---------------------------------------------------------------------- |
| // Symbol types |
| //---------------------------------------------------------------------- |
| 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 |
| }; |
| |
| 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 |
| }; |
| |
| //---------------------------------------------------------------------- |
| // 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)}; |
| |
| 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 frame A 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 |
| }; |
| |
| } // namespace lldb |
| |
| #endif // LLDB_lldb_enumerations_h_ |
