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