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

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