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