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 #ifndef SWIG
  14 // With MSVC, the default type of an enum is always signed, even if one of the
  15 // enumerator values is too large to fit into a signed integer but would
  16 // otherwise fit into an unsigned integer.  As a result of this, all of LLDB's
  17 // flag-style enumerations that specify something like eValueFoo = 1u << 31
  18 // result in negative values.  This usually just results in a benign warning,
  19 // but in a few places we actually do comparisons on the enum values, which
  20 // would cause a real bug.  Furthermore, there's no way to silence only this
  21 // warning, as it's part of -Wmicrosoft which also catches a whole slew of
  22 // other useful issues.
  23 //
  24 // To make matters worse, early versions of SWIG don't recognize the syntax of
  25 // specifying the underlying type of an enum (and Python doesn't care anyway)
  26 // so we need a way to specify the underlying type when the enum is being used
  27 // from C++ code, but just use a regular enum when swig is pre-processing.
  28 #define FLAGS_ENUM(Name) enum Name : unsigned
  29 #define FLAGS_ANONYMOUS_ENUM() enum : unsigned
  30 #else
  31 #define FLAGS_ENUM(Name) enum Name
  32 #define FLAGS_ANONYMOUS_ENUM() enum
  33 #endif
  34
  35 namespace lldb {
  36
  37 //----------------------------------------------------------------------
  38 // Process and Thread States
  39 //----------------------------------------------------------------------
  40 enum StateType {
  41   eStateInvalid = 0,
  42   eStateUnloaded,  ///< Process is object is valid, but not currently loaded
  43   eStateConnected, ///< Process is connected to remote debug services, but not
  44                    ///launched or attached to anything yet
  45   eStateAttaching, ///< Process is currently trying to attach
  46   eStateLaunching, ///< Process is in the process of launching
  47   // The state changes eStateAttaching and eStateLaunching are both sent while the
  48   // private state thread is either not yet started or paused. For that reason, they
  49   // should only be signaled as public state changes, and not private state changes.
  50   eStateStopped,   ///< Process or thread is stopped and can be examined.
  51   eStateRunning,   ///< Process or thread is running and can't be examined.
  52   eStateStepping,  ///< Process or thread is in the process of stepping and can
  53                    ///not be examined.
  54   eStateCrashed,   ///< Process or thread has crashed and can be examined.
  55   eStateDetached,  ///< Process has been detached and can't be examined.
  56   eStateExited,    ///< Process has exited and can't be examined.
  57   eStateSuspended  ///< Process or thread is in a suspended state as far
  58                    ///< as the debugger is concerned while other processes
  59                    ///< or threads get the chance to run.
  60 };
  61
  62 //----------------------------------------------------------------------
  63 // Launch Flags
  64 //----------------------------------------------------------------------
  65 FLAGS_ENUM(LaunchFlags){
  66     eLaunchFlagNone = 0u,
  67     eLaunchFlagExec = (1u << 0),  ///< Exec when launching and turn the calling
  68                                   ///process into a new process
  69     eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to
  70                                   ///allow the process to be debugged
  71     eLaunchFlagStopAtEntry = (1u << 2), ///< Stop at the program entry point
  72                                         ///instead of auto-continuing when
  73                                         ///launching or attaching at entry point
  74     eLaunchFlagDisableASLR =
  75         (1u << 3), ///< Disable Address Space Layout Randomization
  76     eLaunchFlagDisableSTDIO =
  77         (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app)
  78     eLaunchFlagLaunchInTTY =
  79         (1u << 5), ///< Launch the process in a new TTY if supported by the host
  80     eLaunchFlagLaunchInShell =
  81         (1u << 6), ///< Launch the process inside a shell to get shell expansion
  82     eLaunchFlagLaunchInSeparateProcessGroup =
  83         (1u << 7), ///< Launch the process in a separate process group
  84     eLaunchFlagDontSetExitStatus = (1u << 8), ///< If you are going to hand the
  85                                               ///process off (e.g. to
  86                                               ///debugserver)
  87     ///< set this flag so lldb & the handee don't race to set its exit status.
  88     eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub
  89                                           ///should detach rather than killing
  90                                           ///the debugee
  91                                           ///< if it loses connection with lldb.
  92     eLaunchFlagShellExpandArguments =
  93         (1u << 10), ///< Perform shell-style argument expansion
  94     eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit
  95 };
  96
  97 //----------------------------------------------------------------------
  98 // Thread Run Modes
  99 //----------------------------------------------------------------------
 100 enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
 101
 102 //----------------------------------------------------------------------
 103 // Byte ordering definitions
 104 //----------------------------------------------------------------------
 105 enum ByteOrder {
 106   eByteOrderInvalid = 0,
 107   eByteOrderBig = 1,
 108   eByteOrderPDP = 2,
 109   eByteOrderLittle = 4
 110 };
 111
 112 //----------------------------------------------------------------------
 113 // Register encoding definitions
 114 //----------------------------------------------------------------------
 115 enum Encoding {
 116   eEncodingInvalid = 0,
 117   eEncodingUint,    // unsigned integer
 118   eEncodingSint,    // signed integer
 119   eEncodingIEEE754, // float
 120   eEncodingVector   // vector registers
 121 };
 122
 123 //----------------------------------------------------------------------
 124 // Display format definitions
 125 //----------------------------------------------------------------------
 126 enum Format {
 127   eFormatDefault = 0,
 128   eFormatInvalid = 0,
 129   eFormatBoolean,
 130   eFormatBinary,
 131   eFormatBytes,
 132   eFormatBytesWithASCII,
 133   eFormatChar,
 134   eFormatCharPrintable, // Only printable characters, space if not printable
 135   eFormatComplex,       // Floating point complex type
 136   eFormatComplexFloat = eFormatComplex,
 137   eFormatCString, // NULL terminated C strings
 138   eFormatDecimal,
 139   eFormatEnum,
 140   eFormatHex,
 141   eFormatHexUppercase,
 142   eFormatFloat,
 143   eFormatOctal,
 144   eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text'
 145                  // etc...
 146   eFormatUnicode16,
 147   eFormatUnicode32,
 148   eFormatUnsigned,
 149   eFormatPointer,
 150   eFormatVectorOfChar,
 151   eFormatVectorOfSInt8,
 152   eFormatVectorOfUInt8,
 153   eFormatVectorOfSInt16,
 154   eFormatVectorOfUInt16,
 155   eFormatVectorOfSInt32,
 156   eFormatVectorOfUInt32,
 157   eFormatVectorOfSInt64,
 158   eFormatVectorOfUInt64,
 159   eFormatVectorOfFloat16,
 160   eFormatVectorOfFloat32,
 161   eFormatVectorOfFloat64,
 162   eFormatVectorOfUInt128,
 163   eFormatComplexInteger, // Integer complex type
 164   eFormatCharArray,      // Print characters with no single quotes, used for
 165                          // character arrays that can contain non printable
 166                          // characters
 167   eFormatAddressInfo, // Describe what an address points to (func + offset with
 168                       // file/line, symbol + offset, data, etc)
 169   eFormatHexFloat,    // ISO C99 hex float string
 170   eFormatInstruction, // Disassemble an opcode
 171   eFormatVoid,        // Do not print this
 172   kNumFormats
 173 };
 174
 175 //----------------------------------------------------------------------
 176 // Description levels for "void GetDescription(Stream *, DescriptionLevel)"
 177 // calls
 178 //----------------------------------------------------------------------
 179 enum DescriptionLevel {
 180   eDescriptionLevelBrief = 0,
 181   eDescriptionLevelFull,
 182   eDescriptionLevelVerbose,
 183   eDescriptionLevelInitial,
 184   kNumDescriptionLevels
 185 };
 186
 187 //----------------------------------------------------------------------
 188 // Script interpreter types
 189 //----------------------------------------------------------------------
 190 enum ScriptLanguage {
 191   eScriptLanguageNone,
 192   eScriptLanguagePython,
 193   eScriptLanguageDefault = eScriptLanguagePython,
 194   eScriptLanguageUnknown
 195 };
 196
 197 //----------------------------------------------------------------------
 198 // Register numbering types
 199 // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
 200 // these to the lldb internal register numbering scheme (eRegisterKindLLDB).
 201 //----------------------------------------------------------------------
 202 enum RegisterKind {
 203   eRegisterKindEHFrame = 0, // the register numbers seen in eh_frame
 204   eRegisterKindDWARF,       // the register numbers seen DWARF
 205   eRegisterKindGeneric, // insn ptr reg, stack ptr reg, etc not specific to any
 206                         // particular target
 207   eRegisterKindProcessPlugin, // num used by the process plugin - e.g. by the
 208                               // remote gdb-protocol stub program
 209   eRegisterKindLLDB,          // lldb's internal register numbers
 210   kNumRegisterKinds
 211 };
 212
 213 //----------------------------------------------------------------------
 214 // Thread stop reasons
 215 //----------------------------------------------------------------------
 216 enum StopReason {
 217   eStopReasonInvalid = 0,
 218   eStopReasonNone,
 219   eStopReasonTrace,
 220   eStopReasonBreakpoint,
 221   eStopReasonWatchpoint,
 222   eStopReasonSignal,
 223   eStopReasonException,
 224   eStopReasonExec, // Program was re-exec'ed
 225   eStopReasonPlanComplete,
 226   eStopReasonThreadExiting,
 227   eStopReasonInstrumentation
 228 };
 229
 230 //----------------------------------------------------------------------
 231 // Command Return Status Types
 232 //----------------------------------------------------------------------
 233 enum ReturnStatus {
 234   eReturnStatusInvalid,
 235   eReturnStatusSuccessFinishNoResult,
 236   eReturnStatusSuccessFinishResult,
 237   eReturnStatusSuccessContinuingNoResult,
 238   eReturnStatusSuccessContinuingResult,
 239   eReturnStatusStarted,
 240   eReturnStatusFailed,
 241   eReturnStatusQuit
 242 };
 243
 244 //----------------------------------------------------------------------
 245 // The results of expression evaluation:
 246 //----------------------------------------------------------------------
 247 enum ExpressionResults {
 248   eExpressionCompleted = 0,
 249   eExpressionSetupError,
 250   eExpressionParseError,
 251   eExpressionDiscarded,
 252   eExpressionInterrupted,
 253   eExpressionHitBreakpoint,
 254   eExpressionTimedOut,
 255   eExpressionResultUnavailable,
 256   eExpressionStoppedForDebug
 257 };
 258
 259 //----------------------------------------------------------------------
 260 // Connection Status Types
 261 //----------------------------------------------------------------------
 262 enum ConnectionStatus {
 263   eConnectionStatusSuccess,        // Success
 264   eConnectionStatusEndOfFile,      // End-of-file encountered
 265   eConnectionStatusError,          // Check GetError() for details
 266   eConnectionStatusTimedOut,       // Request timed out
 267   eConnectionStatusNoConnection,   // No connection
 268   eConnectionStatusLostConnection, // Lost connection while connected to a valid
 269                                    // connection
 270   eConnectionStatusInterrupted     // Interrupted read
 271 };
 272
 273 enum ErrorType {
 274   eErrorTypeInvalid,
 275   eErrorTypeGeneric,    ///< Generic errors that can be any value.
 276   eErrorTypeMachKernel, ///< Mach kernel error codes.
 277   eErrorTypePOSIX,      ///< POSIX error codes.
 278   eErrorTypeExpression, ///< These are from the ExpressionResults enum.
 279   eErrorTypeWin32       ///< Standard Win32 error codes.
 280 };
 281
 282 enum ValueType {
 283   eValueTypeInvalid = 0,
 284   eValueTypeVariableGlobal = 1,   // globals variable
 285   eValueTypeVariableStatic = 2,   // static variable
 286   eValueTypeVariableArgument = 3, // function argument variables
 287   eValueTypeVariableLocal = 4,    // function local variables
 288   eValueTypeRegister = 5,         // stack frame register value
 289   eValueTypeRegisterSet = 6,      // A collection of stack frame register values
 290   eValueTypeConstResult = 7,      // constant result variables
 291   eValueTypeVariableThreadLocal = 8 // thread local storage variable
 292 };
 293
 294 //----------------------------------------------------------------------
 295 // Token size/granularities for Input Readers
 296 //----------------------------------------------------------------------
 297
 298 enum InputReaderGranularity {
 299   eInputReaderGranularityInvalid = 0,
 300   eInputReaderGranularityByte,
 301   eInputReaderGranularityWord,
 302   eInputReaderGranularityLine,
 303   eInputReaderGranularityAll
 304 };
 305
 306 //------------------------------------------------------------------
 307 /// These mask bits allow a common interface for queries that can
 308 /// limit the amount of information that gets parsed to only the
 309 /// information that is requested. These bits also can indicate what
 310 /// actually did get resolved during query function calls.
 311 ///
 312 /// Each definition corresponds to a one of the member variables
 313 /// in this class, and requests that that item be resolved, or
 314 /// indicates that the member did get resolved.
 315 //------------------------------------------------------------------
 316 FLAGS_ENUM(SymbolContextItem){
 317     eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from
 318                                       ///a query, or was located in query
 319                                       ///results
 320     eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from
 321                                       ///a query, or was located in query
 322                                       ///results
 323     eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested
 324                                         ///from a query, or was located in query
 325                                         ///results
 326     eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested
 327                                         ///from a query, or was located in query
 328                                         ///results
 329     eSymbolContextBlock = (1u << 4),    ///< Set when the deepest \a block is
 330                                      ///requested from a query, or was located
 331                                      ///in query results
 332     eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is
 333                                          ///requested from a query, or was
 334                                          ///located in query results
 335     eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from
 336                                       ///a query, or was located in query
 337                                       ///results
 338     eSymbolContextEverything = ((eSymbolContextSymbol << 1) -
 339                                 1u), ///< Indicates to try and lookup everything
 340                                      ///up during a routine symbol context
 341                                      ///query.
 342     eSymbolContextVariable = (1u << 7) ///< Set when \a global or static
 343                                        ///variable is requested from a query, or
 344                                        ///was located in query results.
 345     ///< eSymbolContextVariable is potentially expensive to lookup so it isn't
 346     ///included in
 347     ///< eSymbolContextEverything which stops it from being used during frame PC
 348     ///lookups and
 349     ///< many other potential address to symbol context lookups.
 350 };
 351
 352 FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
 353                         ePermissionsReadable = (1u << 1),
 354                         ePermissionsExecutable = (1u << 2)};
 355
 356 enum InputReaderAction {
 357   eInputReaderActivate, // reader is newly pushed onto the reader stack
 358   eInputReaderAsynchronousOutputWritten, // an async output event occurred; the
 359                                          // reader may want to do something
 360   eInputReaderReactivate, // reader is on top of the stack again after another
 361                           // reader was popped off
 362   eInputReaderDeactivate, // another reader was pushed on the stack
 363   eInputReaderGotToken,   // reader got one of its tokens (granularity)
 364   eInputReaderInterrupt, // reader received an interrupt signal (probably from a
 365                          // control-c)
 366   eInputReaderEndOfFile, // reader received an EOF char (probably from a
 367                          // control-d)
 368   eInputReaderDone       // reader was just popped off the stack and is done
 369 };
 370
 371 FLAGS_ENUM(BreakpointEventType){
 372     eBreakpointEventTypeInvalidType = (1u << 0),
 373     eBreakpointEventTypeAdded = (1u << 1),
 374     eBreakpointEventTypeRemoved = (1u << 2),
 375     eBreakpointEventTypeLocationsAdded = (1u << 3), // Locations added doesn't
 376                                                     // get sent when the
 377                                                     // breakpoint is created
 378     eBreakpointEventTypeLocationsRemoved = (1u << 4),
 379     eBreakpointEventTypeLocationsResolved = (1u << 5),
 380     eBreakpointEventTypeEnabled = (1u << 6),
 381     eBreakpointEventTypeDisabled = (1u << 7),
 382     eBreakpointEventTypeCommandChanged = (1u << 8),
 383     eBreakpointEventTypeConditionChanged = (1u << 9),
 384     eBreakpointEventTypeIgnoreChanged = (1u << 10),
 385     eBreakpointEventTypeThreadChanged = (1u << 11),
 386     eBreakpointEventTypeAutoContinueChanged = (1u << 12)};
 387
 388 FLAGS_ENUM(WatchpointEventType){
 389     eWatchpointEventTypeInvalidType = (1u << 0),
 390     eWatchpointEventTypeAdded = (1u << 1),
 391     eWatchpointEventTypeRemoved = (1u << 2),
 392     eWatchpointEventTypeEnabled = (1u << 6),
 393     eWatchpointEventTypeDisabled = (1u << 7),
 394     eWatchpointEventTypeCommandChanged = (1u << 8),
 395     eWatchpointEventTypeConditionChanged = (1u << 9),
 396     eWatchpointEventTypeIgnoreChanged = (1u << 10),
 397     eWatchpointEventTypeThreadChanged = (1u << 11),
 398     eWatchpointEventTypeTypeChanged = (1u << 12)};
 399
 400 //----------------------------------------------------------------------
 401 /// Programming language type.
 402 ///
 403 /// These enumerations use the same language enumerations as the DWARF
 404 /// specification for ease of use and consistency.
 405 /// The enum -> string code is in Language.cpp, don't change this
 406 /// table without updating that code as well.
 407 //----------------------------------------------------------------------
 408 enum LanguageType {
 409   eLanguageTypeUnknown = 0x0000,        ///< Unknown or invalid language value.
 410   eLanguageTypeC89 = 0x0001,            ///< ISO C:1989.
 411   eLanguageTypeC = 0x0002,              ///< Non-standardized C, such as K&R.
 412   eLanguageTypeAda83 = 0x0003,          ///< ISO Ada:1983.
 413   eLanguageTypeC_plus_plus = 0x0004,    ///< ISO C++:1998.
 414   eLanguageTypeCobol74 = 0x0005,        ///< ISO Cobol:1974.
 415   eLanguageTypeCobol85 = 0x0006,        ///< ISO Cobol:1985.
 416   eLanguageTypeFortran77 = 0x0007,      ///< ISO Fortran 77.
 417   eLanguageTypeFortran90 = 0x0008,      ///< ISO Fortran 90.
 418   eLanguageTypePascal83 = 0x0009,       ///< ISO Pascal:1983.
 419   eLanguageTypeModula2 = 0x000a,        ///< ISO Modula-2:1996.
 420   eLanguageTypeJava = 0x000b,           ///< Java.
 421   eLanguageTypeC99 = 0x000c,            ///< ISO C:1999.
 422   eLanguageTypeAda95 = 0x000d,          ///< ISO Ada:1995.
 423   eLanguageTypeFortran95 = 0x000e,      ///< ISO Fortran 95.
 424   eLanguageTypePLI = 0x000f,            ///< ANSI PL/I:1976.
 425   eLanguageTypeObjC = 0x0010,           ///< Objective-C.
 426   eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++.
 427   eLanguageTypeUPC = 0x0012,            ///< Unified Parallel C.
 428   eLanguageTypeD = 0x0013,              ///< D.
 429   eLanguageTypePython = 0x0014,         ///< Python.
 430   // NOTE: The below are DWARF5 constants, subject to change upon
 431   // completion of the DWARF5 specification
 432   eLanguageTypeOpenCL = 0x0015,         ///< OpenCL.
 433   eLanguageTypeGo = 0x0016,             ///< Go.
 434   eLanguageTypeModula3 = 0x0017,        ///< Modula 3.
 435   eLanguageTypeHaskell = 0x0018,        ///< Haskell.
 436   eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003.
 437   eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011.
 438   eLanguageTypeOCaml = 0x001b,          ///< OCaml.
 439   eLanguageTypeRust = 0x001c,           ///< Rust.
 440   eLanguageTypeC11 = 0x001d,            ///< ISO C:2011.
 441   eLanguageTypeSwift = 0x001e,          ///< Swift.
 442   eLanguageTypeJulia = 0x001f,          ///< Julia.
 443   eLanguageTypeDylan = 0x0020,          ///< Dylan.
 444   eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014.
 445   eLanguageTypeFortran03 = 0x0022,      ///< ISO Fortran 2003.
 446   eLanguageTypeFortran08 = 0x0023,      ///< ISO Fortran 2008.
 447   // Vendor Extensions
 448   // Note: Language::GetNameForLanguageType
 449   // assumes these can be used as indexes into array language_names, and
 450   // Language::SetLanguageFromCString and Language::AsCString assume these can
 451   // be used as indexes into array g_languages.
 452   eLanguageTypeMipsAssembler = 0x0024,   ///< Mips_Assembler.
 453   eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript.
 454   eNumLanguageTypes
 455 };
 456
 457 enum InstrumentationRuntimeType {
 458   eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
 459   eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
 460   eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
 461   eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,
 462   eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004,
 463   eNumInstrumentationRuntimeTypes
 464 };
 465
 466 enum DynamicValueType {
 467   eNoDynamicValues = 0,
 468   eDynamicCanRunTarget = 1,
 469   eDynamicDontRunTarget = 2
 470 };
 471
 472 enum StopShowColumn {
 473   eStopShowColumnAnsiOrCaret = 0,
 474   eStopShowColumnAnsi = 1,
 475   eStopShowColumnCaret = 2,
 476   eStopShowColumnNone = 3
 477 };
 478
 479 enum AccessType {
 480   eAccessNone,
 481   eAccessPublic,
 482   eAccessPrivate,
 483   eAccessProtected,
 484   eAccessPackage
 485 };
 486
 487 enum CommandArgumentType {
 488   eArgTypeAddress = 0,
 489   eArgTypeAddressOrExpression,
 490   eArgTypeAliasName,
 491   eArgTypeAliasOptions,
 492   eArgTypeArchitecture,
 493   eArgTypeBoolean,
 494   eArgTypeBreakpointID,
 495   eArgTypeBreakpointIDRange,
 496   eArgTypeBreakpointName,
 497   eArgTypeByteSize,
 498   eArgTypeClassName,
 499   eArgTypeCommandName,
 500   eArgTypeCount,
 501   eArgTypeDescriptionVerbosity,
 502   eArgTypeDirectoryName,
 503   eArgTypeDisassemblyFlavor,
 504   eArgTypeEndAddress,
 505   eArgTypeExpression,
 506   eArgTypeExpressionPath,
 507   eArgTypeExprFormat,
 508   eArgTypeFilename,
 509   eArgTypeFormat,
 510   eArgTypeFrameIndex,
 511   eArgTypeFullName,
 512   eArgTypeFunctionName,
 513   eArgTypeFunctionOrSymbol,
 514   eArgTypeGDBFormat,
 515   eArgTypeHelpText,
 516   eArgTypeIndex,
 517   eArgTypeLanguage,
 518   eArgTypeLineNum,
 519   eArgTypeLogCategory,
 520   eArgTypeLogChannel,
 521   eArgTypeMethod,
 522   eArgTypeName,
 523   eArgTypeNewPathPrefix,
 524   eArgTypeNumLines,
 525   eArgTypeNumberPerLine,
 526   eArgTypeOffset,
 527   eArgTypeOldPathPrefix,
 528   eArgTypeOneLiner,
 529   eArgTypePath,
 530   eArgTypePermissionsNumber,
 531   eArgTypePermissionsString,
 532   eArgTypePid,
 533   eArgTypePlugin,
 534   eArgTypeProcessName,
 535   eArgTypePythonClass,
 536   eArgTypePythonFunction,
 537   eArgTypePythonScript,
 538   eArgTypeQueueName,
 539   eArgTypeRegisterName,
 540   eArgTypeRegularExpression,
 541   eArgTypeRunArgs,
 542   eArgTypeRunMode,
 543   eArgTypeScriptedCommandSynchronicity,
 544   eArgTypeScriptLang,
 545   eArgTypeSearchWord,
 546   eArgTypeSelector,
 547   eArgTypeSettingIndex,
 548   eArgTypeSettingKey,
 549   eArgTypeSettingPrefix,
 550   eArgTypeSettingVariableName,
 551   eArgTypeShlibName,
 552   eArgTypeSourceFile,
 553   eArgTypeSortOrder,
 554   eArgTypeStartAddress,
 555   eArgTypeSummaryString,
 556   eArgTypeSymbol,
 557   eArgTypeThreadID,
 558   eArgTypeThreadIndex,
 559   eArgTypeThreadName,
 560   eArgTypeTypeName,
 561   eArgTypeUnsignedInteger,
 562   eArgTypeUnixSignal,
 563   eArgTypeVarName,
 564   eArgTypeValue,
 565   eArgTypeWidth,
 566   eArgTypeNone,
 567   eArgTypePlatform,
 568   eArgTypeWatchpointID,
 569   eArgTypeWatchpointIDRange,
 570   eArgTypeWatchType,
 571   eArgRawInput,
 572   eArgTypeCommand,
 573   eArgTypeLastArg // Always keep this entry as the last entry in this
 574                   // enumeration!!
 575 };
 576
 577 //----------------------------------------------------------------------
 578 // Symbol types
 579 //----------------------------------------------------------------------
 580 enum SymbolType {
 581   eSymbolTypeAny = 0,
 582   eSymbolTypeInvalid = 0,
 583   eSymbolTypeAbsolute,
 584   eSymbolTypeCode,
 585   eSymbolTypeResolver,
 586   eSymbolTypeData,
 587   eSymbolTypeTrampoline,
 588   eSymbolTypeRuntime,
 589   eSymbolTypeException,
 590   eSymbolTypeSourceFile,
 591   eSymbolTypeHeaderFile,
 592   eSymbolTypeObjectFile,
 593   eSymbolTypeCommonBlock,
 594   eSymbolTypeBlock,
 595   eSymbolTypeLocal,
 596   eSymbolTypeParam,
 597   eSymbolTypeVariable,
 598   eSymbolTypeVariableType,
 599   eSymbolTypeLineEntry,
 600   eSymbolTypeLineHeader,
 601   eSymbolTypeScopeBegin,
 602   eSymbolTypeScopeEnd,
 603   eSymbolTypeAdditional, // When symbols take more than one entry, the extra
 604                          // entries get this type
 605   eSymbolTypeCompiler,
 606   eSymbolTypeInstrumentation,
 607   eSymbolTypeUndefined,
 608   eSymbolTypeObjCClass,
 609   eSymbolTypeObjCMetaClass,
 610   eSymbolTypeObjCIVar,
 611   eSymbolTypeReExported
 612 };
 613
 614 enum SectionType {
 615   eSectionTypeInvalid,
 616   eSectionTypeCode,
 617   eSectionTypeContainer, // The section contains child sections
 618   eSectionTypeData,
 619   eSectionTypeDataCString,         // Inlined C string data
 620   eSectionTypeDataCStringPointers, // Pointers to C string data
 621   eSectionTypeDataSymbolAddress,   // Address of a symbol in the symbol table
 622   eSectionTypeData4,
 623   eSectionTypeData8,
 624   eSectionTypeData16,
 625   eSectionTypeDataPointers,
 626   eSectionTypeDebug,
 627   eSectionTypeZeroFill,
 628   eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
 629   eSectionTypeDataObjCCFStrings, // Objective-C const CFString/NSString objects
 630   eSectionTypeDWARFDebugAbbrev,
 631   eSectionTypeDWARFDebugAddr,
 632   eSectionTypeDWARFDebugAranges,
 633   eSectionTypeDWARFDebugCuIndex,
 634   eSectionTypeDWARFDebugFrame,
 635   eSectionTypeDWARFDebugInfo,
 636   eSectionTypeDWARFDebugLine,
 637   eSectionTypeDWARFDebugLoc,
 638   eSectionTypeDWARFDebugMacInfo,
 639   eSectionTypeDWARFDebugMacro,
 640   eSectionTypeDWARFDebugPubNames,
 641   eSectionTypeDWARFDebugPubTypes,
 642   eSectionTypeDWARFDebugRanges,
 643   eSectionTypeDWARFDebugStr,
 644   eSectionTypeDWARFDebugStrOffsets,
 645   eSectionTypeDWARFAppleNames,
 646   eSectionTypeDWARFAppleTypes,
 647   eSectionTypeDWARFAppleNamespaces,
 648   eSectionTypeDWARFAppleObjC,
 649   eSectionTypeELFSymbolTable,       // Elf SHT_SYMTAB section
 650   eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
 651   eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
 652   eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
 653   eSectionTypeEHFrame,
 654   eSectionTypeARMexidx,
 655   eSectionTypeARMextab,
 656   eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
 657                              // __TEXT,__unwind_info
 658   eSectionTypeGoSymtab,
 659   eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
 660                                // address
 661   eSectionTypeDWARFGNUDebugAltLink,
 662   eSectionTypeDWARFDebugTypes, // DWARF .debug_types section
 663   eSectionTypeDWARFDebugNames, // DWARF v5 .debug_names
 664   eSectionTypeOther
 665 };
 666
 667 FLAGS_ENUM(EmulateInstructionOptions){
 668     eEmulateInstructionOptionNone = (0u),
 669     eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
 670     eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
 671
 672 FLAGS_ENUM(FunctionNameType){
 673     eFunctionNameTypeNone = 0u,
 674     eFunctionNameTypeAuto =
 675         (1u << 1), // Automatically figure out which FunctionNameType
 676                    // bits to set based on the function name.
 677     eFunctionNameTypeFull = (1u << 2), // The function name.
 678     // For C this is the same as just the name of the function For C++ this is
 679     // the mangled or demangled version of the mangled name. For ObjC this is
 680     // the full function signature with the + or - and the square brackets and
 681     // the class and selector
 682     eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces
 683                                        // or arguments and no class
 684                                        // methods or selectors will be searched.
 685     eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++)
 686                                          // with no namespace or arguments
 687     eFunctionNameTypeSelector =
 688         (1u << 5), // Find function by selector name (ObjC) names
 689     eFunctionNameTypeAny =
 690         eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
 691 };
 692
 693 //----------------------------------------------------------------------
 694 // Basic types enumeration for the public API SBType::GetBasicType()
 695 //----------------------------------------------------------------------
 696 enum BasicType {
 697   eBasicTypeInvalid = 0,
 698   eBasicTypeVoid = 1,
 699   eBasicTypeChar,
 700   eBasicTypeSignedChar,
 701   eBasicTypeUnsignedChar,
 702   eBasicTypeWChar,
 703   eBasicTypeSignedWChar,
 704   eBasicTypeUnsignedWChar,
 705   eBasicTypeChar16,
 706   eBasicTypeChar32,
 707   eBasicTypeShort,
 708   eBasicTypeUnsignedShort,
 709   eBasicTypeInt,
 710   eBasicTypeUnsignedInt,
 711   eBasicTypeLong,
 712   eBasicTypeUnsignedLong,
 713   eBasicTypeLongLong,
 714   eBasicTypeUnsignedLongLong,
 715   eBasicTypeInt128,
 716   eBasicTypeUnsignedInt128,
 717   eBasicTypeBool,
 718   eBasicTypeHalf,
 719   eBasicTypeFloat,
 720   eBasicTypeDouble,
 721   eBasicTypeLongDouble,
 722   eBasicTypeFloatComplex,
 723   eBasicTypeDoubleComplex,
 724   eBasicTypeLongDoubleComplex,
 725   eBasicTypeObjCID,
 726   eBasicTypeObjCClass,
 727   eBasicTypeObjCSel,
 728   eBasicTypeNullPtr,
 729   eBasicTypeOther
 730 };
 731
 732 enum TraceType {
 733   eTraceTypeNone = 0,
 734
 735   // Hardware Trace generated by the processor.
 736   eTraceTypeProcessorTrace
 737 };
 738
 739 enum StructuredDataType {
 740   eStructuredDataTypeInvalid = -1,
 741   eStructuredDataTypeNull = 0,
 742   eStructuredDataTypeGeneric,
 743   eStructuredDataTypeArray,
 744   eStructuredDataTypeInteger,
 745   eStructuredDataTypeFloat,
 746   eStructuredDataTypeBoolean,
 747   eStructuredDataTypeString,
 748   eStructuredDataTypeDictionary
 749 };
 750
 751 FLAGS_ENUM(TypeClass){
 752     eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
 753     eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
 754     eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
 755     eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
 756     eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
 757     eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
 758     eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
 759     eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
 760     eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
 761     eTypeClassVector = (1u << 17),
 762     // Define the last type class as the MSBit of a 32 bit value
 763     eTypeClassOther = (1u << 31),
 764     // Define a mask that can be used for any type when finding types
 765     eTypeClassAny = (0xffffffffu)};
 766
 767 enum TemplateArgumentKind {
 768   eTemplateArgumentKindNull = 0,
 769   eTemplateArgumentKindType,
 770   eTemplateArgumentKindDeclaration,
 771   eTemplateArgumentKindIntegral,
 772   eTemplateArgumentKindTemplate,
 773   eTemplateArgumentKindTemplateExpansion,
 774   eTemplateArgumentKindExpression,
 775   eTemplateArgumentKindPack,
 776   eTemplateArgumentKindNullPtr,
 777 };
 778
 779 //----------------------------------------------------------------------
 780 // Options that can be set for a formatter to alter its behavior Not all of
 781 // these are applicable to all formatter types
 782 //----------------------------------------------------------------------
 783 FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
 784                         eTypeOptionCascade = (1u << 0),
 785                         eTypeOptionSkipPointers = (1u << 1),
 786                         eTypeOptionSkipReferences = (1u << 2),
 787                         eTypeOptionHideChildren = (1u << 3),
 788                         eTypeOptionHideValue = (1u << 4),
 789                         eTypeOptionShowOneLiner = (1u << 5),
 790                         eTypeOptionHideNames = (1u << 6),
 791                         eTypeOptionNonCacheable = (1u << 7),
 792                         eTypeOptionHideEmptyAggregates = (1u << 8),
 793                         eTypeOptionFrontEndWantsDereference = (1u << 9)
 794 };
 795
 796 //----------------------------------------------------------------------
 797 // This is the return value for frame comparisons.  If you are comparing frame
 798 // A to frame B the following cases arise: 1) When frame A pushes frame B (or a
 799 // frame that ends up pushing B) A is Older than B. 2) When frame A pushed
 800 // frame B (or if frame A is on the stack but B is not) A is Younger than B 3)
 801 // When frame A and frame B have the same StackID, they are Equal. 4) When
 802 // frame A and frame B have the same immediate parent frame, but are not equal,
 803 // the comparison yields
 804 //    SameParent.
 805 // 5) If the two frames are on different threads or processes the comparison is
 806 // Invalid 6) If for some reason we can't figure out what went on, we return
 807 // Unknown.
 808 //----------------------------------------------------------------------
 809 enum FrameComparison {
 810   eFrameCompareInvalid,
 811   eFrameCompareUnknown,
 812   eFrameCompareEqual,
 813   eFrameCompareSameParent,
 814   eFrameCompareYounger,
 815   eFrameCompareOlder
 816 };
 817
 818 //----------------------------------------------------------------------
 819 // File Permissions
 820 //
 821 // Designed to mimic the unix file permission bits so they can be used with
 822 // functions that set 'mode_t' to certain values for permissions.
 823 //----------------------------------------------------------------------
 824 FLAGS_ENUM(FilePermissions){
 825     eFilePermissionsUserRead = (1u << 8), eFilePermissionsUserWrite = (1u << 7),
 826     eFilePermissionsUserExecute = (1u << 6),
 827     eFilePermissionsGroupRead = (1u << 5),
 828     eFilePermissionsGroupWrite = (1u << 4),
 829     eFilePermissionsGroupExecute = (1u << 3),
 830     eFilePermissionsWorldRead = (1u << 2),
 831     eFilePermissionsWorldWrite = (1u << 1),
 832     eFilePermissionsWorldExecute = (1u << 0),
 833
 834     eFilePermissionsUserRW = (eFilePermissionsUserRead |
 835                               eFilePermissionsUserWrite | 0),
 836     eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 |
 837                                   eFilePermissionsUserExecute),
 838     eFilePermissionsUserRWX = (eFilePermissionsUserRead |
 839                                eFilePermissionsUserWrite |
 840                                eFilePermissionsUserExecute),
 841
 842     eFilePermissionsGroupRW = (eFilePermissionsGroupRead |
 843                                eFilePermissionsGroupWrite | 0),
 844     eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 |
 845                                eFilePermissionsGroupExecute),
 846     eFilePermissionsGroupRWX = (eFilePermissionsGroupRead |
 847                                 eFilePermissionsGroupWrite |
 848                                 eFilePermissionsGroupExecute),
 849
 850     eFilePermissionsWorldRW = (eFilePermissionsWorldRead |
 851                                eFilePermissionsWorldWrite | 0),
 852     eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 |
 853                                eFilePermissionsWorldExecute),
 854     eFilePermissionsWorldRWX = (eFilePermissionsWorldRead |
 855                                 eFilePermissionsWorldWrite |
 856                                 eFilePermissionsWorldExecute),
 857
 858     eFilePermissionsEveryoneR = (eFilePermissionsUserRead |
 859                                  eFilePermissionsGroupRead |
 860                                  eFilePermissionsWorldRead),
 861     eFilePermissionsEveryoneW = (eFilePermissionsUserWrite |
 862                                  eFilePermissionsGroupWrite |
 863                                  eFilePermissionsWorldWrite),
 864     eFilePermissionsEveryoneX = (eFilePermissionsUserExecute |
 865                                  eFilePermissionsGroupExecute |
 866                                  eFilePermissionsWorldExecute),
 867
 868     eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR |
 869                                   eFilePermissionsEveryoneW | 0),
 870     eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 |
 871                                   eFilePermissionsEveryoneX),
 872     eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR |
 873                                    eFilePermissionsEveryoneW |
 874                                    eFilePermissionsEveryoneX),
 875     eFilePermissionsFileDefault = eFilePermissionsUserRW,
 876     eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
 877 };
 878
 879 //----------------------------------------------------------------------
 880 // Queue work item types
 881 //
 882 // The different types of work that can be enqueued on a libdispatch aka Grand
 883 // Central Dispatch (GCD) queue.
 884 //----------------------------------------------------------------------
 885 enum QueueItemKind {
 886   eQueueItemKindUnknown = 0,
 887   eQueueItemKindFunction,
 888   eQueueItemKindBlock
 889 };
 890
 891 //----------------------------------------------------------------------
 892 // Queue type
 893 // libdispatch aka Grand Central Dispatch (GCD) queues can be either serial
 894 // (executing on one thread) or concurrent (executing on multiple threads).
 895 //----------------------------------------------------------------------
 896 enum QueueKind {
 897   eQueueKindUnknown = 0,
 898   eQueueKindSerial,
 899   eQueueKindConcurrent
 900 };
 901
 902 //----------------------------------------------------------------------
 903 // Expression Evaluation Stages
 904 // These are the cancellable stages of expression evaluation, passed to the
 905 // expression evaluation callback, so that you can interrupt expression
 906 // evaluation at the various points in its lifecycle.
 907 //----------------------------------------------------------------------
 908 enum ExpressionEvaluationPhase {
 909   eExpressionEvaluationParse = 0,
 910   eExpressionEvaluationIRGen,
 911   eExpressionEvaluationExecution,
 912   eExpressionEvaluationComplete
 913 };
 914
 915 //----------------------------------------------------------------------
 916 // Watchpoint Kind
 917 // Indicates what types of events cause the watchpoint to fire. Used by Native
 918 // *Protocol-related classes.
 919 //----------------------------------------------------------------------
 920 FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0),
 921                            eWatchpointKindRead = (1u << 1)};
 922
 923 enum GdbSignal {
 924   eGdbSignalBadAccess = 0x91,
 925   eGdbSignalBadInstruction = 0x92,
 926   eGdbSignalArithmetic = 0x93,
 927   eGdbSignalEmulation = 0x94,
 928   eGdbSignalSoftware = 0x95,
 929   eGdbSignalBreakpoint = 0x96
 930 };
 931
 932 //----------------------------------------------------------------------
 933 // Used with SBHost::GetPath (lldb::PathType) to find files that are related to
 934 // LLDB on the current host machine. Most files are relative to LLDB or are in
 935 // known locations.
 936 //----------------------------------------------------------------------
 937 enum PathType {
 938   ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB
 939                          // mach-o file in LLDB.framework (MacOSX) exists
 940   ePathTypeSupportExecutableDir, // Find LLDB support executable directory
 941                                  // (debugserver, etc)
 942   ePathTypeHeaderDir,            // Find LLDB header file directory
 943   ePathTypePythonDir,            // Find Python modules (PYTHONPATH) directory
 944   ePathTypeLLDBSystemPlugins,    // System plug-ins directory
 945   ePathTypeLLDBUserPlugins,      // User plug-ins directory
 946   ePathTypeLLDBTempSystemDir,    // The LLDB temp directory for this system that
 947                                  // will be cleaned up on exit
 948   ePathTypeGlobalLLDBTempSystemDir, // The LLDB temp directory for this system,
 949                                     // NOT cleaned up on a process exit.
 950   ePathTypeClangDir                 // Find path to Clang builtin headers
 951 };
 952
 953 //----------------------------------------------------------------------
 954 // Kind of member function
 955 // Used by the type system
 956 //----------------------------------------------------------------------
 957 enum MemberFunctionKind {
 958   eMemberFunctionKindUnknown = 0,    // Not sure what the type of this is
 959   eMemberFunctionKindConstructor,    // A function used to create instances
 960   eMemberFunctionKindDestructor,     // A function used to tear down existing
 961                                      // instances
 962   eMemberFunctionKindInstanceMethod, // A function that applies to a specific
 963                                      // instance
 964   eMemberFunctionKindStaticMethod    // A function that applies to a type rather
 965                                      // than any instance
 966 };
 967
 968 //----------------------------------------------------------------------
 969 // String matching algorithm used by SBTarget
 970 //----------------------------------------------------------------------
 971 enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };
 972
 973 //----------------------------------------------------------------------
 974 // Bitmask that describes details about a type
 975 //----------------------------------------------------------------------
 976 FLAGS_ENUM(TypeFlags){
 977     eTypeHasChildren = (1u << 0),       eTypeHasValue = (1u << 1),
 978     eTypeIsArray = (1u << 2),           eTypeIsBlock = (1u << 3),
 979     eTypeIsBuiltIn = (1u << 4),         eTypeIsClass = (1u << 5),
 980     eTypeIsCPlusPlus = (1u << 6),       eTypeIsEnumeration = (1u << 7),
 981     eTypeIsFuncPrototype = (1u << 8),   eTypeIsMember = (1u << 9),
 982     eTypeIsObjC = (1u << 10),           eTypeIsPointer = (1u << 11),
 983     eTypeIsReference = (1u << 12),      eTypeIsStructUnion = (1u << 13),
 984     eTypeIsTemplate = (1u << 14),       eTypeIsTypedef = (1u << 15),
 985     eTypeIsVector = (1u << 16),         eTypeIsScalar = (1u << 17),
 986     eTypeIsInteger = (1u << 18),        eTypeIsFloat = (1u << 19),
 987     eTypeIsComplex = (1u << 20),        eTypeIsSigned = (1u << 21),
 988     eTypeInstanceIsPointer = (1u << 22)};
 989
 990 FLAGS_ENUM(CommandFlags){
 991     //----------------------------------------------------------------------
 992     // eCommandRequiresTarget
 993     //
 994     // Ensures a valid target is contained in m_exe_ctx prior to executing the
 995     // command. If a target doesn't exist or is invalid, the command will fail
 996     // and CommandObject::GetInvalidTargetDescription() will be returned as the
 997     // error. CommandObject subclasses can override the virtual function for
 998     // GetInvalidTargetDescription() to provide custom strings when needed.
 999     //----------------------------------------------------------------------
1000     eCommandRequiresTarget = (1u << 0),
1001     //----------------------------------------------------------------------
1002     // eCommandRequiresProcess
1003     //
1004     // Ensures a valid process is contained in m_exe_ctx prior to executing the
1005     // command. If a process doesn't exist or is invalid, the command will fail
1006     // and CommandObject::GetInvalidProcessDescription() will be returned as
1007     // the error. CommandObject subclasses can override the virtual function
1008     // for GetInvalidProcessDescription() to provide custom strings when
1009     // needed.
1010     //----------------------------------------------------------------------
1011     eCommandRequiresProcess = (1u << 1),
1012     //----------------------------------------------------------------------
1013     // eCommandRequiresThread
1014     //
1015     // Ensures a valid thread is contained in m_exe_ctx prior to executing the
1016     // command. If a thread doesn't exist or is invalid, the command will fail
1017     // and CommandObject::GetInvalidThreadDescription() will be returned as the
1018     // error. CommandObject subclasses can override the virtual function for
1019     // GetInvalidThreadDescription() to provide custom strings when needed.
1020     //----------------------------------------------------------------------
1021     eCommandRequiresThread = (1u << 2),
1022     //----------------------------------------------------------------------
1023     // eCommandRequiresFrame
1024     //
1025     // Ensures a valid frame is contained in m_exe_ctx prior to executing the
1026     // command. If a frame doesn't exist or is invalid, the command will fail
1027     // and CommandObject::GetInvalidFrameDescription() will be returned as the
1028     // error. CommandObject subclasses can override the virtual function for
1029     // GetInvalidFrameDescription() to provide custom strings when needed.
1030     //----------------------------------------------------------------------
1031     eCommandRequiresFrame = (1u << 3),
1032     //----------------------------------------------------------------------
1033     // eCommandRequiresRegContext
1034     //
1035     // Ensures a valid register context (from the selected frame if there is a
1036     // frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
1037     // available from m_exe_ctx prior to executing the command. If a target
1038     // doesn't exist or is invalid, the command will fail and
1039     // CommandObject::GetInvalidRegContextDescription() will be returned as the
1040     // error. CommandObject subclasses can override the virtual function for
1041     // GetInvalidRegContextDescription() to provide custom strings when needed.
1042     //----------------------------------------------------------------------
1043     eCommandRequiresRegContext = (1u << 4),
1044     //----------------------------------------------------------------------
1045     // eCommandTryTargetAPILock
1046     //
1047     // Attempts to acquire the target lock if a target is selected in the
1048     // command interpreter. If the command object fails to acquire the API
1049     // lock, the command will fail with an appropriate error message.
1050     //----------------------------------------------------------------------
1051     eCommandTryTargetAPILock = (1u << 5),
1052     //----------------------------------------------------------------------
1053     // eCommandProcessMustBeLaunched
1054     //
1055     // Verifies that there is a launched process in m_exe_ctx, if there isn't,
1056     // the command will fail with an appropriate error message.
1057     //----------------------------------------------------------------------
1058     eCommandProcessMustBeLaunched = (1u << 6),
1059     //----------------------------------------------------------------------
1060     // eCommandProcessMustBePaused
1061     //
1062     // Verifies that there is a paused process in m_exe_ctx, if there isn't,
1063     // the command will fail with an appropriate error message.
1064     //----------------------------------------------------------------------
1065     eCommandProcessMustBePaused = (1u << 7)};
1066
1067 //----------------------------------------------------------------------
1068 // Whether a summary should cap how much data it returns to users or not
1069 //----------------------------------------------------------------------
1070 enum TypeSummaryCapping {
1071   eTypeSummaryCapped = true,
1072   eTypeSummaryUncapped = false
1073 };
1074
1075 } // namespace lldb
1076
1077 #endif // LLDB_lldb_enumerations_h_