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