//===-- 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
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)};
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,
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,
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,
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
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
};
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
};
//----------------------------------------------------------------------
// 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)};
//----------------------------------------------------------------------
// 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
};
//----------------------------------------------------------------------
// Address Class
//
// A way of classifying an address used for disassembling and setting
// breakpoints. Many object files can track exactly what parts of their
// object files are code, data and other information. This is of course
// above and beyond just looking at the section types. For example, code
// might contain PC relative data and the object file might be able to
// tell us that an address in code is data.
//----------------------------------------------------------------------
enum AddressClass {
eAddressClassInvalid,
eAddressClassUnknown,
eAddressClassCode,
eAddressClassCodeAlternateISA,
eAddressClassData,
eAddressClassDebug,
eAddressClassRuntime
};
//----------------------------------------------------------------------
// 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){eWatchpointKindRead = (1u << 0),
eWatchpointKindWrite = (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_
