//===-- 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
};
/// 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 = 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