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