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