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