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