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_

#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,
        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
    };

    //----------------------------------------------------------------------
    // 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
        eRegisterKindStabs,       // the register numbers used in stabs debug format (referred to as "gcc" or "gdb" numbering)
        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
    };

    //----------------------------------------------------------------------
    // 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 LanguageRuntime.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: LanguageRuntime::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,
        eNumInstrumentationRuntimeTypes
    };

    enum DynamicValueType
    {
        eNoDynamicValues = 0,
        eDynamicCanRunTarget    = 1,
        eDynamicDontRunTarget   = 2
    };
    
    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,
        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,
        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,
        eSectionTypeCompactUnwind,        // compact unwind section in Mach-O, __TEXT,__unwind_info
        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
    };

    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 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.
   //----------------------------------------------------------------------
   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)
    };
    
    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_