liblldb-3.6-dev 1:3.6.2-3ubuntu2 / usr / lib / llvm-3.6 / include / lldb / lldb-enumerations.h

//===-- 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_

namespace lldb {

    //----------------------------------------------------------------------
    // Process and Thread States
    //----------------------------------------------------------------------
    typedef 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.
    } StateType;

    //----------------------------------------------------------------------
    // Launch Flags
    //----------------------------------------------------------------------
    typedef 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.
    } LaunchFlags;
        
    //----------------------------------------------------------------------
    // Thread Run Modes
    //----------------------------------------------------------------------
    typedef enum RunMode {
        eOnlyThisThread,
        eAllThreads,
        eOnlyDuringStepping
    } RunMode;

    //----------------------------------------------------------------------
    // Byte ordering definitions
    //----------------------------------------------------------------------
    typedef enum ByteOrder
    {
        eByteOrderInvalid   = 0,
        eByteOrderBig       = 1,
        eByteOrderPDP       = 2,
        eByteOrderLittle    = 4
    } ByteOrder;

    //----------------------------------------------------------------------
    // Register encoding definitions
    //----------------------------------------------------------------------
    typedef enum Encoding
    {
        eEncodingInvalid = 0,
        eEncodingUint,               // unsigned integer
        eEncodingSint,               // signed integer
        eEncodingIEEE754,            // float
        eEncodingVector              // vector registers
    } Encoding;

    //----------------------------------------------------------------------
    // Display format definitions
    //----------------------------------------------------------------------
    typedef 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,
        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
    } Format;

    //----------------------------------------------------------------------
    // Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls
    //----------------------------------------------------------------------
    typedef enum DescriptionLevel
    {
        eDescriptionLevelBrief = 0,
        eDescriptionLevelFull,
        eDescriptionLevelVerbose,
        eDescriptionLevelInitial,
        kNumDescriptionLevels
    } DescriptionLevel;

    //----------------------------------------------------------------------
    // Script interpreter types
    //----------------------------------------------------------------------
    typedef enum ScriptLanguage
    {
        eScriptLanguageNone,
        eScriptLanguagePython,
        eScriptLanguageDefault = eScriptLanguagePython
    } ScriptLanguage;

    //----------------------------------------------------------------------
    // Register numbering types
    // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert
    // any of these to the lldb internal register numbering scheme 
    // (eRegisterKindLLDB).
    //----------------------------------------------------------------------
    typedef enum RegisterKind
    {
        eRegisterKindGCC = 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
        eRegisterKindGDB,        // the register numbers gdb uses (matches stabs numbers)
        eRegisterKindLLDB,       // lldb's internal register numbers
        kNumRegisterKinds
    } RegisterKind;

    //----------------------------------------------------------------------
    // Thread stop reasons
    //----------------------------------------------------------------------
    typedef enum StopReason
    {
        eStopReasonInvalid = 0,
        eStopReasonNone,
        eStopReasonTrace,
        eStopReasonBreakpoint,
        eStopReasonWatchpoint,
        eStopReasonSignal,
        eStopReasonException,
        eStopReasonExec,        // Program was re-exec'ed
        eStopReasonPlanComplete,
        eStopReasonThreadExiting,
        eStopReasonInstrumentation
    } StopReason;

    //----------------------------------------------------------------------
    // Command Return Status Types
    //----------------------------------------------------------------------
    typedef enum ReturnStatus
    {
        eReturnStatusInvalid,
        eReturnStatusSuccessFinishNoResult,
        eReturnStatusSuccessFinishResult,
        eReturnStatusSuccessContinuingNoResult,
        eReturnStatusSuccessContinuingResult,
        eReturnStatusStarted,
        eReturnStatusFailed,
        eReturnStatusQuit
    } ReturnStatus;


    //----------------------------------------------------------------------
    // The results of expression evaluation:
    //----------------------------------------------------------------------
    typedef enum ExpressionResults
    {
        eExpressionCompleted = 0,
        eExpressionSetupError,
        eExpressionParseError,
        eExpressionDiscarded,
        eExpressionInterrupted,
        eExpressionHitBreakpoint,
        eExpressionTimedOut,
        eExpressionResultUnavailable,
        eExpressionStoppedForDebug
    } ExpressionResults;

    //----------------------------------------------------------------------
    // Connection Status Types
    //----------------------------------------------------------------------
    typedef 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
    } ConnectionStatus;

    typedef 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.
    } ErrorType;


    typedef 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
    } ValueType;

    //----------------------------------------------------------------------
    // Token size/granularities for Input Readers
    //----------------------------------------------------------------------

    typedef enum InputReaderGranularity
    {
        eInputReaderGranularityInvalid = 0,
        eInputReaderGranularityByte,
        eInputReaderGranularityWord,
        eInputReaderGranularityLine,
        eInputReaderGranularityAll
    } InputReaderGranularity;

    //------------------------------------------------------------------
    /// 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.
    //------------------------------------------------------------------
    typedef 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 query.
    } SymbolContextItem;

    typedef enum Permissions
    {
        ePermissionsWritable    = (1u << 0),
        ePermissionsReadable    = (1u << 1),
        ePermissionsExecutable  = (1u << 2)
    } Permissions;

    typedef 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
    } InputReaderAction;

    typedef 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)
    } BreakpointEventType;

    typedef 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)
    } WatchpointEventType;


    //----------------------------------------------------------------------
    /// 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 LanguageRuntime.cpp, don't change this
    /// table without updating that code as well.
    //----------------------------------------------------------------------
    typedef 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.
        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.
        eNumLanguageTypes
    } LanguageType;
    
    typedef enum InstrumentationRuntimeType {
        eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
        eNumInstrumentationRuntimeTypes
    } InstrumentationRuntimeType;

    typedef enum DynamicValueType
    {
        eNoDynamicValues = 0,
        eDynamicCanRunTarget    = 1,
        eDynamicDontRunTarget   = 2
    } DynamicValueType;
    
    typedef enum AccessType
    {
        eAccessNone,
        eAccessPublic,
        eAccessPrivate,
        eAccessProtected,
        eAccessPackage
    } AccessType;

    typedef 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,
        eArgTypeUnsignedInteger,
        eArgTypeUnixSignal,
        eArgTypeVarName,
        eArgTypeValue,
        eArgTypeWidth,
        eArgTypeNone,
        eArgTypePlatform,
        eArgTypeWatchpointID,
        eArgTypeWatchpointIDRange,
        eArgTypeWatchType,
        eArgTypeLastArg  // Always keep this entry as the last entry in this enumeration!!
    } CommandArgumentType;

    //----------------------------------------------------------------------
    // Symbol types
    //----------------------------------------------------------------------
    typedef 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
    } SymbolType;
    
    typedef 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,
        eSectionTypeDWARFDebugAranges,
        eSectionTypeDWARFDebugFrame,
        eSectionTypeDWARFDebugInfo,
        eSectionTypeDWARFDebugLine,
        eSectionTypeDWARFDebugLoc,
        eSectionTypeDWARFDebugMacInfo,
        eSectionTypeDWARFDebugPubNames,
        eSectionTypeDWARFDebugPubTypes,
        eSectionTypeDWARFDebugRanges,
        eSectionTypeDWARFDebugStr,
        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,
        eSectionTypeCompactUnwind,        // compact unwind section in Mach-O, __TEXT,__unwind_info
        eSectionTypeOther
        
    } SectionType;

    typedef enum EmulateInstructionOptions
    {
        eEmulateInstructionOptionNone               = (0u),
        eEmulateInstructionOptionAutoAdvancePC      = (1u << 0),
        eEmulateInstructionOptionIgnoreConditions   = (1u << 1)
    } EmulateInstructionOptions;

    typedef 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
    } FunctionNameType;
    
    
    //----------------------------------------------------------------------
    // Basic types enumeration for the public API SBType::GetBasicType()
    //----------------------------------------------------------------------
    typedef 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
    } BasicType;

    typedef 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)
    } TypeClass;

    typedef enum TemplateArgumentKind
    {
        eTemplateArgumentKindNull = 0,
        eTemplateArgumentKindType,
        eTemplateArgumentKindDeclaration,
        eTemplateArgumentKindIntegral,
        eTemplateArgumentKindTemplate,
        eTemplateArgumentKindTemplateExpansion,
        eTemplateArgumentKindExpression,
        eTemplateArgumentKindPack

    } TemplateArgumentKind;

    //----------------------------------------------------------------------
    // Options that can be set for a formatter to alter its behavior
    // Not all of these are applicable to all formatter types
    //----------------------------------------------------------------------
    typedef 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)
    } TypeOptions;

   //----------------------------------------------------------------------
   // 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 comparision yields
   //    SameParent.
   // 5) If the two frames are on different threads or processes the comparision is Invalid
   // 6) If for some reason we can't figure out what went on, we return Unknown.
   //----------------------------------------------------------------------
   typedef enum FrameComparison
   {
       eFrameCompareInvalid,
       eFrameCompareUnknown,
       eFrameCompareEqual,
       eFrameCompareSameParent,
       eFrameCompareYounger,
       eFrameCompareOlder
   } FrameComparison;
   
    //----------------------------------------------------------------------
    // 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.
    //----------------------------------------------------------------------
    typedef enum AddressClass
    {
        eAddressClassInvalid,
        eAddressClassUnknown,
        eAddressClassCode,
        eAddressClassCodeAlternateISA,
        eAddressClassData,
        eAddressClassDebug,
        eAddressClassRuntime
    } AddressClass;

    //----------------------------------------------------------------------
    // 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.
    //----------------------------------------------------------------------
    typedef 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,
    } FilePermissions;

    //----------------------------------------------------------------------
    // Queue work item types
    //
    // The different types of work that can be enqueued on a libdispatch
    // aka Grand Central Dispatch (GCD) queue.
    //----------------------------------------------------------------------
    typedef enum QueueItemKind
    {
        eQueueItemKindUnknown = 0,
        eQueueItemKindFunction,
        eQueueItemKindBlock
    } QueueItemKind;

    //----------------------------------------------------------------------
    // Queue type
    // libdispatch aka Grand Central Dispatch (GCD) queues can be either serial
    // (executing on one thread) or concurrent (executing on multiple threads).
    //----------------------------------------------------------------------
    typedef enum QueueKind
    {
        eQueueKindUnknown = 0,
        eQueueKindSerial,
        eQueueKindConcurrent
    } QueueKind;
    
    //----------------------------------------------------------------------
    // 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.
    //----------------------------------------------------------------------
    typedef enum ExpressionEvaluationPhase
    {
        eExpressionEvaluationParse = 0,
        eExpressionEvaluationIRGen,
        eExpressionEvaluationExecution,
        eExpressionEvaluationComplete
    } ExpressionEvaluationPhase;
    

    //----------------------------------------------------------------------
    // Watchpoint Kind
    // Indicates what types of events cause the watchpoint to fire.
    // Used by Native*Protocol-related classes.
    //----------------------------------------------------------------------
    typedef enum WatchpointKind
    {
        eWatchpointKindRead = (1u << 0),
        eWatchpointKindWrite = (1u << 1)
    } WatchpointKind;

    typedef enum GdbSignal
    {
        eGdbSignalBadAccess      = 0x91,
        eGdbSignalBadInstruction = 0x92,
        eGdbSignalArithmetic     = 0x93,
        eGdbSignalEmulation      = 0x94,
        eGdbSignalSoftware       = 0x95,
        eGdbSignalBreakpoint     = 0x96
    } GdbRemoteSignal;

    //----------------------------------------------------------------------
    // 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.
    //----------------------------------------------------------------------
    typedef 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
        ePathTypeClangDir               // Find path to Clang builtin headers
    } PathType;
    
    //----------------------------------------------------------------------
    // Kind of member function
    // Used by the type system
    //----------------------------------------------------------------------
    typedef 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
    } MemberFunctionKind;


    //----------------------------------------------------------------------
    // String matching algorithm used by SBTarget
    //----------------------------------------------------------------------
    typedef enum MatchType {
        eMatchTypeNormal,
        eMatchTypeRegex,
        eMatchTypeStartsWith
    } MatchType;
    
    //----------------------------------------------------------------------
    // Bitmask that describes details about a type
    //----------------------------------------------------------------------
    typedef 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)
    } TypeFlags;
    
    //----------------------------------------------------------------------
    // Whether a summary should cap how much data it returns to users or not
    //----------------------------------------------------------------------
    typedef enum TypeSummaryCapping {
        eTypeSummaryCapped = true,
        eTypeSummaryUncapped = false
    } TypeSummaryCapping;

} // namespace lldb


#endif  // LLDB_lldb_enumerations_h_