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         eArgTypeDirectoryName,
 384         eArgTypeDisassemblyFlavor,
 385         eArgTypeEndAddress,
 386         eArgTypeExpression,
 387         eArgTypeExpressionPath,
 388         eArgTypeExprFormat,
 389         eArgTypeFilename,
 390         eArgTypeFormat,
 391         eArgTypeFrameIndex,
 392         eArgTypeFullName,
 393         eArgTypeFunctionName,
 394         eArgTypeFunctionOrSymbol,
 395         eArgTypeGDBFormat,
 396         eArgTypeIndex,
 397         eArgTypeLanguage,
 398         eArgTypeLineNum,
 399         eArgTypeLogCategory,
 400         eArgTypeLogChannel,
 401         eArgTypeMethod,
 402         eArgTypeName,
 403         eArgTypeNewPathPrefix,
 404         eArgTypeNumLines,
 405         eArgTypeNumberPerLine,
 406         eArgTypeOffset,
 407         eArgTypeOldPathPrefix,
 408         eArgTypeOneLiner,
 409         eArgTypePid,
 410         eArgTypePlugin,
 411         eArgTypeProcessName,
 412         eArgTypePythonClass,
 413         eArgTypePythonFunction,
 414         eArgTypePythonScript,
 415         eArgTypeQueueName,
 416         eArgTypeRegisterName,
 417         eArgTypeRegularExpression,
 418         eArgTypeRunArgs,
 419         eArgTypeRunMode,
 420         eArgTypeScriptedCommandSynchronicity,
 421         eArgTypeScriptLang,
 422         eArgTypeSearchWord,
 423         eArgTypeSelector,
 424         eArgTypeSettingIndex,
 425         eArgTypeSettingKey,
 426         eArgTypeSettingPrefix,
 427         eArgTypeSettingVariableName,
 428         eArgTypeShlibName,
 429         eArgTypeSourceFile,
 430         eArgTypeSortOrder,
 431         eArgTypeStartAddress,
 432         eArgTypeSummaryString,
 433         eArgTypeSymbol,
 434         eArgTypeThreadID,
 435         eArgTypeThreadIndex,
 436         eArgTypeThreadName,
 437         eArgTypeUnsignedInteger,
 438         eArgTypeUnixSignal,
 439         eArgTypeVarName,
 440         eArgTypeValue,
 441         eArgTypeWidth,
 442         eArgTypeNone,
 443         eArgTypePlatform,
 444         eArgTypeWatchpointID,
 445         eArgTypeWatchpointIDRange,
 446         eArgTypeWatchType,
 447         eArgTypeLastArg  // Always keep this entry as the last entry in this enumeration!!
 448     } CommandArgumentType;
 449
 450     //----------------------------------------------------------------------
 451     // Symbol types
 452     //----------------------------------------------------------------------
 453     typedef enum SymbolType
 454     {
 455         eSymbolTypeAny = 0,
 456         eSymbolTypeInvalid = 0,
 457         eSymbolTypeAbsolute,
 458         eSymbolTypeCode,
 459         eSymbolTypeResolver,
 460         eSymbolTypeData,
 461         eSymbolTypeTrampoline,
 462         eSymbolTypeRuntime,
 463         eSymbolTypeException,
 464         eSymbolTypeSourceFile,
 465         eSymbolTypeHeaderFile,
 466         eSymbolTypeObjectFile,
 467         eSymbolTypeCommonBlock,
 468         eSymbolTypeBlock,
 469         eSymbolTypeLocal,
 470         eSymbolTypeParam,
 471         eSymbolTypeVariable,
 472         eSymbolTypeVariableType,
 473         eSymbolTypeLineEntry,
 474         eSymbolTypeLineHeader,
 475         eSymbolTypeScopeBegin,
 476         eSymbolTypeScopeEnd,
 477         eSymbolTypeAdditional, // When symbols take more than one entry, the extra entries get this type
 478         eSymbolTypeCompiler,
 479         eSymbolTypeInstrumentation,
 480         eSymbolTypeUndefined,
 481         eSymbolTypeObjCClass,
 482         eSymbolTypeObjCMetaClass,
 483         eSymbolTypeObjCIVar
 484     } SymbolType;
 485
 486     typedef enum SectionType
 487     {
 488         eSectionTypeInvalid,
 489         eSectionTypeCode,
 490         eSectionTypeContainer,              // The section contains child sections
 491         eSectionTypeData,
 492         eSectionTypeDataCString,            // Inlined C string data
 493         eSectionTypeDataCStringPointers,    // Pointers to C string data
 494         eSectionTypeDataSymbolAddress,      // Address of a symbol in the symbol table
 495         eSectionTypeData4,
 496         eSectionTypeData8,
 497         eSectionTypeData16,
 498         eSectionTypeDataPointers,
 499         eSectionTypeDebug,
 500         eSectionTypeZeroFill,
 501         eSectionTypeDataObjCMessageRefs,    // Pointer to function pointer + selector
 502         eSectionTypeDataObjCCFStrings,      // Objective C const CFString/NSString objects
 503         eSectionTypeDWARFDebugAbbrev,
 504         eSectionTypeDWARFDebugAranges,
 505         eSectionTypeDWARFDebugFrame,
 506         eSectionTypeDWARFDebugInfo,
 507         eSectionTypeDWARFDebugLine,
 508         eSectionTypeDWARFDebugLoc,
 509         eSectionTypeDWARFDebugMacInfo,
 510         eSectionTypeDWARFDebugPubNames,
 511         eSectionTypeDWARFDebugPubTypes,
 512         eSectionTypeDWARFDebugRanges,
 513         eSectionTypeDWARFDebugStr,
 514         eSectionTypeDWARFAppleNames,
 515         eSectionTypeDWARFAppleTypes,
 516         eSectionTypeDWARFAppleNamespaces,
 517         eSectionTypeDWARFAppleObjC,
 518         eSectionTypeELFSymbolTable,       // Elf SHT_SYMTAB section
 519         eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
 520         eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
 521         eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
 522         eSectionTypeEHFrame,
 523         eSectionTypeOther
 524
 525     } SectionType;
 526
 527     typedef enum EmulateInstructionOptions
 528     {
 529         eEmulateInstructionOptionNone               = (0u),
 530         eEmulateInstructionOptionAutoAdvancePC      = (1u << 0),
 531         eEmulateInstructionOptionIgnoreConditions   = (1u << 1)
 532     } EmulateInstructionOptions;
 533
 534     typedef enum FunctionNameType
 535     {
 536         eFunctionNameTypeNone       = 0u,
 537         eFunctionNameTypeAuto       = (1u << 1),    // Automatically figure out which FunctionNameType
 538                                                     // bits to set based on the function name.
 539         eFunctionNameTypeFull       = (1u << 2),    // The function name.
 540                                                     // For C this is the same as just the name of the function
 541                                                     // For C++ this is the mangled or demangled version of the mangled name.
 542                                                     // For ObjC this is the full function signature with the + or
 543                                                     // - and the square brackets and the class and selector
 544         eFunctionNameTypeBase       = (1u << 3),    // The function name only, no namespaces or arguments and no class
 545                                                     // methods or selectors will be searched.
 546         eFunctionNameTypeMethod     = (1u << 4),    // Find function by method name (C++) with no namespace or arguments
 547         eFunctionNameTypeSelector   = (1u << 5),    // Find function by selector name (ObjC) names
 548         eFunctionNameTypeAny        = eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
 549     } FunctionNameType;
 550
 551
 552     //----------------------------------------------------------------------
 553     // Basic types enumeration for the public API SBType::GetBasicType()
 554     //----------------------------------------------------------------------
 555     typedef enum BasicType
 556     {
 557                 eBasicTypeInvalid = 0,
 558         eBasicTypeVoid = 1,
 559         eBasicTypeChar,
 560         eBasicTypeSignedChar,
 561         eBasicTypeUnsignedChar,
 562         eBasicTypeWChar,
 563         eBasicTypeSignedWChar,
 564         eBasicTypeUnsignedWChar,
 565         eBasicTypeChar16,
 566         eBasicTypeChar32,
 567         eBasicTypeShort,
 568         eBasicTypeUnsignedShort,
 569         eBasicTypeInt,
 570         eBasicTypeUnsignedInt,
 571         eBasicTypeLong,
 572         eBasicTypeUnsignedLong,
 573         eBasicTypeLongLong,
 574         eBasicTypeUnsignedLongLong,
 575         eBasicTypeInt128,
 576         eBasicTypeUnsignedInt128,
 577         eBasicTypeBool,
 578         eBasicTypeHalf,
 579         eBasicTypeFloat,
 580         eBasicTypeDouble,
 581         eBasicTypeLongDouble,
 582         eBasicTypeFloatComplex,
 583         eBasicTypeDoubleComplex,
 584         eBasicTypeLongDoubleComplex,
 585         eBasicTypeObjCID,
 586         eBasicTypeObjCClass,
 587         eBasicTypeObjCSel,
 588         eBasicTypeNullPtr,
 589         eBasicTypeOther
 590     } BasicType;
 591
 592     typedef enum TypeClass
 593     {
 594         eTypeClassInvalid           = (0u),
 595         eTypeClassArray             = (1u << 0),
 596         eTypeClassBlockPointer      = (1u << 1),
 597         eTypeClassBuiltin           = (1u << 2),
 598         eTypeClassClass             = (1u << 3),
 599         eTypeClassComplexFloat      = (1u << 4),
 600         eTypeClassComplexInteger    = (1u << 5),
 601         eTypeClassEnumeration       = (1u << 6),
 602         eTypeClassFunction          = (1u << 7),
 603         eTypeClassMemberPointer     = (1u << 8),
 604         eTypeClassObjCObject        = (1u << 9),
 605         eTypeClassObjCInterface     = (1u << 10),
 606         eTypeClassObjCObjectPointer = (1u << 11),
 607         eTypeClassPointer           = (1u << 12),
 608         eTypeClassReference         = (1u << 13),
 609         eTypeClassStruct            = (1u << 14),
 610         eTypeClassTypedef           = (1u << 15),
 611         eTypeClassUnion             = (1u << 16),
 612         eTypeClassVector            = (1u << 17),
 613         // Define the last type class as the MSBit of a 32 bit value
 614         eTypeClassOther             = (1u << 31),
 615         // Define a mask that can be used for any type when finding types
 616         eTypeClassAny               = (0xffffffffu)
 617     } TypeClass;
 618
 619     typedef enum TemplateArgumentKind
 620     {
 621         eTemplateArgumentKindNull = 0,
 622         eTemplateArgumentKindType,
 623         eTemplateArgumentKindDeclaration,
 624         eTemplateArgumentKindIntegral,
 625         eTemplateArgumentKindTemplate,
 626         eTemplateArgumentKindTemplateExpansion,
 627         eTemplateArgumentKindExpression,
 628         eTemplateArgumentKindPack
 629
 630     } TemplateArgumentKind;
 631
 632     //----------------------------------------------------------------------
 633     // Options that can be set for a formatter to alter its behavior
 634     // Not all of these are applicable to all formatter types
 635     //----------------------------------------------------------------------
 636     typedef enum TypeOptions
 637     {
 638         eTypeOptionNone            = (0u),
 639         eTypeOptionCascade         = (1u << 0),
 640         eTypeOptionSkipPointers    = (1u << 1),
 641         eTypeOptionSkipReferences  = (1u << 2),
 642         eTypeOptionHideChildren    = (1u << 3),
 643         eTypeOptionHideValue       = (1u << 4),
 644         eTypeOptionShowOneLiner    = (1u << 5),
 645         eTypeOptionHideNames       = (1u << 6)
 646     } TypeOptions;
 647
 648    //----------------------------------------------------------------------
 649    // This is the return value for frame comparisons.  When frame A pushes
 650    // frame B onto the stack, frame A is OLDER than frame B.
 651    //----------------------------------------------------------------------
 652    typedef enum FrameComparison
 653    {
 654        eFrameCompareInvalid,
 655        eFrameCompareUnknown,
 656        eFrameCompareEqual,
 657        eFrameCompareYounger,
 658        eFrameCompareOlder
 659    } FrameComparison;
 660
 661     //----------------------------------------------------------------------
 662     // Address Class
 663     //
 664     // A way of classifying an address used for disassembling and setting
 665     // breakpoints. Many object files can track exactly what parts of their
 666     // object files are code, data and other information. This is of course
 667     // above and beyond just looking at the section types. For example, code
 668     // might contain PC relative data and the object file might be able to
 669     // tell us that an address in code is data.
 670     //----------------------------------------------------------------------
 671     typedef enum AddressClass
 672     {
 673         eAddressClassInvalid,
 674         eAddressClassUnknown,
 675         eAddressClassCode,
 676         eAddressClassCodeAlternateISA,
 677         eAddressClassData,
 678         eAddressClassDebug,
 679         eAddressClassRuntime
 680     } AddressClass;
 681
 682 } // namespace lldb
 683
 684
 685 #endif  // LLDB_lldb_enumerations_h_