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 <cstdint> 13 #include <type_traits> 14 15 #ifndef SWIG 16 // Macro to enable bitmask operations on an enum. Without this, Enum | Enum 17 // gets promoted to an int, so you have to say Enum a = Enum(eFoo | eBar). If 18 // you mark Enum with LLDB_MARK_AS_BITMASK_ENUM(Enum), however, you can simply 19 // write Enum a = eFoo | eBar. 20 // Unfortunately, swig<3.0 doesn't recognise the constexpr keyword, so remove 21 // this entire block, as it is not necessary for swig processing. 22 #define LLDB_MARK_AS_BITMASK_ENUM(Enum) \ 23 constexpr Enum operator|(Enum a, Enum b) { \ 24 return static_cast<Enum>( \ 25 static_cast<std::underlying_type<Enum>::type>(a) | \ 26 static_cast<std::underlying_type<Enum>::type>(b)); \ 27 } \ 28 constexpr Enum operator&(Enum a, Enum b) { \ 29 return static_cast<Enum>( \ 30 static_cast<std::underlying_type<Enum>::type>(a) & \ 31 static_cast<std::underlying_type<Enum>::type>(b)); \ 32 } \ 33 constexpr Enum operator~(Enum a) { \ 34 return static_cast<Enum>( \ 35 ~static_cast<std::underlying_type<Enum>::type>(a)); \ 36 } \ 37 inline Enum &operator|=(Enum &a, Enum b) { \ 38 a = a | b; \ 39 return a; \ 40 } \ 41 inline Enum &operator&=(Enum &a, Enum b) { \ 42 a = a & b; \ 43 return a; \ 44 } 45 #else 46 #define LLDB_MARK_AS_BITMASK_ENUM(Enum) 47 #endif 48 49 #ifndef SWIG 50 // With MSVC, the default type of an enum is always signed, even if one of the 51 // enumerator values is too large to fit into a signed integer but would 52 // otherwise fit into an unsigned integer. As a result of this, all of LLDB's 53 // flag-style enumerations that specify something like eValueFoo = 1u << 31 54 // result in negative values. This usually just results in a benign warning, 55 // but in a few places we actually do comparisons on the enum values, which 56 // would cause a real bug. Furthermore, there's no way to silence only this 57 // warning, as it's part of -Wmicrosoft which also catches a whole slew of 58 // other useful issues. 59 // 60 // To make matters worse, early versions of SWIG don't recognize the syntax of 61 // specifying the underlying type of an enum (and Python doesn't care anyway) 62 // so we need a way to specify the underlying type when the enum is being used 63 // from C++ code, but just use a regular enum when swig is pre-processing. 64 #define FLAGS_ENUM(Name) enum Name : unsigned 65 #define FLAGS_ANONYMOUS_ENUM() enum : unsigned 66 #else 67 #define FLAGS_ENUM(Name) enum Name 68 #define FLAGS_ANONYMOUS_ENUM() enum 69 #endif 70 71 namespace lldb { 72 73 /// Process and Thread States. 74 enum StateType { 75 eStateInvalid = 0, 76 eStateUnloaded, ///< Process is object is valid, but not currently loaded 77 eStateConnected, ///< Process is connected to remote debug services, but not 78 /// launched or attached to anything yet 79 eStateAttaching, ///< Process is currently trying to attach 80 eStateLaunching, ///< Process is in the process of launching 81 // The state changes eStateAttaching and eStateLaunching are both sent while 82 // the private state thread is either not yet started or paused. For that 83 // reason, they should only be signaled as public state changes, and not 84 // private state changes. 85 eStateStopped, ///< Process or thread is stopped and can be examined. 86 eStateRunning, ///< Process or thread is running and can't be examined. 87 eStateStepping, ///< Process or thread is in the process of stepping and can 88 /// not be examined. 89 eStateCrashed, ///< Process or thread has crashed and can be examined. 90 eStateDetached, ///< Process has been detached and can't be examined. 91 eStateExited, ///< Process has exited and can't be examined. 92 eStateSuspended, ///< Process or thread is in a suspended state as far 93 ///< as the debugger is concerned while other processes 94 ///< or threads get the chance to run. 95 kLastStateType = eStateSuspended 96 }; 97 98 /// Launch Flags. FLAGS_ENUM(LaunchFlags)99 FLAGS_ENUM(LaunchFlags){ 100 eLaunchFlagNone = 0u, 101 eLaunchFlagExec = (1u << 0), ///< Exec when launching and turn the calling 102 /// process into a new process 103 eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to 104 /// allow the process to be debugged 105 eLaunchFlagStopAtEntry = (1u 106 << 2), ///< Stop at the program entry point 107 /// instead of auto-continuing when 108 /// launching or attaching at entry point 109 eLaunchFlagDisableASLR = 110 (1u << 3), ///< Disable Address Space Layout Randomization 111 eLaunchFlagDisableSTDIO = 112 (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app) 113 eLaunchFlagLaunchInTTY = 114 (1u << 5), ///< Launch the process in a new TTY if supported by the host 115 eLaunchFlagLaunchInShell = 116 (1u << 6), ///< Launch the process inside a shell to get shell expansion 117 eLaunchFlagLaunchInSeparateProcessGroup = 118 (1u << 7), ///< Launch the process in a separate process group 119 ///< If you are going to hand the process off (e.g. to 120 ///< debugserver) 121 eLaunchFlagDontSetExitStatus = (1u << 8), 122 ///< set this flag so lldb & the handee don't race to set its exit status. 123 eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub 124 ///< should detach rather than killing 125 ///< the debugee 126 ///< if it loses connection with lldb. 127 eLaunchFlagShellExpandArguments = 128 (1u << 10), ///< Perform shell-style argument expansion 129 eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit 130 eLaunchFlagInheritTCCFromParent = 131 (1u << 12), ///< Don't make the inferior responsible for its own TCC 132 ///< permissions but instead inherit them from its parent. 133 }; 134 135 /// Thread Run Modes. 136 enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping }; 137 138 /// Byte ordering definitions. 139 enum ByteOrder { 140 eByteOrderInvalid = 0, 141 eByteOrderBig = 1, 142 eByteOrderPDP = 2, 143 eByteOrderLittle = 4 144 }; 145 146 /// Register encoding definitions. 147 enum Encoding { 148 eEncodingInvalid = 0, 149 eEncodingUint, ///< unsigned integer 150 eEncodingSint, ///< signed integer 151 eEncodingIEEE754, ///< float 152 eEncodingVector ///< vector registers 153 }; 154 155 /// Display format definitions. 156 enum Format { 157 eFormatDefault = 0, 158 eFormatInvalid = 0, 159 eFormatBoolean, 160 eFormatBinary, 161 eFormatBytes, 162 eFormatBytesWithASCII, 163 eFormatChar, 164 eFormatCharPrintable, ///< Only printable characters, '.' if not printable 165 eFormatComplex, ///< Floating point complex type 166 eFormatComplexFloat = eFormatComplex, 167 eFormatCString, ///< NULL terminated C strings 168 eFormatDecimal, 169 eFormatEnum, 170 eFormatHex, 171 eFormatHexUppercase, 172 eFormatFloat, 173 eFormatOctal, 174 eFormatOSType, ///< OS character codes encoded into an integer 'PICT' 'text' 175 ///< etc... 176 eFormatUnicode16, 177 eFormatUnicode32, 178 eFormatUnsigned, 179 eFormatPointer, 180 eFormatVectorOfChar, 181 eFormatVectorOfSInt8, 182 eFormatVectorOfUInt8, 183 eFormatVectorOfSInt16, 184 eFormatVectorOfUInt16, 185 eFormatVectorOfSInt32, 186 eFormatVectorOfUInt32, 187 eFormatVectorOfSInt64, 188 eFormatVectorOfUInt64, 189 eFormatVectorOfFloat16, 190 eFormatVectorOfFloat32, 191 eFormatVectorOfFloat64, 192 eFormatVectorOfUInt128, 193 eFormatComplexInteger, ///< Integer complex type 194 eFormatCharArray, ///< Print characters with no single quotes, used for 195 ///< character arrays that can contain non printable 196 ///< characters 197 eFormatAddressInfo, ///< Describe what an address points to (func + offset 198 ///< with file/line, symbol + offset, data, etc) 199 eFormatHexFloat, ///< ISO C99 hex float string 200 eFormatInstruction, ///< Disassemble an opcode 201 eFormatVoid, ///< Do not print this 202 eFormatUnicode8, 203 kNumFormats 204 }; 205 206 /// Description levels for "void GetDescription(Stream *, DescriptionLevel)" 207 /// calls. 208 enum DescriptionLevel { 209 eDescriptionLevelBrief = 0, 210 eDescriptionLevelFull, 211 eDescriptionLevelVerbose, 212 eDescriptionLevelInitial, 213 kNumDescriptionLevels 214 }; 215 216 /// Script interpreter types. 217 enum ScriptLanguage { 218 eScriptLanguageNone = 0, 219 eScriptLanguagePython, 220 eScriptLanguageLua, 221 eScriptLanguageUnknown, 222 eScriptLanguageDefault = eScriptLanguageLua 223 }; 224 225 /// Register numbering types. 226 // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of 227 // these to the lldb internal register numbering scheme (eRegisterKindLLDB). 228 enum RegisterKind { 229 eRegisterKindEHFrame = 0, ///< the register numbers seen in eh_frame 230 eRegisterKindDWARF, ///< the register numbers seen DWARF 231 eRegisterKindGeneric, ///< insn ptr reg, stack ptr reg, etc not specific to 232 ///< any particular target 233 eRegisterKindProcessPlugin, ///< num used by the process plugin - e.g. by the 234 ///< remote gdb-protocol stub program 235 eRegisterKindLLDB, ///< lldb's internal register numbers 236 kNumRegisterKinds 237 }; 238 239 /// Thread stop reasons. 240 enum StopReason { 241 eStopReasonInvalid = 0, 242 eStopReasonNone, 243 eStopReasonTrace, 244 eStopReasonBreakpoint, 245 eStopReasonWatchpoint, 246 eStopReasonSignal, 247 eStopReasonException, 248 eStopReasonExec, ///< Program was re-exec'ed 249 eStopReasonPlanComplete, 250 eStopReasonThreadExiting, 251 eStopReasonInstrumentation, 252 eStopReasonProcessorTrace, 253 eStopReasonFork, 254 eStopReasonVFork, 255 eStopReasonVForkDone, 256 }; 257 258 /// Command Return Status Types. 259 enum ReturnStatus { 260 eReturnStatusInvalid, 261 eReturnStatusSuccessFinishNoResult, 262 eReturnStatusSuccessFinishResult, 263 eReturnStatusSuccessContinuingNoResult, 264 eReturnStatusSuccessContinuingResult, 265 eReturnStatusStarted, 266 eReturnStatusFailed, 267 eReturnStatusQuit 268 }; 269 270 /// The results of expression evaluation. 271 enum ExpressionResults { 272 eExpressionCompleted = 0, 273 eExpressionSetupError, 274 eExpressionParseError, 275 eExpressionDiscarded, 276 eExpressionInterrupted, 277 eExpressionHitBreakpoint, 278 eExpressionTimedOut, 279 eExpressionResultUnavailable, 280 eExpressionStoppedForDebug, 281 eExpressionThreadVanished 282 }; 283 284 enum SearchDepth { 285 eSearchDepthInvalid = 0, 286 eSearchDepthTarget, 287 eSearchDepthModule, 288 eSearchDepthCompUnit, 289 eSearchDepthFunction, 290 eSearchDepthBlock, 291 eSearchDepthAddress, 292 kLastSearchDepthKind = eSearchDepthAddress 293 }; 294 295 /// Connection Status Types. 296 enum ConnectionStatus { 297 eConnectionStatusSuccess, ///< Success 298 eConnectionStatusEndOfFile, ///< End-of-file encountered 299 eConnectionStatusError, ///< Check GetError() for details 300 eConnectionStatusTimedOut, ///< Request timed out 301 eConnectionStatusNoConnection, ///< No connection 302 eConnectionStatusLostConnection, ///< Lost connection while connected to a 303 ///< valid connection 304 eConnectionStatusInterrupted ///< Interrupted read 305 }; 306 307 enum ErrorType { 308 eErrorTypeInvalid, 309 eErrorTypeGeneric, ///< Generic errors that can be any value. 310 eErrorTypeMachKernel, ///< Mach kernel error codes. 311 eErrorTypePOSIX, ///< POSIX error codes. 312 eErrorTypeExpression, ///< These are from the ExpressionResults enum. 313 eErrorTypeWin32 ///< Standard Win32 error codes. 314 }; 315 316 enum ValueType { 317 eValueTypeInvalid = 0, 318 eValueTypeVariableGlobal = 1, ///< globals variable 319 eValueTypeVariableStatic = 2, ///< static variable 320 eValueTypeVariableArgument = 3, ///< function argument variables 321 eValueTypeVariableLocal = 4, ///< function local variables 322 eValueTypeRegister = 5, ///< stack frame register value 323 eValueTypeRegisterSet = 6, ///< A collection of stack frame register values 324 eValueTypeConstResult = 7, ///< constant result variables 325 eValueTypeVariableThreadLocal = 8, ///< thread local storage variable 326 eValueTypeVTable = 9, ///< virtual function table 327 eValueTypeVTableEntry = 10, ///< function pointer in virtual function table 328 }; 329 330 /// Token size/granularities for Input Readers. 331 332 enum InputReaderGranularity { 333 eInputReaderGranularityInvalid = 0, 334 eInputReaderGranularityByte, 335 eInputReaderGranularityWord, 336 eInputReaderGranularityLine, 337 eInputReaderGranularityAll 338 }; 339 340 /// These mask bits allow a common interface for queries that can 341 /// limit the amount of information that gets parsed to only the 342 /// information that is requested. These bits also can indicate what 343 /// actually did get resolved during query function calls. 344 /// 345 /// Each definition corresponds to a one of the member variables 346 /// in this class, and requests that that item be resolved, or 347 /// indicates that the member did get resolved. FLAGS_ENUM(SymbolContextItem)348 FLAGS_ENUM(SymbolContextItem){ 349 /// Set when \a target is requested from a query, or was located 350 /// in query results 351 eSymbolContextTarget = (1u << 0), 352 /// Set when \a module is requested from a query, or was located 353 /// in query results 354 eSymbolContextModule = (1u << 1), 355 /// Set when \a comp_unit is requested from a query, or was 356 /// located in query results 357 eSymbolContextCompUnit = (1u << 2), 358 /// Set when \a function is requested from a query, or was located 359 /// in query results 360 eSymbolContextFunction = (1u << 3), 361 /// Set when the deepest \a block is requested from a query, or 362 /// was located in query results 363 eSymbolContextBlock = (1u << 4), 364 /// Set when \a line_entry is requested from a query, or was 365 /// located in query results 366 eSymbolContextLineEntry = (1u << 5), 367 /// Set when \a symbol is requested from a query, or was located 368 /// in query results 369 eSymbolContextSymbol = (1u << 6), 370 /// Indicates to try and lookup everything up during a routine 371 /// symbol context query. 372 eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1u), 373 /// Set when \a global or static variable is requested from a 374 /// query, or was located in query results. 375 /// eSymbolContextVariable is potentially expensive to lookup so 376 /// it isn't included in eSymbolContextEverything which stops it 377 /// from being used during frame PC lookups and many other 378 /// potential address to symbol context lookups. 379 eSymbolContextVariable = (1u << 7), 380 381 // Keep this last and up-to-date for what the last enum value is. 382 eSymbolContextLastItem = eSymbolContextVariable, 383 }; 384 LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem) 385 FLAGS_ENUM(Permissions)386 FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0), 387 ePermissionsReadable = (1u << 1), 388 ePermissionsExecutable = (1u << 2)}; 389 LLDB_MARK_AS_BITMASK_ENUM(Permissions) 390 391 enum InputReaderAction { 392 eInputReaderActivate, ///< reader is newly pushed onto the reader stack 393 eInputReaderAsynchronousOutputWritten, ///< an async output event occurred; 394 ///< the reader may want to do 395 ///< something 396 eInputReaderReactivate, ///< reader is on top of the stack again after another 397 ///< reader was popped off 398 eInputReaderDeactivate, ///< another reader was pushed on the stack 399 eInputReaderGotToken, ///< reader got one of its tokens (granularity) 400 eInputReaderInterrupt, ///< reader received an interrupt signal (probably from 401 ///< a control-c) 402 eInputReaderEndOfFile, ///< reader received an EOF char (probably from a 403 ///< control-d) 404 eInputReaderDone ///< reader was just popped off the stack and is done 405 }; 406 FLAGS_ENUM(BreakpointEventType)407 FLAGS_ENUM(BreakpointEventType){ 408 eBreakpointEventTypeInvalidType = (1u << 0), 409 eBreakpointEventTypeAdded = (1u << 1), 410 eBreakpointEventTypeRemoved = (1u << 2), 411 eBreakpointEventTypeLocationsAdded = (1u << 3), ///< Locations added doesn't 412 ///< get sent when the 413 ///< breakpoint is created 414 eBreakpointEventTypeLocationsRemoved = (1u << 4), 415 eBreakpointEventTypeLocationsResolved = (1u << 5), 416 eBreakpointEventTypeEnabled = (1u << 6), 417 eBreakpointEventTypeDisabled = (1u << 7), 418 eBreakpointEventTypeCommandChanged = (1u << 8), 419 eBreakpointEventTypeConditionChanged = (1u << 9), 420 eBreakpointEventTypeIgnoreChanged = (1u << 10), 421 eBreakpointEventTypeThreadChanged = (1u << 11), 422 eBreakpointEventTypeAutoContinueChanged = (1u << 12)}; 423 FLAGS_ENUM(WatchpointEventType)424 FLAGS_ENUM(WatchpointEventType){ 425 eWatchpointEventTypeInvalidType = (1u << 0), 426 eWatchpointEventTypeAdded = (1u << 1), 427 eWatchpointEventTypeRemoved = (1u << 2), 428 eWatchpointEventTypeEnabled = (1u << 6), 429 eWatchpointEventTypeDisabled = (1u << 7), 430 eWatchpointEventTypeCommandChanged = (1u << 8), 431 eWatchpointEventTypeConditionChanged = (1u << 9), 432 eWatchpointEventTypeIgnoreChanged = (1u << 10), 433 eWatchpointEventTypeThreadChanged = (1u << 11), 434 eWatchpointEventTypeTypeChanged = (1u << 12)}; 435 436 enum WatchpointWriteType { 437 /// Don't stop when the watched memory region is written to. 438 eWatchpointWriteTypeDisabled, 439 /// Stop on any write access to the memory region, even if 440 /// the value doesn't change. On some architectures, a write 441 /// near the memory region may be falsely reported as a match, 442 /// and notify this spurious stop as a watchpoint trap. 443 eWatchpointWriteTypeAlways, 444 /// Stop on a write to the memory region that changes its value. 445 /// This is most likely the behavior a user expects, and is the 446 /// behavior in gdb. lldb can silently ignore writes near the 447 /// watched memory region that are reported as accesses to lldb. 448 eWatchpointWriteTypeOnModify 449 }; 450 451 /// Programming language type. 452 /// 453 /// These enumerations use the same language enumerations as the DWARF 454 /// specification for ease of use and consistency. 455 /// The enum -> string code is in Language.cpp, don't change this 456 /// table without updating that code as well. 457 /// 458 /// This datatype is used in SBExpressionOptions::SetLanguage() which 459 /// makes this type API. Do not change its underlying storage type! 460 enum LanguageType { 461 eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value. 462 eLanguageTypeC89 = 0x0001, ///< ISO C:1989. 463 eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R. 464 eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983. 465 eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998. 466 eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974. 467 eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985. 468 eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77. 469 eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90. 470 eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983. 471 eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996. 472 eLanguageTypeJava = 0x000b, ///< Java. 473 eLanguageTypeC99 = 0x000c, ///< ISO C:1999. 474 eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995. 475 eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95. 476 eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976. 477 eLanguageTypeObjC = 0x0010, ///< Objective-C. 478 eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++. 479 eLanguageTypeUPC = 0x0012, ///< Unified Parallel C. 480 eLanguageTypeD = 0x0013, ///< D. 481 eLanguageTypePython = 0x0014, ///< Python. 482 // NOTE: The below are DWARF5 constants, subject to change upon 483 // completion of the DWARF5 specification 484 eLanguageTypeOpenCL = 0x0015, ///< OpenCL. 485 eLanguageTypeGo = 0x0016, ///< Go. 486 eLanguageTypeModula3 = 0x0017, ///< Modula 3. 487 eLanguageTypeHaskell = 0x0018, ///< Haskell. 488 eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003. 489 eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011. 490 eLanguageTypeOCaml = 0x001b, ///< OCaml. 491 eLanguageTypeRust = 0x001c, ///< Rust. 492 eLanguageTypeC11 = 0x001d, ///< ISO C:2011. 493 eLanguageTypeSwift = 0x001e, ///< Swift. 494 eLanguageTypeJulia = 0x001f, ///< Julia. 495 eLanguageTypeDylan = 0x0020, ///< Dylan. 496 eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014. 497 eLanguageTypeFortran03 = 0x0022, ///< ISO Fortran 2003. 498 eLanguageTypeFortran08 = 0x0023, ///< ISO Fortran 2008. 499 eLanguageTypeRenderScript = 0x0024, 500 eLanguageTypeBLISS = 0x0025, 501 eLanguageTypeKotlin = 0x0026, 502 eLanguageTypeZig = 0x0027, 503 eLanguageTypeCrystal = 0x0028, 504 eLanguageTypeC_plus_plus_17 = 0x002a, ///< ISO C++:2017. 505 eLanguageTypeC_plus_plus_20 = 0x002b, ///< ISO C++:2020. 506 eLanguageTypeC17 = 0x002c, 507 eLanguageTypeFortran18 = 0x002d, 508 eLanguageTypeAda2005 = 0x002e, 509 eLanguageTypeAda2012 = 0x002f, 510 eLanguageTypeHIP = 0x0030, 511 eLanguageTypeAssembly = 0x0031, 512 eLanguageTypeC_sharp = 0x0032, 513 eLanguageTypeMojo = 0x0033, 514 515 // Vendor Extensions 516 // Note: Language::GetNameForLanguageType 517 // assumes these can be used as indexes into array language_names, and 518 // Language::SetLanguageFromCString and Language::AsCString assume these can 519 // be used as indexes into array g_languages. 520 eLanguageTypeMipsAssembler, ///< Mips_Assembler. 521 // Mojo will move to the common list of languages once the DWARF committee 522 // creates a language code for it. 523 eNumLanguageTypes 524 }; 525 526 enum InstrumentationRuntimeType { 527 eInstrumentationRuntimeTypeAddressSanitizer = 0x0000, 528 eInstrumentationRuntimeTypeThreadSanitizer = 0x0001, 529 eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002, 530 eInstrumentationRuntimeTypeMainThreadChecker = 0x0003, 531 eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004, 532 eInstrumentationRuntimeTypeLibsanitizersAsan = 0x0005, 533 eNumInstrumentationRuntimeTypes 534 }; 535 536 enum DynamicValueType { 537 eNoDynamicValues = 0, 538 eDynamicCanRunTarget = 1, 539 eDynamicDontRunTarget = 2 540 }; 541 542 enum StopShowColumn { 543 eStopShowColumnAnsiOrCaret = 0, 544 eStopShowColumnAnsi = 1, 545 eStopShowColumnCaret = 2, 546 eStopShowColumnNone = 3 547 }; 548 549 enum AccessType { 550 eAccessNone, 551 eAccessPublic, 552 eAccessPrivate, 553 eAccessProtected, 554 eAccessPackage 555 }; 556 557 enum CommandArgumentType { 558 eArgTypeAddress = 0, 559 eArgTypeAddressOrExpression, 560 eArgTypeAliasName, 561 eArgTypeAliasOptions, 562 eArgTypeArchitecture, 563 eArgTypeBoolean, 564 eArgTypeBreakpointID, 565 eArgTypeBreakpointIDRange, 566 eArgTypeBreakpointName, 567 eArgTypeByteSize, 568 eArgTypeClassName, 569 eArgTypeCommandName, 570 eArgTypeCount, 571 eArgTypeDescriptionVerbosity, 572 eArgTypeDirectoryName, 573 eArgTypeDisassemblyFlavor, 574 eArgTypeEndAddress, 575 eArgTypeExpression, 576 eArgTypeExpressionPath, 577 eArgTypeExprFormat, 578 eArgTypeFileLineColumn, 579 eArgTypeFilename, 580 eArgTypeFormat, 581 eArgTypeFrameIndex, 582 eArgTypeFullName, 583 eArgTypeFunctionName, 584 eArgTypeFunctionOrSymbol, 585 eArgTypeGDBFormat, 586 eArgTypeHelpText, 587 eArgTypeIndex, 588 eArgTypeLanguage, 589 eArgTypeLineNum, 590 eArgTypeLogCategory, 591 eArgTypeLogChannel, 592 eArgTypeMethod, 593 eArgTypeName, 594 eArgTypeNewPathPrefix, 595 eArgTypeNumLines, 596 eArgTypeNumberPerLine, 597 eArgTypeOffset, 598 eArgTypeOldPathPrefix, 599 eArgTypeOneLiner, 600 eArgTypePath, 601 eArgTypePermissionsNumber, 602 eArgTypePermissionsString, 603 eArgTypePid, 604 eArgTypePlugin, 605 eArgTypeProcessName, 606 eArgTypePythonClass, 607 eArgTypePythonFunction, 608 eArgTypePythonScript, 609 eArgTypeQueueName, 610 eArgTypeRegisterName, 611 eArgTypeRegularExpression, 612 eArgTypeRunArgs, 613 eArgTypeRunMode, 614 eArgTypeScriptedCommandSynchronicity, 615 eArgTypeScriptLang, 616 eArgTypeSearchWord, 617 eArgTypeSelector, 618 eArgTypeSettingIndex, 619 eArgTypeSettingKey, 620 eArgTypeSettingPrefix, 621 eArgTypeSettingVariableName, 622 eArgTypeShlibName, 623 eArgTypeSourceFile, 624 eArgTypeSortOrder, 625 eArgTypeStartAddress, 626 eArgTypeSummaryString, 627 eArgTypeSymbol, 628 eArgTypeThreadID, 629 eArgTypeThreadIndex, 630 eArgTypeThreadName, 631 eArgTypeTypeName, 632 eArgTypeUnsignedInteger, 633 eArgTypeUnixSignal, 634 eArgTypeVarName, 635 eArgTypeValue, 636 eArgTypeWidth, 637 eArgTypeNone, 638 eArgTypePlatform, 639 eArgTypeWatchpointID, 640 eArgTypeWatchpointIDRange, 641 eArgTypeWatchType, 642 eArgRawInput, 643 eArgTypeCommand, 644 eArgTypeColumnNum, 645 eArgTypeModuleUUID, 646 eArgTypeSaveCoreStyle, 647 eArgTypeLogHandler, 648 eArgTypeSEDStylePair, 649 eArgTypeRecognizerID, 650 eArgTypeConnectURL, 651 eArgTypeTargetID, 652 eArgTypeStopHookID, 653 eArgTypeCompletionType, 654 eArgTypeRemotePath, 655 eArgTypeRemoteFilename, 656 eArgTypeModule, 657 eArgTypeLastArg // Always keep this entry as the last entry in this 658 // enumeration!! 659 }; 660 661 /// Symbol types. 662 // Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63 663 // entries you will have to resize that field. 664 enum SymbolType { 665 eSymbolTypeAny = 0, 666 eSymbolTypeInvalid = 0, 667 eSymbolTypeAbsolute, 668 eSymbolTypeCode, 669 eSymbolTypeResolver, 670 eSymbolTypeData, 671 eSymbolTypeTrampoline, 672 eSymbolTypeRuntime, 673 eSymbolTypeException, 674 eSymbolTypeSourceFile, 675 eSymbolTypeHeaderFile, 676 eSymbolTypeObjectFile, 677 eSymbolTypeCommonBlock, 678 eSymbolTypeBlock, 679 eSymbolTypeLocal, 680 eSymbolTypeParam, 681 eSymbolTypeVariable, 682 eSymbolTypeVariableType, 683 eSymbolTypeLineEntry, 684 eSymbolTypeLineHeader, 685 eSymbolTypeScopeBegin, 686 eSymbolTypeScopeEnd, 687 eSymbolTypeAdditional, ///< When symbols take more than one entry, the extra 688 ///< entries get this type 689 eSymbolTypeCompiler, 690 eSymbolTypeInstrumentation, 691 eSymbolTypeUndefined, 692 eSymbolTypeObjCClass, 693 eSymbolTypeObjCMetaClass, 694 eSymbolTypeObjCIVar, 695 eSymbolTypeReExported 696 }; 697 698 enum SectionType { 699 eSectionTypeInvalid, 700 eSectionTypeCode, 701 eSectionTypeContainer, ///< The section contains child sections 702 eSectionTypeData, 703 eSectionTypeDataCString, ///< Inlined C string data 704 eSectionTypeDataCStringPointers, ///< Pointers to C string data 705 eSectionTypeDataSymbolAddress, ///< Address of a symbol in the symbol table 706 eSectionTypeData4, 707 eSectionTypeData8, 708 eSectionTypeData16, 709 eSectionTypeDataPointers, 710 eSectionTypeDebug, 711 eSectionTypeZeroFill, 712 eSectionTypeDataObjCMessageRefs, ///< Pointer to function pointer + selector 713 eSectionTypeDataObjCCFStrings, ///< Objective-C const CFString/NSString 714 ///< objects 715 eSectionTypeDWARFDebugAbbrev, 716 eSectionTypeDWARFDebugAddr, 717 eSectionTypeDWARFDebugAranges, 718 eSectionTypeDWARFDebugCuIndex, 719 eSectionTypeDWARFDebugFrame, 720 eSectionTypeDWARFDebugInfo, 721 eSectionTypeDWARFDebugLine, 722 eSectionTypeDWARFDebugLoc, 723 eSectionTypeDWARFDebugMacInfo, 724 eSectionTypeDWARFDebugMacro, 725 eSectionTypeDWARFDebugPubNames, 726 eSectionTypeDWARFDebugPubTypes, 727 eSectionTypeDWARFDebugRanges, 728 eSectionTypeDWARFDebugStr, 729 eSectionTypeDWARFDebugStrOffsets, 730 eSectionTypeDWARFAppleNames, 731 eSectionTypeDWARFAppleTypes, 732 eSectionTypeDWARFAppleNamespaces, 733 eSectionTypeDWARFAppleObjC, 734 eSectionTypeELFSymbolTable, ///< Elf SHT_SYMTAB section 735 eSectionTypeELFDynamicSymbols, ///< Elf SHT_DYNSYM section 736 eSectionTypeELFRelocationEntries, ///< Elf SHT_REL or SHT_REL section 737 eSectionTypeELFDynamicLinkInfo, ///< Elf SHT_DYNAMIC section 738 eSectionTypeEHFrame, 739 eSectionTypeARMexidx, 740 eSectionTypeARMextab, 741 eSectionTypeCompactUnwind, ///< compact unwind section in Mach-O, 742 ///< __TEXT,__unwind_info 743 eSectionTypeGoSymtab, 744 eSectionTypeAbsoluteAddress, ///< Dummy section for symbols with absolute 745 ///< address 746 eSectionTypeDWARFGNUDebugAltLink, 747 eSectionTypeDWARFDebugTypes, ///< DWARF .debug_types section 748 eSectionTypeDWARFDebugNames, ///< DWARF v5 .debug_names 749 eSectionTypeOther, 750 eSectionTypeDWARFDebugLineStr, ///< DWARF v5 .debug_line_str 751 eSectionTypeDWARFDebugRngLists, ///< DWARF v5 .debug_rnglists 752 eSectionTypeDWARFDebugLocLists, ///< DWARF v5 .debug_loclists 753 eSectionTypeDWARFDebugAbbrevDwo, 754 eSectionTypeDWARFDebugInfoDwo, 755 eSectionTypeDWARFDebugStrDwo, 756 eSectionTypeDWARFDebugStrOffsetsDwo, 757 eSectionTypeDWARFDebugTypesDwo, 758 eSectionTypeDWARFDebugRngListsDwo, 759 eSectionTypeDWARFDebugLocDwo, 760 eSectionTypeDWARFDebugLocListsDwo, 761 eSectionTypeDWARFDebugTuIndex, 762 eSectionTypeCTF, 763 eSectionTypeSwiftModules, 764 }; 765 FLAGS_ENUM(EmulateInstructionOptions)766 FLAGS_ENUM(EmulateInstructionOptions){ 767 eEmulateInstructionOptionNone = (0u), 768 eEmulateInstructionOptionAutoAdvancePC = (1u << 0), 769 eEmulateInstructionOptionIgnoreConditions = (1u << 1)}; 770 FLAGS_ENUM(FunctionNameType)771 FLAGS_ENUM(FunctionNameType){ 772 eFunctionNameTypeNone = 0u, 773 eFunctionNameTypeAuto = 774 (1u << 1), ///< Automatically figure out which FunctionNameType 775 ///< bits to set based on the function name. 776 eFunctionNameTypeFull = (1u << 2), ///< The function name. 777 ///< For C this is the same as just the name of the function For C++ this is 778 ///< the mangled or demangled version of the mangled name. For ObjC this is 779 ///< the full function signature with the + or - and the square brackets and 780 ///< the class and selector 781 eFunctionNameTypeBase = (1u 782 << 3), ///< The function name only, no namespaces 783 ///< or arguments and no class 784 ///< methods or selectors will be searched. 785 eFunctionNameTypeMethod = (1u << 4), ///< Find function by method name (C++) 786 ///< with no namespace or arguments 787 eFunctionNameTypeSelector = 788 (1u << 5), ///< Find function by selector name (ObjC) names 789 eFunctionNameTypeAny = 790 eFunctionNameTypeAuto ///< DEPRECATED: use eFunctionNameTypeAuto 791 }; 792 LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType) 793 794 /// Basic types enumeration for the public API SBType::GetBasicType(). 795 enum BasicType { 796 eBasicTypeInvalid = 0, 797 eBasicTypeVoid = 1, 798 eBasicTypeChar, 799 eBasicTypeSignedChar, 800 eBasicTypeUnsignedChar, 801 eBasicTypeWChar, 802 eBasicTypeSignedWChar, 803 eBasicTypeUnsignedWChar, 804 eBasicTypeChar16, 805 eBasicTypeChar32, 806 eBasicTypeChar8, 807 eBasicTypeShort, 808 eBasicTypeUnsignedShort, 809 eBasicTypeInt, 810 eBasicTypeUnsignedInt, 811 eBasicTypeLong, 812 eBasicTypeUnsignedLong, 813 eBasicTypeLongLong, 814 eBasicTypeUnsignedLongLong, 815 eBasicTypeInt128, 816 eBasicTypeUnsignedInt128, 817 eBasicTypeBool, 818 eBasicTypeHalf, 819 eBasicTypeFloat, 820 eBasicTypeDouble, 821 eBasicTypeLongDouble, 822 eBasicTypeFloatComplex, 823 eBasicTypeDoubleComplex, 824 eBasicTypeLongDoubleComplex, 825 eBasicTypeObjCID, 826 eBasicTypeObjCClass, 827 eBasicTypeObjCSel, 828 eBasicTypeNullPtr, 829 eBasicTypeOther 830 }; 831 832 /// Deprecated 833 enum TraceType { 834 eTraceTypeNone = 0, 835 836 /// Intel Processor Trace 837 eTraceTypeProcessorTrace 838 }; 839 840 enum StructuredDataType { 841 eStructuredDataTypeInvalid = -1, 842 eStructuredDataTypeNull = 0, 843 eStructuredDataTypeGeneric, 844 eStructuredDataTypeArray, 845 eStructuredDataTypeInteger, 846 eStructuredDataTypeFloat, 847 eStructuredDataTypeBoolean, 848 eStructuredDataTypeString, 849 eStructuredDataTypeDictionary, 850 eStructuredDataTypeSignedInteger, 851 eStructuredDataTypeUnsignedInteger = eStructuredDataTypeInteger, 852 }; 853 FLAGS_ENUM(TypeClass)854 FLAGS_ENUM(TypeClass){ 855 eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0), 856 eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2), 857 eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4), 858 eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6), 859 eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8), 860 eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10), 861 eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12), 862 eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14), 863 eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16), 864 eTypeClassVector = (1u << 17), 865 // Define the last type class as the MSBit of a 32 bit value 866 eTypeClassOther = (1u << 31), 867 // Define a mask that can be used for any type when finding types 868 eTypeClassAny = (0xffffffffu)}; 869 LLDB_MARK_AS_BITMASK_ENUM(TypeClass) 870 871 enum TemplateArgumentKind { 872 eTemplateArgumentKindNull = 0, 873 eTemplateArgumentKindType, 874 eTemplateArgumentKindDeclaration, 875 eTemplateArgumentKindIntegral, 876 eTemplateArgumentKindTemplate, 877 eTemplateArgumentKindTemplateExpansion, 878 eTemplateArgumentKindExpression, 879 eTemplateArgumentKindPack, 880 eTemplateArgumentKindNullPtr, 881 eTemplateArgumentKindStructuralValue, 882 }; 883 884 /// Type of match to be performed when looking for a formatter for a data type. 885 /// Used by classes like SBTypeNameSpecifier or lldb_private::TypeMatcher. 886 enum FormatterMatchType { 887 eFormatterMatchExact, 888 eFormatterMatchRegex, 889 eFormatterMatchCallback, 890 891 eLastFormatterMatchType = eFormatterMatchCallback, 892 }; 893 894 /// Options that can be set for a formatter to alter its behavior. Not 895 /// all of these are applicable to all formatter types. FLAGS_ENUM(TypeOptions)896 FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u), 897 eTypeOptionCascade = (1u << 0), 898 eTypeOptionSkipPointers = (1u << 1), 899 eTypeOptionSkipReferences = (1u << 2), 900 eTypeOptionHideChildren = (1u << 3), 901 eTypeOptionHideValue = (1u << 4), 902 eTypeOptionShowOneLiner = (1u << 5), 903 eTypeOptionHideNames = (1u << 6), 904 eTypeOptionNonCacheable = (1u << 7), 905 eTypeOptionHideEmptyAggregates = (1u << 8), 906 eTypeOptionFrontEndWantsDereference = (1u << 9)}; 907 908 /// This is the return value for frame comparisons. If you are comparing frame 909 /// A to frame B the following cases arise: 910 /// 911 /// 1) When frame A pushes frame B (or a frame that ends up pushing 912 /// B) A is Older than B. 913 /// 914 /// 2) When frame A pushed frame B (or if frameA is on the stack 915 /// but B is not) A is Younger than B. 916 /// 917 /// 3) When frame A and frame B have the same StackID, they are 918 /// Equal. 919 /// 920 /// 4) When frame A and frame B have the same immediate parent 921 /// frame, but are not equal, the comparison yields SameParent. 922 /// 923 /// 5) If the two frames are on different threads or processes the 924 /// comparison is Invalid. 925 /// 926 /// 6) If for some reason we can't figure out what went on, we 927 /// return Unknown. 928 enum FrameComparison { 929 eFrameCompareInvalid, 930 eFrameCompareUnknown, 931 eFrameCompareEqual, 932 eFrameCompareSameParent, 933 eFrameCompareYounger, 934 eFrameCompareOlder 935 }; 936 937 /// File Permissions. 938 /// 939 /// Designed to mimic the unix file permission bits so they can be used with 940 /// functions that set 'mode_t' to certain values for permissions. FLAGS_ENUM(FilePermissions)941 FLAGS_ENUM(FilePermissions){ 942 eFilePermissionsUserRead = (1u << 8), 943 eFilePermissionsUserWrite = (1u << 7), 944 eFilePermissionsUserExecute = (1u << 6), 945 eFilePermissionsGroupRead = (1u << 5), 946 eFilePermissionsGroupWrite = (1u << 4), 947 eFilePermissionsGroupExecute = (1u << 3), 948 eFilePermissionsWorldRead = (1u << 2), 949 eFilePermissionsWorldWrite = (1u << 1), 950 eFilePermissionsWorldExecute = (1u << 0), 951 952 eFilePermissionsUserRW = (eFilePermissionsUserRead | 953 eFilePermissionsUserWrite | 0), 954 eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 | 955 eFilePermissionsUserExecute), 956 eFilePermissionsUserRWX = (eFilePermissionsUserRead | 957 eFilePermissionsUserWrite | 958 eFilePermissionsUserExecute), 959 960 eFilePermissionsGroupRW = (eFilePermissionsGroupRead | 961 eFilePermissionsGroupWrite | 0), 962 eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 | 963 eFilePermissionsGroupExecute), 964 eFilePermissionsGroupRWX = (eFilePermissionsGroupRead | 965 eFilePermissionsGroupWrite | 966 eFilePermissionsGroupExecute), 967 968 eFilePermissionsWorldRW = (eFilePermissionsWorldRead | 969 eFilePermissionsWorldWrite | 0), 970 eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 | 971 eFilePermissionsWorldExecute), 972 eFilePermissionsWorldRWX = (eFilePermissionsWorldRead | 973 eFilePermissionsWorldWrite | 974 eFilePermissionsWorldExecute), 975 976 eFilePermissionsEveryoneR = (eFilePermissionsUserRead | 977 eFilePermissionsGroupRead | 978 eFilePermissionsWorldRead), 979 eFilePermissionsEveryoneW = (eFilePermissionsUserWrite | 980 eFilePermissionsGroupWrite | 981 eFilePermissionsWorldWrite), 982 eFilePermissionsEveryoneX = (eFilePermissionsUserExecute | 983 eFilePermissionsGroupExecute | 984 eFilePermissionsWorldExecute), 985 986 eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR | 987 eFilePermissionsEveryoneW | 0), 988 eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 | 989 eFilePermissionsEveryoneX), 990 eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR | 991 eFilePermissionsEveryoneW | 992 eFilePermissionsEveryoneX), 993 eFilePermissionsFileDefault = eFilePermissionsUserRW, 994 eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX, 995 }; 996 997 /// Queue work item types. 998 /// 999 /// The different types of work that can be enqueued on a libdispatch aka Grand 1000 /// Central Dispatch (GCD) queue. 1001 enum QueueItemKind { 1002 eQueueItemKindUnknown = 0, 1003 eQueueItemKindFunction, 1004 eQueueItemKindBlock 1005 }; 1006 1007 /// Queue type. 1008 /// 1009 /// libdispatch aka Grand Central Dispatch (GCD) queues can be either 1010 /// serial (executing on one thread) or concurrent (executing on 1011 /// multiple threads). 1012 enum QueueKind { 1013 eQueueKindUnknown = 0, 1014 eQueueKindSerial, 1015 eQueueKindConcurrent 1016 }; 1017 1018 /// Expression Evaluation Stages. 1019 /// 1020 /// These are the cancellable stages of expression evaluation, passed 1021 /// to the expression evaluation callback, so that you can interrupt 1022 /// expression evaluation at the various points in its lifecycle. 1023 enum ExpressionEvaluationPhase { 1024 eExpressionEvaluationParse = 0, 1025 eExpressionEvaluationIRGen, 1026 eExpressionEvaluationExecution, 1027 eExpressionEvaluationComplete 1028 }; 1029 1030 /// Architecture-agnostic categorization of instructions for traversing the 1031 /// control flow of a trace. 1032 /// 1033 /// A single instruction can match one or more of these categories. 1034 enum InstructionControlFlowKind { 1035 /// The instruction could not be classified. 1036 eInstructionControlFlowKindUnknown = 0, 1037 /// The instruction is something not listed below, i.e. it's a sequential 1038 /// instruction that doesn't affect the control flow of the program. 1039 eInstructionControlFlowKindOther, 1040 /// The instruction is a near (function) call. 1041 eInstructionControlFlowKindCall, 1042 /// The instruction is a near (function) return. 1043 eInstructionControlFlowKindReturn, 1044 /// The instruction is a near unconditional jump. 1045 eInstructionControlFlowKindJump, 1046 /// The instruction is a near conditional jump. 1047 eInstructionControlFlowKindCondJump, 1048 /// The instruction is a call-like far transfer. 1049 /// E.g. SYSCALL, SYSENTER, or FAR CALL. 1050 eInstructionControlFlowKindFarCall, 1051 /// The instruction is a return-like far transfer. 1052 /// E.g. SYSRET, SYSEXIT, IRET, or FAR RET. 1053 eInstructionControlFlowKindFarReturn, 1054 /// The instruction is a jump-like far transfer. 1055 /// E.g. FAR JMP. 1056 eInstructionControlFlowKindFarJump 1057 }; 1058 1059 /// Watchpoint Kind. 1060 /// 1061 /// Indicates what types of events cause the watchpoint to fire. Used by Native 1062 /// *Protocol-related classes. FLAGS_ENUM(WatchpointKind)1063 FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0), 1064 eWatchpointKindRead = (1u << 1)}; 1065 1066 enum GdbSignal { 1067 eGdbSignalBadAccess = 0x91, 1068 eGdbSignalBadInstruction = 0x92, 1069 eGdbSignalArithmetic = 0x93, 1070 eGdbSignalEmulation = 0x94, 1071 eGdbSignalSoftware = 0x95, 1072 eGdbSignalBreakpoint = 0x96 1073 }; 1074 1075 /// Used with SBHostOS::GetLLDBPath (lldb::PathType) to find files that are 1076 /// related to LLDB on the current host machine. Most files are 1077 /// relative to LLDB or are in known locations. 1078 enum PathType { 1079 ePathTypeLLDBShlibDir, ///< The directory where the lldb.so (unix) or LLDB 1080 ///< mach-o file in LLDB.framework (MacOSX) exists 1081 ePathTypeSupportExecutableDir, ///< Find LLDB support executable directory 1082 ///< (debugserver, etc) 1083 ePathTypeHeaderDir, ///< Find LLDB header file directory 1084 ePathTypePythonDir, ///< Find Python modules (PYTHONPATH) directory 1085 ePathTypeLLDBSystemPlugins, ///< System plug-ins directory 1086 ePathTypeLLDBUserPlugins, ///< User plug-ins directory 1087 ePathTypeLLDBTempSystemDir, ///< The LLDB temp directory for this system that 1088 ///< will be cleaned up on exit 1089 ePathTypeGlobalLLDBTempSystemDir, ///< The LLDB temp directory for this 1090 ///< system, NOT cleaned up on a process 1091 ///< exit. 1092 ePathTypeClangDir ///< Find path to Clang builtin headers 1093 }; 1094 1095 /// Kind of member function. 1096 /// 1097 /// Used by the type system. 1098 enum MemberFunctionKind { 1099 eMemberFunctionKindUnknown = 0, ///< Not sure what the type of this is 1100 eMemberFunctionKindConstructor, ///< A function used to create instances 1101 eMemberFunctionKindDestructor, ///< A function used to tear down existing 1102 ///< instances 1103 eMemberFunctionKindInstanceMethod, ///< A function that applies to a specific 1104 ///< instance 1105 eMemberFunctionKindStaticMethod ///< A function that applies to a type rather 1106 ///< than any instance 1107 }; 1108 1109 /// String matching algorithm used by SBTarget. 1110 enum MatchType { 1111 eMatchTypeNormal, 1112 eMatchTypeRegex, 1113 eMatchTypeStartsWith, 1114 eMatchTypeRegexInsensitive 1115 }; 1116 1117 /// Bitmask that describes details about a type. FLAGS_ENUM(TypeFlags)1118 FLAGS_ENUM(TypeFlags){ 1119 eTypeHasChildren = (1u << 0), eTypeHasValue = (1u << 1), 1120 eTypeIsArray = (1u << 2), eTypeIsBlock = (1u << 3), 1121 eTypeIsBuiltIn = (1u << 4), eTypeIsClass = (1u << 5), 1122 eTypeIsCPlusPlus = (1u << 6), eTypeIsEnumeration = (1u << 7), 1123 eTypeIsFuncPrototype = (1u << 8), eTypeIsMember = (1u << 9), 1124 eTypeIsObjC = (1u << 10), eTypeIsPointer = (1u << 11), 1125 eTypeIsReference = (1u << 12), eTypeIsStructUnion = (1u << 13), 1126 eTypeIsTemplate = (1u << 14), eTypeIsTypedef = (1u << 15), 1127 eTypeIsVector = (1u << 16), eTypeIsScalar = (1u << 17), 1128 eTypeIsInteger = (1u << 18), eTypeIsFloat = (1u << 19), 1129 eTypeIsComplex = (1u << 20), eTypeIsSigned = (1u << 21), 1130 eTypeInstanceIsPointer = (1u << 22)}; 1131 FLAGS_ENUM(CommandFlags)1132 FLAGS_ENUM(CommandFlags){ 1133 /// eCommandRequiresTarget 1134 /// 1135 /// Ensures a valid target is contained in m_exe_ctx prior to executing the 1136 /// command. If a target doesn't exist or is invalid, the command will fail 1137 /// and CommandObject::GetInvalidTargetDescription() will be returned as the 1138 /// error. CommandObject subclasses can override the virtual function for 1139 /// GetInvalidTargetDescription() to provide custom strings when needed. 1140 eCommandRequiresTarget = (1u << 0), 1141 /// eCommandRequiresProcess 1142 /// 1143 /// Ensures a valid process is contained in m_exe_ctx prior to executing the 1144 /// command. If a process doesn't exist or is invalid, the command will fail 1145 /// and CommandObject::GetInvalidProcessDescription() will be returned as 1146 /// the error. CommandObject subclasses can override the virtual function 1147 /// for GetInvalidProcessDescription() to provide custom strings when 1148 /// needed. 1149 eCommandRequiresProcess = (1u << 1), 1150 /// eCommandRequiresThread 1151 /// 1152 /// Ensures a valid thread is contained in m_exe_ctx prior to executing the 1153 /// command. If a thread doesn't exist or is invalid, the command will fail 1154 /// and CommandObject::GetInvalidThreadDescription() will be returned as the 1155 /// error. CommandObject subclasses can override the virtual function for 1156 /// GetInvalidThreadDescription() to provide custom strings when needed. 1157 eCommandRequiresThread = (1u << 2), 1158 /// eCommandRequiresFrame 1159 /// 1160 /// Ensures a valid frame is contained in m_exe_ctx prior to executing the 1161 /// command. If a frame doesn't exist or is invalid, the command will fail 1162 /// and CommandObject::GetInvalidFrameDescription() will be returned as the 1163 /// error. CommandObject subclasses can override the virtual function for 1164 /// GetInvalidFrameDescription() to provide custom strings when needed. 1165 eCommandRequiresFrame = (1u << 3), 1166 /// eCommandRequiresRegContext 1167 /// 1168 /// Ensures a valid register context (from the selected frame if there is a 1169 /// frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is 1170 /// available from m_exe_ctx prior to executing the command. If a target 1171 /// doesn't exist or is invalid, the command will fail and 1172 /// CommandObject::GetInvalidRegContextDescription() will be returned as the 1173 /// error. CommandObject subclasses can override the virtual function for 1174 /// GetInvalidRegContextDescription() to provide custom strings when needed. 1175 eCommandRequiresRegContext = (1u << 4), 1176 /// eCommandTryTargetAPILock 1177 /// 1178 /// Attempts to acquire the target lock if a target is selected in the 1179 /// command interpreter. If the command object fails to acquire the API 1180 /// lock, the command will fail with an appropriate error message. 1181 eCommandTryTargetAPILock = (1u << 5), 1182 /// eCommandProcessMustBeLaunched 1183 /// 1184 /// Verifies that there is a launched process in m_exe_ctx, if there isn't, 1185 /// the command will fail with an appropriate error message. 1186 eCommandProcessMustBeLaunched = (1u << 6), 1187 /// eCommandProcessMustBePaused 1188 /// 1189 /// Verifies that there is a paused process in m_exe_ctx, if there isn't, 1190 /// the command will fail with an appropriate error message. 1191 eCommandProcessMustBePaused = (1u << 7), 1192 /// eCommandProcessMustBeTraced 1193 /// 1194 /// Verifies that the process is being traced by a Trace plug-in, if it 1195 /// isn't the command will fail with an appropriate error message. 1196 eCommandProcessMustBeTraced = (1u << 8)}; 1197 1198 /// Whether a summary should cap how much data it returns to users or not. 1199 enum TypeSummaryCapping { 1200 eTypeSummaryCapped = true, 1201 eTypeSummaryUncapped = false 1202 }; 1203 1204 /// The result from a command interpreter run. 1205 enum CommandInterpreterResult { 1206 /// Command interpreter finished successfully. 1207 eCommandInterpreterResultSuccess, 1208 /// Stopped because the corresponding option was set and the inferior 1209 /// crashed. 1210 eCommandInterpreterResultInferiorCrash, 1211 /// Stopped because the corresponding option was set and a command returned 1212 /// an error. 1213 eCommandInterpreterResultCommandError, 1214 /// Stopped because quit was requested. 1215 eCommandInterpreterResultQuitRequested, 1216 }; 1217 1218 // Style of core file to create when calling SaveCore. 1219 enum SaveCoreStyle { 1220 eSaveCoreUnspecified = 0, 1221 eSaveCoreFull = 1, 1222 eSaveCoreDirtyOnly = 2, 1223 eSaveCoreStackOnly = 3, 1224 }; 1225 1226 /// Events that might happen during a trace session. 1227 enum TraceEvent { 1228 /// Tracing was disabled for some time due to a software trigger. 1229 eTraceEventDisabledSW, 1230 /// Tracing was disable for some time due to a hardware trigger. 1231 eTraceEventDisabledHW, 1232 /// Event due to CPU change for a thread. This event is also fired when 1233 /// suddenly it's not possible to identify the cpu of a given thread. 1234 eTraceEventCPUChanged, 1235 /// Event due to a CPU HW clock tick. 1236 eTraceEventHWClockTick, 1237 /// The underlying tracing technology emitted a synchronization event used by 1238 /// trace processors. 1239 eTraceEventSyncPoint, 1240 }; 1241 1242 // Enum used to identify which kind of item a \a TraceCursor is pointing at 1243 enum TraceItemKind { 1244 eTraceItemKindError = 0, 1245 eTraceItemKindEvent, 1246 eTraceItemKindInstruction, 1247 }; 1248 1249 /// Enum to indicate the reference point when invoking 1250 /// \a TraceCursor::Seek(). 1251 /// The following values are inspired by \a std::istream::seekg. 1252 enum TraceCursorSeekType { 1253 /// The beginning of the trace, i.e the oldest item. 1254 eTraceCursorSeekTypeBeginning = 0, 1255 /// The current position in the trace. 1256 eTraceCursorSeekTypeCurrent, 1257 /// The end of the trace, i.e the most recent item. 1258 eTraceCursorSeekTypeEnd 1259 }; 1260 1261 /// Enum to control the verbosity level of `dwim-print` execution. 1262 enum DWIMPrintVerbosity { 1263 /// Run `dwim-print` with no verbosity. 1264 eDWIMPrintVerbosityNone, 1265 /// Print a message when `dwim-print` uses `expression` evaluation. 1266 eDWIMPrintVerbosityExpression, 1267 /// Always print a message indicating how `dwim-print` is evaluating its 1268 /// expression. 1269 eDWIMPrintVerbosityFull, 1270 }; 1271 1272 enum WatchpointValueKind { 1273 eWatchPointValueKindInvalid = 0, 1274 ///< Watchpoint was created watching a variable 1275 eWatchPointValueKindVariable = 1, 1276 ///< Watchpoint was created watching the result of an expression that was 1277 ///< evaluated at creation time. 1278 eWatchPointValueKindExpression = 2, 1279 }; 1280 1281 enum CompletionType { 1282 eNoCompletion = 0ul, 1283 eSourceFileCompletion = (1ul << 0), 1284 eDiskFileCompletion = (1ul << 1), 1285 eDiskDirectoryCompletion = (1ul << 2), 1286 eSymbolCompletion = (1ul << 3), 1287 eModuleCompletion = (1ul << 4), 1288 eSettingsNameCompletion = (1ul << 5), 1289 ePlatformPluginCompletion = (1ul << 6), 1290 eArchitectureCompletion = (1ul << 7), 1291 eVariablePathCompletion = (1ul << 8), 1292 eRegisterCompletion = (1ul << 9), 1293 eBreakpointCompletion = (1ul << 10), 1294 eProcessPluginCompletion = (1ul << 11), 1295 eDisassemblyFlavorCompletion = (1ul << 12), 1296 eTypeLanguageCompletion = (1ul << 13), 1297 eFrameIndexCompletion = (1ul << 14), 1298 eModuleUUIDCompletion = (1ul << 15), 1299 eStopHookIDCompletion = (1ul << 16), 1300 eThreadIndexCompletion = (1ul << 17), 1301 eWatchpointIDCompletion = (1ul << 18), 1302 eBreakpointNameCompletion = (1ul << 19), 1303 eProcessIDCompletion = (1ul << 20), 1304 eProcessNameCompletion = (1ul << 21), 1305 eRemoteDiskFileCompletion = (1ul << 22), 1306 eRemoteDiskDirectoryCompletion = (1ul << 23), 1307 eTypeCategoryNameCompletion = (1ul << 24), 1308 eCustomCompletion = (1ul << 25), 1309 eThreadIDCompletion = (1ul << 26), 1310 // This last enum element is just for input validation. 1311 // Add new completions before this element, 1312 // and then increment eTerminatorCompletion's shift value 1313 eTerminatorCompletion = (1ul << 27) 1314 }; 1315 1316 /// Specifies if children need to be re-computed 1317 /// after a call to \ref SyntheticChildrenFrontEnd::Update. 1318 enum ChildCacheState { 1319 eRefetch = 0, ///< Children need to be recomputed dynamically. 1320 1321 eReuse = 1, ///< Children did not change and don't need to be recomputed; 1322 ///< re-use what we computed the last time we called Update. 1323 }; 1324 1325 enum SymbolDownload { 1326 eSymbolDownloadOff = 0, 1327 eSymbolDownloadBackground = 1, 1328 eSymbolDownloadForeground = 2, 1329 }; 1330 1331 /// Used in the SBProcess AddressMask/FixAddress methods. 1332 enum AddressMaskType { 1333 eAddressMaskTypeCode = 0, 1334 eAddressMaskTypeData, 1335 eAddressMaskTypeAny, 1336 eAddressMaskTypeAll = eAddressMaskTypeAny 1337 }; 1338 1339 /// Used in the SBProcess AddressMask/FixAddress methods. 1340 enum AddressMaskRange { 1341 eAddressMaskRangeLow = 0, 1342 eAddressMaskRangeHigh, 1343 eAddressMaskRangeAny, 1344 eAddressMaskRangeAll = eAddressMaskRangeAny, 1345 }; 1346 1347 /// Used by the debugger to indicate which events are being broadcasted. 1348 enum DebuggerBroadcastBit { 1349 eBroadcastBitProgress = (1 << 0), 1350 eBroadcastBitWarning = (1 << 1), 1351 eBroadcastBitError = (1 << 2), 1352 eBroadcastSymbolChange = (1 << 3), 1353 eBroadcastBitProgressCategory = (1 << 4), 1354 }; 1355 1356 /// Used for expressing severity in logs and diagnostics. 1357 enum Severity { 1358 eSeverityError, 1359 eSeverityWarning, 1360 eSeverityInfo, // Equivalent to Remark used in clang. 1361 }; 1362 1363 } // namespace lldb 1364 1365 #endif // LLDB_LLDB_ENUMERATIONS_H 1366