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