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
71namespace lldb {
72
73/// Process and Thread States.
74enum 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.
99FLAGS_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.
136enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
137
138/// Byte ordering definitions.
139enum ByteOrder {
140 eByteOrderInvalid = 0,
141 eByteOrderBig = 1,
142 eByteOrderPDP = 2,
143 eByteOrderLittle = 4
144};
145
146/// Register encoding definitions.
147enum 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.
156enum 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.
208enum DescriptionLevel {
209 eDescriptionLevelBrief = 0,
210 eDescriptionLevelFull,
211 eDescriptionLevelVerbose,
212 eDescriptionLevelInitial,
213 kNumDescriptionLevels
214};
215
216/// Script interpreter types.
217enum ScriptLanguage {
218 eScriptLanguageNone = 0,
219 eScriptLanguagePython,
220 eScriptLanguageLua,
221 eScriptLanguageUnknown,
222 eScriptLanguageDefault = eScriptLanguagePython
223};
224
225/// Register numbering types.
226// See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
227// these to the lldb internal register numbering scheme (eRegisterKindLLDB).
228enum 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.
240enum 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.
259enum 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.
271enum ExpressionResults {
272 eExpressionCompleted = 0,
273 eExpressionSetupError,
274 eExpressionParseError,
275 eExpressionDiscarded,
276 eExpressionInterrupted,
277 eExpressionHitBreakpoint,
278 eExpressionTimedOut,
279 eExpressionResultUnavailable,
280 eExpressionStoppedForDebug,
281 eExpressionThreadVanished
282};
283
284enum 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.
296enum 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
307enum 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
316enum 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
332enum 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.
348FLAGS_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};
384LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)
385
386FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
387 ePermissionsReadable = (1u << 1),
388 ePermissionsExecutable = (1u << 2)};
389LLDB_MARK_AS_BITMASK_ENUM(Permissions)
390
391enum 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
407FLAGS_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
424FLAGS_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
436enum 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!
460enum 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
526enum InstrumentationRuntimeType {
527 eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
528 eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
529 eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
530 eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,
531 eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004,
532 eInstrumentationRuntimeTypeLibsanitizersAsan = 0x0005,
533 eNumInstrumentationRuntimeTypes
534};
535
536enum DynamicValueType {
537 eNoDynamicValues = 0,
538 eDynamicCanRunTarget = 1,
539 eDynamicDontRunTarget = 2
540};
541
542enum StopShowColumn {
543 eStopShowColumnAnsiOrCaret = 0,
544 eStopShowColumnAnsi = 1,
545 eStopShowColumnCaret = 2,
546 eStopShowColumnNone = 3
547};
548
549enum AccessType {
550 eAccessNone,
551 eAccessPublic,
552 eAccessPrivate,
553 eAccessProtected,
554 eAccessPackage
555};
556
557enum 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.
664enum 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
698enum 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
766FLAGS_ENUM(EmulateInstructionOptions){
767 eEmulateInstructionOptionNone = (0u),
768 eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
769 eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
770
771FLAGS_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};
792LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
793
794/// Basic types enumeration for the public API SBType::GetBasicType().
795enum 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
833enum TraceType {
834 eTraceTypeNone = 0,
835
836 /// Intel Processor Trace
837 eTraceTypeProcessorTrace
838};
839
840enum 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
854FLAGS_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)};
869LLDB_MARK_AS_BITMASK_ENUM(TypeClass)
870
871enum 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.
886enum 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.
896FLAGS_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.
928enum 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.
941FLAGS_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.
1001enum 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).
1012enum 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.
1023enum 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.
1034enum 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.
1063FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0),
1064 eWatchpointKindRead = (1u << 1)};
1065
1066enum 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.
1078enum 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.
1098enum 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.
1110enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };
1111
1112/// Bitmask that describes details about a type.
1113FLAGS_ENUM(TypeFlags){
1114 eTypeHasChildren = (1u << 0), eTypeHasValue = (1u << 1),
1115 eTypeIsArray = (1u << 2), eTypeIsBlock = (1u << 3),
1116 eTypeIsBuiltIn = (1u << 4), eTypeIsClass = (1u << 5),
1117 eTypeIsCPlusPlus = (1u << 6), eTypeIsEnumeration = (1u << 7),
1118 eTypeIsFuncPrototype = (1u << 8), eTypeIsMember = (1u << 9),
1119 eTypeIsObjC = (1u << 10), eTypeIsPointer = (1u << 11),
1120 eTypeIsReference = (1u << 12), eTypeIsStructUnion = (1u << 13),
1121 eTypeIsTemplate = (1u << 14), eTypeIsTypedef = (1u << 15),
1122 eTypeIsVector = (1u << 16), eTypeIsScalar = (1u << 17),
1123 eTypeIsInteger = (1u << 18), eTypeIsFloat = (1u << 19),
1124 eTypeIsComplex = (1u << 20), eTypeIsSigned = (1u << 21),
1125 eTypeInstanceIsPointer = (1u << 22)};
1126
1127FLAGS_ENUM(CommandFlags){
1128 /// eCommandRequiresTarget
1129 ///
1130 /// Ensures a valid target is contained in m_exe_ctx prior to executing the
1131 /// command. If a target doesn't exist or is invalid, the command will fail
1132 /// and CommandObject::GetInvalidTargetDescription() will be returned as the
1133 /// error. CommandObject subclasses can override the virtual function for
1134 /// GetInvalidTargetDescription() to provide custom strings when needed.
1135 eCommandRequiresTarget = (1u << 0),
1136 /// eCommandRequiresProcess
1137 ///
1138 /// Ensures a valid process is contained in m_exe_ctx prior to executing the
1139 /// command. If a process doesn't exist or is invalid, the command will fail
1140 /// and CommandObject::GetInvalidProcessDescription() will be returned as
1141 /// the error. CommandObject subclasses can override the virtual function
1142 /// for GetInvalidProcessDescription() to provide custom strings when
1143 /// needed.
1144 eCommandRequiresProcess = (1u << 1),
1145 /// eCommandRequiresThread
1146 ///
1147 /// Ensures a valid thread is contained in m_exe_ctx prior to executing the
1148 /// command. If a thread doesn't exist or is invalid, the command will fail
1149 /// and CommandObject::GetInvalidThreadDescription() will be returned as the
1150 /// error. CommandObject subclasses can override the virtual function for
1151 /// GetInvalidThreadDescription() to provide custom strings when needed.
1152 eCommandRequiresThread = (1u << 2),
1153 /// eCommandRequiresFrame
1154 ///
1155 /// Ensures a valid frame is contained in m_exe_ctx prior to executing the
1156 /// command. If a frame doesn't exist or is invalid, the command will fail
1157 /// and CommandObject::GetInvalidFrameDescription() will be returned as the
1158 /// error. CommandObject subclasses can override the virtual function for
1159 /// GetInvalidFrameDescription() to provide custom strings when needed.
1160 eCommandRequiresFrame = (1u << 3),
1161 /// eCommandRequiresRegContext
1162 ///
1163 /// Ensures a valid register context (from the selected frame if there is a
1164 /// frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
1165 /// available from m_exe_ctx prior to executing the command. If a target
1166 /// doesn't exist or is invalid, the command will fail and
1167 /// CommandObject::GetInvalidRegContextDescription() will be returned as the
1168 /// error. CommandObject subclasses can override the virtual function for
1169 /// GetInvalidRegContextDescription() to provide custom strings when needed.
1170 eCommandRequiresRegContext = (1u << 4),
1171 /// eCommandTryTargetAPILock
1172 ///
1173 /// Attempts to acquire the target lock if a target is selected in the
1174 /// command interpreter. If the command object fails to acquire the API
1175 /// lock, the command will fail with an appropriate error message.
1176 eCommandTryTargetAPILock = (1u << 5),
1177 /// eCommandProcessMustBeLaunched
1178 ///
1179 /// Verifies that there is a launched process in m_exe_ctx, if there isn't,
1180 /// the command will fail with an appropriate error message.
1181 eCommandProcessMustBeLaunched = (1u << 6),
1182 /// eCommandProcessMustBePaused
1183 ///
1184 /// Verifies that there is a paused process in m_exe_ctx, if there isn't,
1185 /// the command will fail with an appropriate error message.
1186 eCommandProcessMustBePaused = (1u << 7),
1187 /// eCommandProcessMustBeTraced
1188 ///
1189 /// Verifies that the process is being traced by a Trace plug-in, if it
1190 /// isn't the command will fail with an appropriate error message.
1191 eCommandProcessMustBeTraced = (1u << 8)};
1192
1193/// Whether a summary should cap how much data it returns to users or not.
1194enum TypeSummaryCapping {
1195 eTypeSummaryCapped = true,
1196 eTypeSummaryUncapped = false
1197};
1198
1199/// The result from a command interpreter run.
1200enum CommandInterpreterResult {
1201 /// Command interpreter finished successfully.
1202 eCommandInterpreterResultSuccess,
1203 /// Stopped because the corresponding option was set and the inferior
1204 /// crashed.
1205 eCommandInterpreterResultInferiorCrash,
1206 /// Stopped because the corresponding option was set and a command returned
1207 /// an error.
1208 eCommandInterpreterResultCommandError,
1209 /// Stopped because quit was requested.
1210 eCommandInterpreterResultQuitRequested,
1211};
1212
1213// Style of core file to create when calling SaveCore.
1214enum SaveCoreStyle {
1215 eSaveCoreUnspecified = 0,
1216 eSaveCoreFull = 1,
1217 eSaveCoreDirtyOnly = 2,
1218 eSaveCoreStackOnly = 3,
1219};
1220
1221/// Events that might happen during a trace session.
1222enum TraceEvent {
1223 /// Tracing was disabled for some time due to a software trigger.
1224 eTraceEventDisabledSW,
1225 /// Tracing was disable for some time due to a hardware trigger.
1226 eTraceEventDisabledHW,
1227 /// Event due to CPU change for a thread. This event is also fired when
1228 /// suddenly it's not possible to identify the cpu of a given thread.
1229 eTraceEventCPUChanged,
1230 /// Event due to a CPU HW clock tick.
1231 eTraceEventHWClockTick,
1232 /// The underlying tracing technology emitted a synchronization event used by
1233 /// trace processors.
1234 eTraceEventSyncPoint,
1235};
1236
1237// Enum used to identify which kind of item a \a TraceCursor is pointing at
1238enum TraceItemKind {
1239 eTraceItemKindError = 0,
1240 eTraceItemKindEvent,
1241 eTraceItemKindInstruction,
1242};
1243
1244/// Enum to indicate the reference point when invoking
1245/// \a TraceCursor::Seek().
1246/// The following values are inspired by \a std::istream::seekg.
1247enum TraceCursorSeekType {
1248 /// The beginning of the trace, i.e the oldest item.
1249 eTraceCursorSeekTypeBeginning = 0,
1250 /// The current position in the trace.
1251 eTraceCursorSeekTypeCurrent,
1252 /// The end of the trace, i.e the most recent item.
1253 eTraceCursorSeekTypeEnd
1254};
1255
1256/// Enum to control the verbosity level of `dwim-print` execution.
1257enum DWIMPrintVerbosity {
1258 /// Run `dwim-print` with no verbosity.
1259 eDWIMPrintVerbosityNone,
1260 /// Print a message when `dwim-print` uses `expression` evaluation.
1261 eDWIMPrintVerbosityExpression,
1262 /// Always print a message indicating how `dwim-print` is evaluating its
1263 /// expression.
1264 eDWIMPrintVerbosityFull,
1265};
1266
1267enum WatchpointValueKind {
1268 eWatchPointValueKindInvalid = 0,
1269 ///< Watchpoint was created watching a variable
1270 eWatchPointValueKindVariable = 1,
1271 ///< Watchpoint was created watching the result of an expression that was
1272 ///< evaluated at creation time.
1273 eWatchPointValueKindExpression = 2,
1274};
1275
1276enum CompletionType {
1277 eNoCompletion = 0ul,
1278 eSourceFileCompletion = (1ul << 0),
1279 eDiskFileCompletion = (1ul << 1),
1280 eDiskDirectoryCompletion = (1ul << 2),
1281 eSymbolCompletion = (1ul << 3),
1282 eModuleCompletion = (1ul << 4),
1283 eSettingsNameCompletion = (1ul << 5),
1284 ePlatformPluginCompletion = (1ul << 6),
1285 eArchitectureCompletion = (1ul << 7),
1286 eVariablePathCompletion = (1ul << 8),
1287 eRegisterCompletion = (1ul << 9),
1288 eBreakpointCompletion = (1ul << 10),
1289 eProcessPluginCompletion = (1ul << 11),
1290 eDisassemblyFlavorCompletion = (1ul << 12),
1291 eTypeLanguageCompletion = (1ul << 13),
1292 eFrameIndexCompletion = (1ul << 14),
1293 eModuleUUIDCompletion = (1ul << 15),
1294 eStopHookIDCompletion = (1ul << 16),
1295 eThreadIndexCompletion = (1ul << 17),
1296 eWatchpointIDCompletion = (1ul << 18),
1297 eBreakpointNameCompletion = (1ul << 19),
1298 eProcessIDCompletion = (1ul << 20),
1299 eProcessNameCompletion = (1ul << 21),
1300 eRemoteDiskFileCompletion = (1ul << 22),
1301 eRemoteDiskDirectoryCompletion = (1ul << 23),
1302 eTypeCategoryNameCompletion = (1ul << 24),
1303 eCustomCompletion = (1ul << 25),
1304 eThreadIDCompletion = (1ul << 26),
1305 // This last enum element is just for input validation.
1306 // Add new completions before this element,
1307 // and then increment eTerminatorCompletion's shift value
1308 eTerminatorCompletion = (1ul << 27)
1309};
1310
1311/// Specifies if children need to be re-computed
1312/// after a call to \ref SyntheticChildrenFrontEnd::Update.
1313enum ChildCacheState {
1314 eRefetch = 0, ///< Children need to be recomputed dynamically.
1315
1316 eReuse = 1, ///< Children did not change and don't need to be recomputed;
1317 ///< re-use what we computed the last time we called Update.
1318};
1319
1320enum SymbolDownload {
1321 eSymbolDownloadOff = 0,
1322 eSymbolDownloadBackground = 1,
1323 eSymbolDownloadForeground = 2,
1324};
1325
1326/// Used in the SBProcess AddressMask/FixAddress methods.
1327enum AddressMaskType {
1328 eAddressMaskTypeCode = 0,
1329 eAddressMaskTypeData,
1330 eAddressMaskTypeAny,
1331 eAddressMaskTypeAll = eAddressMaskTypeAny
1332};
1333
1334/// Used in the SBProcess AddressMask/FixAddress methods.
1335enum AddressMaskRange {
1336 eAddressMaskRangeLow = 0,
1337 eAddressMaskRangeHigh,
1338 eAddressMaskRangeAny,
1339 eAddressMaskRangeAll = eAddressMaskRangeAny,
1340};
1341
1342/// Used by the debugger to indicate which events are being broadcasted.
1343enum DebuggerBroadcastBit {
1344 eBroadcastBitProgress = (1 << 0),
1345 eBroadcastBitWarning = (1 << 1),
1346 eBroadcastBitError = (1 << 2),
1347 eBroadcastBitProgressCategory = (1 << 3),
1348};
1349
1350} // namespace lldb
1351
1352#endif // LLDB_LLDB_ENUMERATIONS_H
1353

source code of lldb/include/lldb/lldb-enumerations.h