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