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