contrib/llvm/tools/lldb/include/lldb/lldb-enumerations.h

   1 //===-- lldb-enumerations.h -------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLDB_lldb_enumerations_h_
  11 #define LLDB_lldb_enumerations_h_
  12
  13 namespace lldb {
  14
  15     //----------------------------------------------------------------------
  16     // Process and Thread States
  17     //----------------------------------------------------------------------
  18     typedef enum StateType
  19     {
  20         eStateInvalid = 0,
  21         eStateUnloaded,     ///< Process is object is valid, but not currently loaded
  22         eStateConnected,    ///< Process is connected to remote debug services, but not launched or attached to anything yet
  23         eStateAttaching,    ///< Process is currently trying to attach
  24         eStateLaunching,    ///< Process is in the process of launching
  25         eStateStopped,      ///< Process or thread is stopped and can be examined.
  26         eStateRunning,      ///< Process or thread is running and can't be examined.
  27         eStateStepping,     ///< Process or thread is in the process of stepping and can not be examined.
  28         eStateCrashed,      ///< Process or thread has crashed and can be examined.
  29         eStateDetached,     ///< Process has been detached and can't be examined.
  30         eStateExited,       ///< Process has exited and can't be examined.
  31         eStateSuspended     ///< Process or thread is in a suspended state as far
  32                             ///< as the debugger is concerned while other processes
  33                             ///< or threads get the chance to run.
  34     } StateType;
  35
  36     //----------------------------------------------------------------------
  37     // Launch Flags
  38     //----------------------------------------------------------------------
  39     typedef enum LaunchFlags
  40     {
  41         eLaunchFlagNone         = 0u,
  42         eLaunchFlagExec         = (1u << 0),  ///< Exec when launching and turn the calling process into a new process
  43         eLaunchFlagDebug        = (1u << 1),  ///< Stop as soon as the process launches to allow the process to be debugged
  44         eLaunchFlagStopAtEntry  = (1u << 2),  ///< Stop at the program entry point instead of auto-continuing when launching or attaching at entry point
  45         eLaunchFlagDisableASLR  = (1u << 3),  ///< Disable Address Space Layout Randomization
  46         eLaunchFlagDisableSTDIO = (1u << 4),  ///< Disable stdio for inferior process (e.g. for a GUI app)
  47         eLaunchFlagLaunchInTTY  = (1u << 5),  ///< Launch the process in a new TTY if supported by the host
  48         eLaunchFlagLaunchInShell= (1u << 6),   ///< Launch the process inside a shell to get shell expansion
  49         eLaunchFlagLaunchInSeparateProcessGroup = (1u << 7), ///< Launch the process in a separate process group
  50         eLaunchFlagsDontMonitorProcess = (1u << 8)  ///< If you are going to hand the process off (e.g. to debugserver)
  51                                                     ///< set this flag so lldb & the handee don't race to reap it.
  52     } LaunchFlags;
  53
  54     //----------------------------------------------------------------------
  55     // Thread Run Modes
  56     //----------------------------------------------------------------------
  57     typedef enum RunMode {
  58         eOnlyThisThread,
  59         eAllThreads,
  60         eOnlyDuringStepping
  61     } RunMode;
  62
  63     //----------------------------------------------------------------------
  64     // Byte ordering definitions
  65     //----------------------------------------------------------------------
  66     typedef enum ByteOrder
  67     {
  68         eByteOrderInvalid   = 0,
  69         eByteOrderBig       = 1,
  70         eByteOrderPDP       = 2,
  71         eByteOrderLittle    = 4
  72     } ByteOrder;
  73
  74     //----------------------------------------------------------------------
  75     // Register encoding definitions
  76     //----------------------------------------------------------------------
  77     typedef enum Encoding
  78     {
  79         eEncodingInvalid = 0,
  80         eEncodingUint,               // unsigned integer
  81         eEncodingSint,               // signed integer
  82         eEncodingIEEE754,            // float
  83         eEncodingVector              // vector registers
  84     } Encoding;
  85
  86     //----------------------------------------------------------------------
  87     // Display format definitions
  88     //----------------------------------------------------------------------
  89     typedef enum Format
  90     {
  91         eFormatDefault = 0,
  92         eFormatInvalid = 0,
  93         eFormatBoolean,
  94         eFormatBinary,
  95         eFormatBytes,
  96         eFormatBytesWithASCII,
  97         eFormatChar,
  98         eFormatCharPrintable,   // Only printable characters, space if not printable
  99         eFormatComplex,         // Floating point complex type
 100         eFormatComplexFloat = eFormatComplex,
 101         eFormatCString,         // NULL terminated C strings
 102         eFormatDecimal,
 103         eFormatEnum,
 104         eFormatHex,
 105         eFormatHexUppercase,
 106         eFormatFloat,
 107         eFormatOctal,
 108         eFormatOSType,          // OS character codes encoded into an integer 'PICT' 'text' etc...
 109         eFormatUnicode16,
 110         eFormatUnicode32,
 111         eFormatUnsigned,
 112         eFormatPointer,
 113         eFormatVectorOfChar,
 114         eFormatVectorOfSInt8,
 115         eFormatVectorOfUInt8,
 116         eFormatVectorOfSInt16,
 117         eFormatVectorOfUInt16,
 118         eFormatVectorOfSInt32,
 119         eFormatVectorOfUInt32,
 120         eFormatVectorOfSInt64,
 121         eFormatVectorOfUInt64,
 122         eFormatVectorOfFloat32,
 123         eFormatVectorOfFloat64,
 124         eFormatVectorOfUInt128,
 125         eFormatComplexInteger,      // Integer complex type
 126         eFormatCharArray,           // Print characters with no single quotes, used for character arrays that can contain non printable characters
 127         eFormatAddressInfo,         // Describe what an address points to (func + offset with file/line, symbol + offset, data, etc)
 128         eFormatHexFloat,            // ISO C99 hex float string
 129         eFormatInstruction,         // Disassemble an opcode
 130         eFormatVoid,                // Do not print this
 131         kNumFormats
 132     } Format;
 133
 134     //----------------------------------------------------------------------
 135     // Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls
 136     //----------------------------------------------------------------------
 137     typedef enum DescriptionLevel
 138     {
 139         eDescriptionLevelBrief = 0,
 140         eDescriptionLevelFull,
 141         eDescriptionLevelVerbose,
 142         eDescriptionLevelInitial,
 143         kNumDescriptionLevels
 144     } DescriptionLevel;
 145
 146     //----------------------------------------------------------------------
 147     // Script interpreter types
 148     //----------------------------------------------------------------------
 149     typedef enum ScriptLanguage
 150     {
 151         eScriptLanguageNone,
 152         eScriptLanguagePython,
 153         eScriptLanguageDefault = eScriptLanguagePython
 154     } ScriptLanguage;
 155
 156     //----------------------------------------------------------------------
 157     // Register numbering types
 158     //----------------------------------------------------------------------
 159     typedef enum RegisterKind
 160     {
 161         eRegisterKindGCC = 0,    // the register numbers seen in eh_frame
 162         eRegisterKindDWARF,      // the register numbers seen DWARF
 163         eRegisterKindGeneric,    // insn ptr reg, stack ptr reg, etc not specific to any particular target
 164         eRegisterKindGDB,        // the register numbers gdb uses (matches stabs numbers?)
 165         eRegisterKindLLDB,       // lldb's internal register numbers
 166         kNumRegisterKinds
 167     } RegisterKind;
 168
 169     //----------------------------------------------------------------------
 170     // Thread stop reasons
 171     //----------------------------------------------------------------------
 172     typedef enum StopReason
 173     {
 174         eStopReasonInvalid = 0,
 175         eStopReasonNone,
 176         eStopReasonTrace,
 177         eStopReasonBreakpoint,
 178         eStopReasonWatchpoint,
 179         eStopReasonSignal,
 180         eStopReasonException,
 181         eStopReasonExec,        // Program was re-exec'ed
 182         eStopReasonPlanComplete,
 183         eStopReasonThreadExiting
 184     } StopReason;
 185
 186     //----------------------------------------------------------------------
 187     // Command Return Status Types
 188     //----------------------------------------------------------------------
 189     typedef enum ReturnStatus
 190     {
 191         eReturnStatusInvalid,
 192         eReturnStatusSuccessFinishNoResult,
 193         eReturnStatusSuccessFinishResult,
 194         eReturnStatusSuccessContinuingNoResult,
 195         eReturnStatusSuccessContinuingResult,
 196         eReturnStatusStarted,
 197         eReturnStatusFailed,
 198         eReturnStatusQuit
 199     } ReturnStatus;
 200
 201
 202     //----------------------------------------------------------------------
 203     // Connection Status Types
 204     //----------------------------------------------------------------------
 205     typedef enum ConnectionStatus
 206     {
 207         eConnectionStatusSuccess,         // Success
 208         eConnectionStatusEndOfFile,       // End-of-file encountered
 209         eConnectionStatusError,           // Check GetError() for details
 210         eConnectionStatusTimedOut,        // Request timed out
 211         eConnectionStatusNoConnection,    // No connection
 212         eConnectionStatusLostConnection   // Lost connection while connected to a valid connection
 213     } ConnectionStatus;
 214
 215     typedef enum ErrorType
 216     {
 217         eErrorTypeInvalid,
 218         eErrorTypeGeneric,      ///< Generic errors that can be any value.
 219         eErrorTypeMachKernel,   ///< Mach kernel error codes.
 220         eErrorTypePOSIX         ///< POSIX error codes.
 221     } ErrorType;
 222
 223
 224     typedef enum ValueType
 225     {
 226         eValueTypeInvalid           = 0,
 227         eValueTypeVariableGlobal    = 1,    // globals variable
 228         eValueTypeVariableStatic    = 2,    // static variable
 229         eValueTypeVariableArgument  = 3,    // function argument variables
 230         eValueTypeVariableLocal     = 4,    // function local variables
 231         eValueTypeRegister          = 5,    // stack frame register value
 232         eValueTypeRegisterSet       = 6,    // A collection of stack frame register values
 233         eValueTypeConstResult       = 7     // constant result variables
 234     } ValueType;
 235
 236     //----------------------------------------------------------------------
 237     // Token size/granularities for Input Readers
 238     //----------------------------------------------------------------------
 239
 240     typedef enum InputReaderGranularity
 241     {
 242         eInputReaderGranularityInvalid = 0,
 243         eInputReaderGranularityByte,
 244         eInputReaderGranularityWord,
 245         eInputReaderGranularityLine,
 246         eInputReaderGranularityAll
 247     } InputReaderGranularity;
 248
 249     //------------------------------------------------------------------
 250     /// These mask bits allow a common interface for queries that can
 251     /// limit the amount of information that gets parsed to only the
 252     /// information that is requested. These bits also can indicate what
 253     /// actually did get resolved during query function calls.
 254     ///
 255     /// Each definition corresponds to a one of the member variables
 256     /// in this class, and requests that that item be resolved, or
 257     /// indicates that the member did get resolved.
 258     //------------------------------------------------------------------
 259     typedef enum SymbolContextItem
 260     {
 261         eSymbolContextTarget     = (1u << 0), ///< Set when \a target is requested from a query, or was located in query results
 262         eSymbolContextModule     = (1u << 1), ///< Set when \a module is requested from a query, or was located in query results
 263         eSymbolContextCompUnit   = (1u << 2), ///< Set when \a comp_unit is requested from a query, or was located in query results
 264         eSymbolContextFunction   = (1u << 3), ///< Set when \a function is requested from a query, or was located in query results
 265         eSymbolContextBlock      = (1u << 4), ///< Set when the deepest \a block is requested from a query, or was located in query results
 266         eSymbolContextLineEntry  = (1u << 5), ///< Set when \a line_entry is requested from a query, or was located in query results
 267         eSymbolContextSymbol     = (1u << 6), ///< Set when \a symbol is requested from a query, or was located in query results
 268         eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1u)  ///< Indicates to try and lookup everything up during a query.
 269     } SymbolContextItem;
 270
 271     typedef enum Permissions
 272     {
 273         ePermissionsWritable    = (1u << 0),
 274         ePermissionsReadable    = (1u << 1),
 275         ePermissionsExecutable  = (1u << 2)
 276     } Permissions;
 277
 278     typedef enum InputReaderAction
 279     {
 280         eInputReaderActivate,   // reader is newly pushed onto the reader stack
 281         eInputReaderAsynchronousOutputWritten, // an async output event occurred; the reader may want to do something
 282         eInputReaderReactivate, // reader is on top of the stack again after another reader was popped off
 283         eInputReaderDeactivate, // another reader was pushed on the stack
 284         eInputReaderGotToken,   // reader got one of its tokens (granularity)
 285         eInputReaderInterrupt,  // reader received an interrupt signal (probably from a control-c)
 286         eInputReaderEndOfFile,  // reader received an EOF char (probably from a control-d)
 287         eInputReaderDone        // reader was just popped off the stack and is done
 288     } InputReaderAction;
 289
 290     typedef enum BreakpointEventType
 291     {
 292         eBreakpointEventTypeInvalidType         = (1u << 0),
 293         eBreakpointEventTypeAdded               = (1u << 1),
 294         eBreakpointEventTypeRemoved             = (1u << 2),
 295         eBreakpointEventTypeLocationsAdded      = (1u << 3),  // Locations added doesn't get sent when the breakpoint is created
 296         eBreakpointEventTypeLocationsRemoved    = (1u << 4),
 297         eBreakpointEventTypeLocationsResolved   = (1u << 5),
 298         eBreakpointEventTypeEnabled             = (1u << 6),
 299         eBreakpointEventTypeDisabled            = (1u << 7),
 300         eBreakpointEventTypeCommandChanged      = (1u << 8),
 301         eBreakpointEventTypeConditionChanged    = (1u << 9),
 302         eBreakpointEventTypeIgnoreChanged       = (1u << 10),
 303         eBreakpointEventTypeThreadChanged       = (1u << 11)
 304     } BreakpointEventType;
 305
 306     typedef enum WatchpointEventType
 307     {
 308         eWatchpointEventTypeInvalidType         = (1u << 0),
 309         eWatchpointEventTypeAdded               = (1u << 1),
 310         eWatchpointEventTypeRemoved             = (1u << 2),
 311         eWatchpointEventTypeEnabled             = (1u << 6),
 312         eWatchpointEventTypeDisabled            = (1u << 7),
 313         eWatchpointEventTypeCommandChanged      = (1u << 8),
 314         eWatchpointEventTypeConditionChanged    = (1u << 9),
 315         eWatchpointEventTypeIgnoreChanged       = (1u << 10),
 316         eWatchpointEventTypeThreadChanged       = (1u << 11),
 317         eWatchpointEventTypeTypeChanged         = (1u << 12)
 318     } WatchpointEventType;
 319
 320
 321     //----------------------------------------------------------------------
 322     /// Programming language type.
 323     ///
 324     /// These enumerations use the same language enumerations as the DWARF
 325     /// specification for ease of use and consistency.
 326     /// The enum -> string code is in LanguageRuntime.cpp, don't change this
 327     /// table without updating that code as well.
 328     //----------------------------------------------------------------------
 329     typedef enum LanguageType
 330     {
 331         eLanguageTypeUnknown         = 0x0000,   ///< Unknown or invalid language value.
 332         eLanguageTypeC89             = 0x0001,   ///< ISO C:1989.
 333         eLanguageTypeC               = 0x0002,   ///< Non-standardized C, such as K&R.
 334         eLanguageTypeAda83           = 0x0003,   ///< ISO Ada:1983.
 335         eLanguageTypeC_plus_plus     = 0x0004,   ///< ISO C++:1998.
 336         eLanguageTypeCobol74         = 0x0005,   ///< ISO Cobol:1974.
 337         eLanguageTypeCobol85         = 0x0006,   ///< ISO Cobol:1985.
 338         eLanguageTypeFortran77       = 0x0007,   ///< ISO Fortran 77.
 339         eLanguageTypeFortran90       = 0x0008,   ///< ISO Fortran 90.
 340         eLanguageTypePascal83        = 0x0009,   ///< ISO Pascal:1983.
 341         eLanguageTypeModula2         = 0x000a,   ///< ISO Modula-2:1996.
 342         eLanguageTypeJava            = 0x000b,   ///< Java.
 343         eLanguageTypeC99             = 0x000c,   ///< ISO C:1999.
 344         eLanguageTypeAda95           = 0x000d,   ///< ISO Ada:1995.
 345         eLanguageTypeFortran95       = 0x000e,   ///< ISO Fortran 95.
 346         eLanguageTypePLI             = 0x000f,   ///< ANSI PL/I:1976.
 347         eLanguageTypeObjC            = 0x0010,   ///< Objective-C.
 348         eLanguageTypeObjC_plus_plus  = 0x0011,   ///< Objective-C++.
 349         eLanguageTypeUPC             = 0x0012,   ///< Unified Parallel C.
 350         eLanguageTypeD               = 0x0013,   ///< D.
 351         eLanguageTypePython          = 0x0014,   ///< Python.
 352         eNumLanguageTypes
 353     } LanguageType;
 354
 355     typedef enum DynamicValueType
 356     {
 357         eNoDynamicValues = 0,
 358         eDynamicCanRunTarget    = 1,
 359         eDynamicDontRunTarget   = 2
 360     } DynamicValueType;
 361
 362     typedef enum AccessType
 363     {
 364         eAccessNone,
 365         eAccessPublic,
 366         eAccessPrivate,
 367         eAccessProtected,
 368         eAccessPackage
 369     } AccessType;
 370
 371     typedef enum CommandArgumentType
 372     {
 373         eArgTypeAddress = 0,
 374         eArgTypeAddressOrExpression,
 375         eArgTypeAliasName,
 376         eArgTypeAliasOptions,
 377         eArgTypeArchitecture,
 378         eArgTypeBoolean,
 379         eArgTypeBreakpointID,
 380         eArgTypeBreakpointIDRange,
 381         eArgTypeByteSize,
 382         eArgTypeClassName,
 383         eArgTypeCommandName,
 384         eArgTypeCount,
 385         eArgTypeDescriptionVerbosity,
 386         eArgTypeDirectoryName,
 387         eArgTypeDisassemblyFlavor,
 388         eArgTypeEndAddress,
 389         eArgTypeExpression,
 390         eArgTypeExpressionPath,
 391         eArgTypeExprFormat,
 392         eArgTypeFilename,
 393         eArgTypeFormat,
 394         eArgTypeFrameIndex,
 395         eArgTypeFullName,
 396         eArgTypeFunctionName,
 397         eArgTypeFunctionOrSymbol,
 398         eArgTypeGDBFormat,
 399         eArgTypeIndex,
 400         eArgTypeLanguage,
 401         eArgTypeLineNum,
 402         eArgTypeLogCategory,
 403         eArgTypeLogChannel,
 404         eArgTypeMethod,
 405         eArgTypeName,
 406         eArgTypeNewPathPrefix,
 407         eArgTypeNumLines,
 408         eArgTypeNumberPerLine,
 409         eArgTypeOffset,
 410         eArgTypeOldPathPrefix,
 411         eArgTypeOneLiner,
 412         eArgTypePath,
 413         eArgTypePermissionsNumber,
 414         eArgTypePermissionsString,
 415         eArgTypePid,
 416         eArgTypePlugin,
 417         eArgTypeProcessName,
 418         eArgTypePythonClass,
 419         eArgTypePythonFunction,
 420         eArgTypePythonScript,
 421         eArgTypeQueueName,
 422         eArgTypeRegisterName,
 423         eArgTypeRegularExpression,
 424         eArgTypeRunArgs,
 425         eArgTypeRunMode,
 426         eArgTypeScriptedCommandSynchronicity,
 427         eArgTypeScriptLang,
 428         eArgTypeSearchWord,
 429         eArgTypeSelector,
 430         eArgTypeSettingIndex,
 431         eArgTypeSettingKey,
 432         eArgTypeSettingPrefix,
 433         eArgTypeSettingVariableName,
 434         eArgTypeShlibName,
 435         eArgTypeSourceFile,
 436         eArgTypeSortOrder,
 437         eArgTypeStartAddress,
 438         eArgTypeSummaryString,
 439         eArgTypeSymbol,
 440         eArgTypeThreadID,
 441         eArgTypeThreadIndex,
 442         eArgTypeThreadName,
 443         eArgTypeUnsignedInteger,
 444         eArgTypeUnixSignal,
 445         eArgTypeVarName,
 446         eArgTypeValue,
 447         eArgTypeWidth,
 448         eArgTypeNone,
 449         eArgTypePlatform,
 450         eArgTypeWatchpointID,
 451         eArgTypeWatchpointIDRange,
 452         eArgTypeWatchType,
 453         eArgTypeLastArg  // Always keep this entry as the last entry in this enumeration!!
 454     } CommandArgumentType;
 455
 456     //----------------------------------------------------------------------
 457     // Symbol types
 458     //----------------------------------------------------------------------
 459     typedef enum SymbolType
 460     {
 461         eSymbolTypeAny = 0,
 462         eSymbolTypeInvalid = 0,
 463         eSymbolTypeAbsolute,
 464         eSymbolTypeCode,
 465         eSymbolTypeResolver,
 466         eSymbolTypeData,
 467         eSymbolTypeTrampoline,
 468         eSymbolTypeRuntime,
 469         eSymbolTypeException,
 470         eSymbolTypeSourceFile,
 471         eSymbolTypeHeaderFile,
 472         eSymbolTypeObjectFile,
 473         eSymbolTypeCommonBlock,
 474         eSymbolTypeBlock,
 475         eSymbolTypeLocal,
 476         eSymbolTypeParam,
 477         eSymbolTypeVariable,
 478         eSymbolTypeVariableType,
 479         eSymbolTypeLineEntry,
 480         eSymbolTypeLineHeader,
 481         eSymbolTypeScopeBegin,
 482         eSymbolTypeScopeEnd,
 483         eSymbolTypeAdditional, // When symbols take more than one entry, the extra entries get this type
 484         eSymbolTypeCompiler,
 485         eSymbolTypeInstrumentation,
 486         eSymbolTypeUndefined,
 487         eSymbolTypeObjCClass,
 488         eSymbolTypeObjCMetaClass,
 489         eSymbolTypeObjCIVar,
 490         eSymbolTypeReExported
 491     } SymbolType;
 492
 493     typedef enum SectionType
 494     {
 495         eSectionTypeInvalid,
 496         eSectionTypeCode,
 497         eSectionTypeContainer,              // The section contains child sections
 498         eSectionTypeData,
 499         eSectionTypeDataCString,            // Inlined C string data
 500         eSectionTypeDataCStringPointers,    // Pointers to C string data
 501         eSectionTypeDataSymbolAddress,      // Address of a symbol in the symbol table
 502         eSectionTypeData4,
 503         eSectionTypeData8,
 504         eSectionTypeData16,
 505         eSectionTypeDataPointers,
 506         eSectionTypeDebug,
 507         eSectionTypeZeroFill,
 508         eSectionTypeDataObjCMessageRefs,    // Pointer to function pointer + selector
 509         eSectionTypeDataObjCCFStrings,      // Objective C const CFString/NSString objects
 510         eSectionTypeDWARFDebugAbbrev,
 511         eSectionTypeDWARFDebugAranges,
 512         eSectionTypeDWARFDebugFrame,
 513         eSectionTypeDWARFDebugInfo,
 514         eSectionTypeDWARFDebugLine,
 515         eSectionTypeDWARFDebugLoc,
 516         eSectionTypeDWARFDebugMacInfo,
 517         eSectionTypeDWARFDebugPubNames,
 518         eSectionTypeDWARFDebugPubTypes,
 519         eSectionTypeDWARFDebugRanges,
 520         eSectionTypeDWARFDebugStr,
 521         eSectionTypeDWARFAppleNames,
 522         eSectionTypeDWARFAppleTypes,
 523         eSectionTypeDWARFAppleNamespaces,
 524         eSectionTypeDWARFAppleObjC,
 525         eSectionTypeELFSymbolTable,       // Elf SHT_SYMTAB section
 526         eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
 527         eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
 528         eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
 529         eSectionTypeEHFrame,
 530         eSectionTypeOther
 531
 532     } SectionType;
 533
 534     typedef enum EmulateInstructionOptions
 535     {
 536         eEmulateInstructionOptionNone               = (0u),
 537         eEmulateInstructionOptionAutoAdvancePC      = (1u << 0),
 538         eEmulateInstructionOptionIgnoreConditions   = (1u << 1)
 539     } EmulateInstructionOptions;
 540
 541     typedef enum FunctionNameType
 542     {
 543         eFunctionNameTypeNone       = 0u,
 544         eFunctionNameTypeAuto       = (1u << 1),    // Automatically figure out which FunctionNameType
 545                                                     // bits to set based on the function name.
 546         eFunctionNameTypeFull       = (1u << 2),    // The function name.
 547                                                     // For C this is the same as just the name of the function
 548                                                     // For C++ this is the mangled or demangled version of the mangled name.
 549                                                     // For ObjC this is the full function signature with the + or
 550                                                     // - and the square brackets and the class and selector
 551         eFunctionNameTypeBase       = (1u << 3),    // The function name only, no namespaces or arguments and no class
 552                                                     // methods or selectors will be searched.
 553         eFunctionNameTypeMethod     = (1u << 4),    // Find function by method name (C++) with no namespace or arguments
 554         eFunctionNameTypeSelector   = (1u << 5),    // Find function by selector name (ObjC) names
 555         eFunctionNameTypeAny        = eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
 556     } FunctionNameType;
 557
 558
 559     //----------------------------------------------------------------------
 560     // Basic types enumeration for the public API SBType::GetBasicType()
 561     //----------------------------------------------------------------------
 562     typedef enum BasicType
 563     {
 564                 eBasicTypeInvalid = 0,
 565         eBasicTypeVoid = 1,
 566         eBasicTypeChar,
 567         eBasicTypeSignedChar,
 568         eBasicTypeUnsignedChar,
 569         eBasicTypeWChar,
 570         eBasicTypeSignedWChar,
 571         eBasicTypeUnsignedWChar,
 572         eBasicTypeChar16,
 573         eBasicTypeChar32,
 574         eBasicTypeShort,
 575         eBasicTypeUnsignedShort,
 576         eBasicTypeInt,
 577         eBasicTypeUnsignedInt,
 578         eBasicTypeLong,
 579         eBasicTypeUnsignedLong,
 580         eBasicTypeLongLong,
 581         eBasicTypeUnsignedLongLong,
 582         eBasicTypeInt128,
 583         eBasicTypeUnsignedInt128,
 584         eBasicTypeBool,
 585         eBasicTypeHalf,
 586         eBasicTypeFloat,
 587         eBasicTypeDouble,
 588         eBasicTypeLongDouble,
 589         eBasicTypeFloatComplex,
 590         eBasicTypeDoubleComplex,
 591         eBasicTypeLongDoubleComplex,
 592         eBasicTypeObjCID,
 593         eBasicTypeObjCClass,
 594         eBasicTypeObjCSel,
 595         eBasicTypeNullPtr,
 596         eBasicTypeOther
 597     } BasicType;
 598
 599     typedef enum TypeClass
 600     {
 601         eTypeClassInvalid           = (0u),
 602         eTypeClassArray             = (1u << 0),
 603         eTypeClassBlockPointer      = (1u << 1),
 604         eTypeClassBuiltin           = (1u << 2),
 605         eTypeClassClass             = (1u << 3),
 606         eTypeClassComplexFloat      = (1u << 4),
 607         eTypeClassComplexInteger    = (1u << 5),
 608         eTypeClassEnumeration       = (1u << 6),
 609         eTypeClassFunction          = (1u << 7),
 610         eTypeClassMemberPointer     = (1u << 8),
 611         eTypeClassObjCObject        = (1u << 9),
 612         eTypeClassObjCInterface     = (1u << 10),
 613         eTypeClassObjCObjectPointer = (1u << 11),
 614         eTypeClassPointer           = (1u << 12),
 615         eTypeClassReference         = (1u << 13),
 616         eTypeClassStruct            = (1u << 14),
 617         eTypeClassTypedef           = (1u << 15),
 618         eTypeClassUnion             = (1u << 16),
 619         eTypeClassVector            = (1u << 17),
 620         // Define the last type class as the MSBit of a 32 bit value
 621         eTypeClassOther             = (1u << 31),
 622         // Define a mask that can be used for any type when finding types
 623         eTypeClassAny               = (0xffffffffu)
 624     } TypeClass;
 625
 626     typedef enum TemplateArgumentKind
 627     {
 628         eTemplateArgumentKindNull = 0,
 629         eTemplateArgumentKindType,
 630         eTemplateArgumentKindDeclaration,
 631         eTemplateArgumentKindIntegral,
 632         eTemplateArgumentKindTemplate,
 633         eTemplateArgumentKindTemplateExpansion,
 634         eTemplateArgumentKindExpression,
 635         eTemplateArgumentKindPack
 636
 637     } TemplateArgumentKind;
 638
 639     //----------------------------------------------------------------------
 640     // Options that can be set for a formatter to alter its behavior
 641     // Not all of these are applicable to all formatter types
 642     //----------------------------------------------------------------------
 643     typedef enum TypeOptions
 644     {
 645         eTypeOptionNone            = (0u),
 646         eTypeOptionCascade         = (1u << 0),
 647         eTypeOptionSkipPointers    = (1u << 1),
 648         eTypeOptionSkipReferences  = (1u << 2),
 649         eTypeOptionHideChildren    = (1u << 3),
 650         eTypeOptionHideValue       = (1u << 4),
 651         eTypeOptionShowOneLiner    = (1u << 5),
 652         eTypeOptionHideNames       = (1u << 6)
 653     } TypeOptions;
 654
 655    //----------------------------------------------------------------------
 656    // This is the return value for frame comparisons.  When frame A pushes
 657    // frame B onto the stack, frame A is OLDER than frame B.
 658    //----------------------------------------------------------------------
 659    typedef enum FrameComparison
 660    {
 661        eFrameCompareInvalid,
 662        eFrameCompareUnknown,
 663        eFrameCompareEqual,
 664        eFrameCompareYounger,
 665        eFrameCompareOlder
 666    } FrameComparison;
 667
 668     //----------------------------------------------------------------------
 669     // Address Class
 670     //
 671     // A way of classifying an address used for disassembling and setting
 672     // breakpoints. Many object files can track exactly what parts of their
 673     // object files are code, data and other information. This is of course
 674     // above and beyond just looking at the section types. For example, code
 675     // might contain PC relative data and the object file might be able to
 676     // tell us that an address in code is data.
 677     //----------------------------------------------------------------------
 678     typedef enum AddressClass
 679     {
 680         eAddressClassInvalid,
 681         eAddressClassUnknown,
 682         eAddressClassCode,
 683         eAddressClassCodeAlternateISA,
 684         eAddressClassData,
 685         eAddressClassDebug,
 686         eAddressClassRuntime
 687     } AddressClass;
 688
 689     //----------------------------------------------------------------------
 690     // File Permissions
 691     //
 692     // Designed to mimic the unix file permission bits so they can be
 693     // used with functions that set 'mode_t' to certain values for
 694     // permissions.
 695     //----------------------------------------------------------------------
 696     typedef enum FilePermissions
 697     {
 698         eFilePermissionsUserRead        = (1u << 8),
 699         eFilePermissionsUserWrite       = (1u << 7),
 700         eFilePermissionsUserExecute     = (1u << 6),
 701         eFilePermissionsGroupRead       = (1u << 5),
 702         eFilePermissionsGroupWrite      = (1u << 4),
 703         eFilePermissionsGroupExecute    = (1u << 3),
 704         eFilePermissionsWorldRead       = (1u << 2),
 705         eFilePermissionsWorldWrite      = (1u << 1),
 706         eFilePermissionsWorldExecute    = (1u << 0),
 707
 708         eFilePermissionsUserRW      = (eFilePermissionsUserRead    | eFilePermissionsUserWrite      | 0                             ),
 709         eFileFilePermissionsUserRX  = (eFilePermissionsUserRead    | 0                              | eFilePermissionsUserExecute   ),
 710         eFilePermissionsUserRWX     = (eFilePermissionsUserRead    | eFilePermissionsUserWrite      | eFilePermissionsUserExecute   ),
 711
 712         eFilePermissionsGroupRW     = (eFilePermissionsGroupRead   | eFilePermissionsGroupWrite     | 0                             ),
 713         eFilePermissionsGroupRX     = (eFilePermissionsGroupRead   | 0                              | eFilePermissionsGroupExecute  ),
 714         eFilePermissionsGroupRWX    = (eFilePermissionsGroupRead   | eFilePermissionsGroupWrite     | eFilePermissionsGroupExecute  ),
 715
 716         eFilePermissionsWorldRW     = (eFilePermissionsWorldRead   | eFilePermissionsWorldWrite     | 0                             ),
 717         eFilePermissionsWorldRX     = (eFilePermissionsWorldRead   | 0                              | eFilePermissionsWorldExecute  ),
 718         eFilePermissionsWorldRWX    = (eFilePermissionsWorldRead   | eFilePermissionsWorldWrite     | eFilePermissionsWorldExecute  ),
 719
 720         eFilePermissionsEveryoneR   = (eFilePermissionsUserRead    | eFilePermissionsGroupRead      | eFilePermissionsWorldRead     ),
 721         eFilePermissionsEveryoneW   = (eFilePermissionsUserWrite   | eFilePermissionsGroupWrite     | eFilePermissionsWorldWrite    ),
 722         eFilePermissionsEveryoneX   = (eFilePermissionsUserExecute | eFilePermissionsGroupExecute   | eFilePermissionsWorldExecute  ),
 723
 724         eFilePermissionsEveryoneRW  = (eFilePermissionsEveryoneR   | eFilePermissionsEveryoneW      | 0                             ),
 725         eFilePermissionsEveryoneRX  = (eFilePermissionsEveryoneR   | 0                              | eFilePermissionsEveryoneX     ),
 726         eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR   | eFilePermissionsEveryoneW      | eFilePermissionsEveryoneX     ),
 727         eFilePermissionsFileDefault = eFilePermissionsUserRW,
 728         eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
 729     } FilePermissions;
 730
 731     //----------------------------------------------------------------------
 732     // Queue work item types
 733     //
 734     // The different types of work that can be enqueued on a libdispatch
 735     // aka Grand Central Dispatch (GCD) queue.
 736     //----------------------------------------------------------------------
 737     typedef enum QueueItemKind
 738     {
 739         eQueueItemKindUnknown = 0,
 740         eQueueItemKindFunction,
 741         eQueueItemKindBlock
 742     } QueueItemKind;
 743
 744 } // namespace lldb
 745
 746
 747 #endif  // LLDB_lldb_enumerations_h_