LLDB  mainline
lldb-enumerations.h
Go to the documentation of this file.
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 {
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 the
81  // private state thread is either not yet started or paused. For that reason, they
82  // should only be signaled as public state changes, and not private state changes.
83  eStateStopped, ///< Process or thread is stopped and can be examined.
84  eStateRunning, ///< Process or thread is running and can't be examined.
85  eStateStepping, ///< Process or thread is in the process of stepping and can
86  ///not be examined.
87  eStateCrashed, ///< Process or thread has crashed and can be examined.
88  eStateDetached, ///< Process has been detached and can't be examined.
89  eStateExited, ///< Process has exited and can't be examined.
90  eStateSuspended, ///< Process or thread is in a suspended state as far
91  ///< as the debugger is concerned while other processes
92  ///< or threads get the chance to run.
94 };
95 
96 // Launch Flags
97 FLAGS_ENUM(LaunchFlags){
98  eLaunchFlagNone = 0u,
99  eLaunchFlagExec = (1u << 0), ///< Exec when launching and turn the calling
100  ///process into a new process
101  eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to
102  ///allow the process to be debugged
103  eLaunchFlagStopAtEntry = (1u << 2), ///< Stop at the program entry point
104  ///instead of auto-continuing when
105  ///launching or attaching at entry point
106  eLaunchFlagDisableASLR =
107  (1u << 3), ///< Disable Address Space Layout Randomization
108  eLaunchFlagDisableSTDIO =
109  (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app)
110  eLaunchFlagLaunchInTTY =
111  (1u << 5), ///< Launch the process in a new TTY if supported by the host
112  eLaunchFlagLaunchInShell =
113  (1u << 6), ///< Launch the process inside a shell to get shell expansion
114  eLaunchFlagLaunchInSeparateProcessGroup =
115  (1u << 7), ///< Launch the process in a separate process group
116  eLaunchFlagDontSetExitStatus = (1u << 8), ///< If you are going to hand the
117  ///process off (e.g. to
118  ///debugserver)
119  ///< set this flag so lldb & the handee don't race to set its exit status.
120  eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub
121  ///should detach rather than killing
122  ///the debugee
123  ///< if it loses connection with lldb.
124  eLaunchFlagShellExpandArguments =
125  (1u << 10), ///< Perform shell-style argument expansion
126  eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit
127 };
128 
129 // Thread Run Modes
131 
132 // Byte ordering definitions
133 enum ByteOrder {
138 };
139 
140 // Register encoding definitions
141 enum Encoding {
143  eEncodingUint, // unsigned integer
144  eEncodingSint, // signed integer
146  eEncodingVector // vector registers
147 };
148 
149 // Display format definitions
150 enum Format {
158  eFormatCharPrintable, // Only printable characters, space if not printable
159  eFormatComplex, // Floating point complex type
161  eFormatCString, // NULL terminated C strings
168  eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text'
169  // etc...
187  eFormatComplexInteger, // Integer complex type
188  eFormatCharArray, // Print characters with no single quotes, used for
189  // character arrays that can contain non printable
190  // characters
191  eFormatAddressInfo, // Describe what an address points to (func + offset with
192  // file/line, symbol + offset, data, etc)
193  eFormatHexFloat, // ISO C99 hex float string
194  eFormatInstruction, // Disassemble an opcode
195  eFormatVoid, // Do not print this
197 };
198 
199 // Description levels for "void GetDescription(Stream *, DescriptionLevel)"
200 // calls
207 };
208 
209 // Script interpreter types
215 };
216 
217 // Register numbering types
218 // See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
219 // these to the lldb internal register numbering scheme (eRegisterKindLLDB).
221  eRegisterKindEHFrame = 0, // the register numbers seen in eh_frame
222  eRegisterKindDWARF, // the register numbers seen DWARF
223  eRegisterKindGeneric, // insn ptr reg, stack ptr reg, etc not specific to any
224  // particular target
225  eRegisterKindProcessPlugin, // num used by the process plugin - e.g. by the
226  // remote gdb-protocol stub program
227  eRegisterKindLLDB, // lldb's internal register numbers
229 };
230 
231 // Thread stop reasons
240  eStopReasonExec, // Program was re-exec'ed
244 };
245 
246 // Command Return Status Types
256 };
257 
258 // The results of expression evaluation:
269 };
270 
280 };
281 
282 // Connection Status Types
285  eConnectionStatusEndOfFile, // End-of-file encountered
286  eConnectionStatusError, // Check GetError() for details
287  eConnectionStatusTimedOut, // Request timed out
289  eConnectionStatusLostConnection, // Lost connection while connected to a valid
290  // connection
291  eConnectionStatusInterrupted // Interrupted read
292 };
293 
294 enum ErrorType {
296  eErrorTypeGeneric, ///< Generic errors that can be any value.
297  eErrorTypeMachKernel, ///< Mach kernel error codes.
298  eErrorTypePOSIX, ///< POSIX error codes.
299  eErrorTypeExpression, ///< These are from the ExpressionResults enum.
300  eErrorTypeWin32 ///< Standard Win32 error codes.
301 };
302 
303 enum ValueType {
305  eValueTypeVariableGlobal = 1, // globals variable
306  eValueTypeVariableStatic = 2, // static variable
307  eValueTypeVariableArgument = 3, // function argument variables
308  eValueTypeVariableLocal = 4, // function local variables
309  eValueTypeRegister = 5, // stack frame register value
310  eValueTypeRegisterSet = 6, // A collection of stack frame register values
311  eValueTypeConstResult = 7, // constant result variables
312  eValueTypeVariableThreadLocal = 8 // thread local storage variable
313 };
314 
315 // Token size/granularities for Input Readers
316 
323 };
324 
325 /// These mask bits allow a common interface for queries that can
326 /// limit the amount of information that gets parsed to only the
327 /// information that is requested. These bits also can indicate what
328 /// actually did get resolved during query function calls.
329 ///
330 /// Each definition corresponds to a one of the member variables
331 /// in this class, and requests that that item be resolved, or
332 /// indicates that the member did get resolved.
333 FLAGS_ENUM(SymbolContextItem){
334  eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from
335  /// a query, or was located in query
336  /// results
337  eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from
338  /// a query, or was located in query
339  /// results
340  eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested
341  /// from a query, or was located in
342  /// query results
343  eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested
344  /// from a query, or was located in
345  /// query results
346  eSymbolContextBlock = (1u << 4), ///< Set when the deepest \a block is
347  /// requested from a query, or was located
348  /// in query results
349  eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is
350  /// requested from a query, or was
351  /// located in query results
352  eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from
353  /// a query, or was located in query
354  /// results
355  eSymbolContextEverything = ((eSymbolContextSymbol << 1) -
356  1u), ///< Indicates to try and lookup everything
357  /// up during a routine symbol context
358  /// query.
359  eSymbolContextVariable = (1u << 7), ///< Set when \a global or static
360  /// variable is requested from a query,
361  /// or was located in query results.
362  ///< eSymbolContextVariable is potentially expensive to lookup so it isn't
363  /// included in
364  ///< eSymbolContextEverything which stops it from being used during frame PC
365  /// lookups and
366  ///< many other potential address to symbol context lookups.
367 };
368 LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)
369 
370 FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
371  ePermissionsReadable = (1u << 1),
372  ePermissionsExecutable = (1u << 2)};
373 LLDB_MARK_AS_BITMASK_ENUM(Permissions)
374 
376  eInputReaderActivate, // reader is newly pushed onto the reader stack
377  eInputReaderAsynchronousOutputWritten, // an async output event occurred; the
378  // reader may want to do something
379  eInputReaderReactivate, // reader is on top of the stack again after another
380  // reader was popped off
381  eInputReaderDeactivate, // another reader was pushed on the stack
382  eInputReaderGotToken, // reader got one of its tokens (granularity)
383  eInputReaderInterrupt, // reader received an interrupt signal (probably from a
384  // control-c)
385  eInputReaderEndOfFile, // reader received an EOF char (probably from a
386  // control-d)
387  eInputReaderDone // reader was just popped off the stack and is done
388 };
389 
390 FLAGS_ENUM(BreakpointEventType){
391  eBreakpointEventTypeInvalidType = (1u << 0),
392  eBreakpointEventTypeAdded = (1u << 1),
393  eBreakpointEventTypeRemoved = (1u << 2),
394  eBreakpointEventTypeLocationsAdded = (1u << 3), // Locations added doesn't
395  // get sent when the
396  // breakpoint is created
397  eBreakpointEventTypeLocationsRemoved = (1u << 4),
398  eBreakpointEventTypeLocationsResolved = (1u << 5),
399  eBreakpointEventTypeEnabled = (1u << 6),
400  eBreakpointEventTypeDisabled = (1u << 7),
401  eBreakpointEventTypeCommandChanged = (1u << 8),
402  eBreakpointEventTypeConditionChanged = (1u << 9),
403  eBreakpointEventTypeIgnoreChanged = (1u << 10),
404  eBreakpointEventTypeThreadChanged = (1u << 11),
405  eBreakpointEventTypeAutoContinueChanged = (1u << 12)};
406 
407 FLAGS_ENUM(WatchpointEventType){
408  eWatchpointEventTypeInvalidType = (1u << 0),
409  eWatchpointEventTypeAdded = (1u << 1),
410  eWatchpointEventTypeRemoved = (1u << 2),
411  eWatchpointEventTypeEnabled = (1u << 6),
412  eWatchpointEventTypeDisabled = (1u << 7),
413  eWatchpointEventTypeCommandChanged = (1u << 8),
414  eWatchpointEventTypeConditionChanged = (1u << 9),
415  eWatchpointEventTypeIgnoreChanged = (1u << 10),
416  eWatchpointEventTypeThreadChanged = (1u << 11),
417  eWatchpointEventTypeTypeChanged = (1u << 12)};
418 
419 /// Programming language type.
420 ///
421 /// These enumerations use the same language enumerations as the DWARF
422 /// specification for ease of use and consistency.
423 /// The enum -> string code is in Language.cpp, don't change this
424 /// table without updating that code as well.
426  eLanguageTypeUnknown = 0x0000, ///< Unknown or invalid language value.
427  eLanguageTypeC89 = 0x0001, ///< ISO C:1989.
428  eLanguageTypeC = 0x0002, ///< Non-standardized C, such as K&R.
429  eLanguageTypeAda83 = 0x0003, ///< ISO Ada:1983.
430  eLanguageTypeC_plus_plus = 0x0004, ///< ISO C++:1998.
431  eLanguageTypeCobol74 = 0x0005, ///< ISO Cobol:1974.
432  eLanguageTypeCobol85 = 0x0006, ///< ISO Cobol:1985.
433  eLanguageTypeFortran77 = 0x0007, ///< ISO Fortran 77.
434  eLanguageTypeFortran90 = 0x0008, ///< ISO Fortran 90.
435  eLanguageTypePascal83 = 0x0009, ///< ISO Pascal:1983.
436  eLanguageTypeModula2 = 0x000a, ///< ISO Modula-2:1996.
437  eLanguageTypeJava = 0x000b, ///< Java.
438  eLanguageTypeC99 = 0x000c, ///< ISO C:1999.
439  eLanguageTypeAda95 = 0x000d, ///< ISO Ada:1995.
440  eLanguageTypeFortran95 = 0x000e, ///< ISO Fortran 95.
441  eLanguageTypePLI = 0x000f, ///< ANSI PL/I:1976.
442  eLanguageTypeObjC = 0x0010, ///< Objective-C.
443  eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++.
444  eLanguageTypeUPC = 0x0012, ///< Unified Parallel C.
445  eLanguageTypeD = 0x0013, ///< D.
446  eLanguageTypePython = 0x0014, ///< Python.
447  // NOTE: The below are DWARF5 constants, subject to change upon
448  // completion of the DWARF5 specification
449  eLanguageTypeOpenCL = 0x0015, ///< OpenCL.
450  eLanguageTypeGo = 0x0016, ///< Go.
451  eLanguageTypeModula3 = 0x0017, ///< Modula 3.
452  eLanguageTypeHaskell = 0x0018, ///< Haskell.
453  eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003.
454  eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011.
455  eLanguageTypeOCaml = 0x001b, ///< OCaml.
456  eLanguageTypeRust = 0x001c, ///< Rust.
457  eLanguageTypeC11 = 0x001d, ///< ISO C:2011.
458  eLanguageTypeSwift = 0x001e, ///< Swift.
459  eLanguageTypeJulia = 0x001f, ///< Julia.
460  eLanguageTypeDylan = 0x0020, ///< Dylan.
461  eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014.
462  eLanguageTypeFortran03 = 0x0022, ///< ISO Fortran 2003.
463  eLanguageTypeFortran08 = 0x0023, ///< ISO Fortran 2008.
464  // Vendor Extensions
465  // Note: Language::GetNameForLanguageType
466  // assumes these can be used as indexes into array language_names, and
467  // Language::SetLanguageFromCString and Language::AsCString assume these can
468  // be used as indexes into array g_languages.
469  eLanguageTypeMipsAssembler = 0x0024, ///< Mips_Assembler.
470  eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript.
472 };
473 
481 };
482 
487 };
488 
494 };
495 
502 };
503 
590  eArgTypeLastArg // Always keep this entry as the last entry in this
591  // enumeration!!
592 };
593 
594 // Symbol types
618  eSymbolTypeAdditional, // When symbols take more than one entry, the extra
619  // entries get this type
627 };
628 
632  eSectionTypeContainer, // The section contains child sections
634  eSectionTypeDataCString, // Inlined C string data
635  eSectionTypeDataCStringPointers, // Pointers to C string data
636  eSectionTypeDataSymbolAddress, // Address of a symbol in the symbol table
643  eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
644  eSectionTypeDataObjCCFStrings, // Objective-C const CFString/NSString objects
664  eSectionTypeELFSymbolTable, // Elf SHT_SYMTAB section
665  eSectionTypeELFDynamicSymbols, // Elf SHT_DYNSYM section
666  eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
667  eSectionTypeELFDynamicLinkInfo, // Elf SHT_DYNAMIC section
671  eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
672  // __TEXT,__unwind_info
674  eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
675  // address
677  eSectionTypeDWARFDebugTypes, // DWARF .debug_types section
678  eSectionTypeDWARFDebugNames, // DWARF v5 .debug_names
680  eSectionTypeDWARFDebugLineStr, // DWARF v5 .debug_line_str
681  eSectionTypeDWARFDebugRngLists, // DWARF v5 .debug_rnglists
682  eSectionTypeDWARFDebugLocLists, // DWARF v5 .debug_loclists
687 };
688 
689 FLAGS_ENUM(EmulateInstructionOptions){
690  eEmulateInstructionOptionNone = (0u),
691  eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
692  eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
693 
694 FLAGS_ENUM(FunctionNameType){
695  eFunctionNameTypeNone = 0u,
696  eFunctionNameTypeAuto =
697  (1u << 1), // Automatically figure out which FunctionNameType
698  // bits to set based on the function name.
699  eFunctionNameTypeFull = (1u << 2), // The function name.
700  // For C this is the same as just the name of the function For C++ this is
701  // the mangled or demangled version of the mangled name. For ObjC this is
702  // the full function signature with the + or - and the square brackets and
703  // the class and selector
704  eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces
705  // or arguments and no class
706  // methods or selectors will be searched.
707  eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++)
708  // with no namespace or arguments
709  eFunctionNameTypeSelector =
710  (1u << 5), // Find function by selector name (ObjC) names
711  eFunctionNameTypeAny =
712  eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
713 };
714 LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
715 
716 // Basic types enumeration for the public API SBType::GetBasicType()
717 enum BasicType {
751 };
752 
753 enum TraceType {
755 
756  // Hardware Trace generated by the processor.
758 };
759 
770 };
771 
772 FLAGS_ENUM(TypeClass){
773  eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
774  eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
775  eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
776  eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
777  eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
778  eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
779  eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
780  eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
781  eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
782  eTypeClassVector = (1u << 17),
783  // Define the last type class as the MSBit of a 32 bit value
784  eTypeClassOther = (1u << 31),
785  // Define a mask that can be used for any type when finding types
786  eTypeClassAny = (0xffffffffu)};
787 LLDB_MARK_AS_BITMASK_ENUM(TypeClass)
788 
799 };
800 
801 // Options that can be set for a formatter to alter its behavior Not all of
802 // these are applicable to all formatter types
803 FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
804  eTypeOptionCascade = (1u << 0),
805  eTypeOptionSkipPointers = (1u << 1),
806  eTypeOptionSkipReferences = (1u << 2),
807  eTypeOptionHideChildren = (1u << 3),
808  eTypeOptionHideValue = (1u << 4),
809  eTypeOptionShowOneLiner = (1u << 5),
810  eTypeOptionHideNames = (1u << 6),
811  eTypeOptionNonCacheable = (1u << 7),
812  eTypeOptionHideEmptyAggregates = (1u << 8),
813  eTypeOptionFrontEndWantsDereference = (1u << 9)
814 };
815 
816 // This is the return value for frame comparisons. If you are comparing frame
817 // A to frame B the following cases arise: 1) When frame A pushes frame B (or a
818 // frame that ends up pushing B) A is Older than B. 2) When frame A pushed
819 // frame B (or if frame A is on the stack but B is not) A is Younger than B 3)
820 // When frame A and frame B have the same StackID, they are Equal. 4) When
821 // frame A and frame B have the same immediate parent frame, but are not equal,
822 // the comparison yields
823 // SameParent.
824 // 5) If the two frames are on different threads or processes the comparison is
825 // Invalid 6) If for some reason we can't figure out what went on, we return
826 // Unknown.
834 };
835 
836 // File Permissions
837 //
838 // Designed to mimic the unix file permission bits so they can be used with
839 // functions that set 'mode_t' to certain values for permissions.
840 FLAGS_ENUM(FilePermissions){
841  eFilePermissionsUserRead = (1u << 8), eFilePermissionsUserWrite = (1u << 7),
842  eFilePermissionsUserExecute = (1u << 6),
843  eFilePermissionsGroupRead = (1u << 5),
844  eFilePermissionsGroupWrite = (1u << 4),
845  eFilePermissionsGroupExecute = (1u << 3),
846  eFilePermissionsWorldRead = (1u << 2),
847  eFilePermissionsWorldWrite = (1u << 1),
848  eFilePermissionsWorldExecute = (1u << 0),
849 
850  eFilePermissionsUserRW = (eFilePermissionsUserRead |
851  eFilePermissionsUserWrite | 0),
852  eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 |
853  eFilePermissionsUserExecute),
854  eFilePermissionsUserRWX = (eFilePermissionsUserRead |
855  eFilePermissionsUserWrite |
856  eFilePermissionsUserExecute),
857 
858  eFilePermissionsGroupRW = (eFilePermissionsGroupRead |
859  eFilePermissionsGroupWrite | 0),
860  eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 |
861  eFilePermissionsGroupExecute),
862  eFilePermissionsGroupRWX = (eFilePermissionsGroupRead |
863  eFilePermissionsGroupWrite |
864  eFilePermissionsGroupExecute),
865 
866  eFilePermissionsWorldRW = (eFilePermissionsWorldRead |
867  eFilePermissionsWorldWrite | 0),
868  eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 |
869  eFilePermissionsWorldExecute),
870  eFilePermissionsWorldRWX = (eFilePermissionsWorldRead |
871  eFilePermissionsWorldWrite |
872  eFilePermissionsWorldExecute),
873 
874  eFilePermissionsEveryoneR = (eFilePermissionsUserRead |
875  eFilePermissionsGroupRead |
876  eFilePermissionsWorldRead),
877  eFilePermissionsEveryoneW = (eFilePermissionsUserWrite |
878  eFilePermissionsGroupWrite |
879  eFilePermissionsWorldWrite),
880  eFilePermissionsEveryoneX = (eFilePermissionsUserExecute |
881  eFilePermissionsGroupExecute |
882  eFilePermissionsWorldExecute),
883 
884  eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR |
885  eFilePermissionsEveryoneW | 0),
886  eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 |
887  eFilePermissionsEveryoneX),
888  eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR |
889  eFilePermissionsEveryoneW |
890  eFilePermissionsEveryoneX),
891  eFilePermissionsFileDefault = eFilePermissionsUserRW,
892  eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
893 };
894 
895 // Queue work item types
896 //
897 // The different types of work that can be enqueued on a libdispatch aka Grand
898 // Central Dispatch (GCD) queue.
903 };
904 
905 // Queue type
906 // libdispatch aka Grand Central Dispatch (GCD) queues can be either serial
907 // (executing on one thread) or concurrent (executing on multiple threads).
908 enum QueueKind {
912 };
913 
914 // Expression Evaluation Stages
915 // These are the cancellable stages of expression evaluation, passed to the
916 // expression evaluation callback, so that you can interrupt expression
917 // evaluation at the various points in its lifecycle.
923 };
924 
925 // Watchpoint Kind
926 // Indicates what types of events cause the watchpoint to fire. Used by Native
927 // *Protocol-related classes.
928 FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0),
929  eWatchpointKindRead = (1u << 1)};
930 
931 enum GdbSignal {
938 };
939 
940 // Used with SBHost::GetPath (lldb::PathType) to find files that are related to
941 // LLDB on the current host machine. Most files are relative to LLDB or are in
942 // known locations.
943 enum PathType {
944  ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB
945  // mach-o file in LLDB.framework (MacOSX) exists
946  ePathTypeSupportExecutableDir, // Find LLDB support executable directory
947  // (debugserver, etc)
948  ePathTypeHeaderDir, // Find LLDB header file directory
949  ePathTypePythonDir, // Find Python modules (PYTHONPATH) directory
950  ePathTypeLLDBSystemPlugins, // System plug-ins directory
951  ePathTypeLLDBUserPlugins, // User plug-ins directory
952  ePathTypeLLDBTempSystemDir, // The LLDB temp directory for this system that
953  // will be cleaned up on exit
954  ePathTypeGlobalLLDBTempSystemDir, // The LLDB temp directory for this system,
955  // NOT cleaned up on a process exit.
956  ePathTypeClangDir // Find path to Clang builtin headers
957 };
958 
959 // Kind of member function
960 // Used by the type system
962  eMemberFunctionKindUnknown = 0, // Not sure what the type of this is
963  eMemberFunctionKindConstructor, // A function used to create instances
964  eMemberFunctionKindDestructor, // A function used to tear down existing
965  // instances
966  eMemberFunctionKindInstanceMethod, // A function that applies to a specific
967  // instance
968  eMemberFunctionKindStaticMethod // A function that applies to a type rather
969  // than any instance
970 };
971 
972 // String matching algorithm used by SBTarget
974 
975 // Bitmask that describes details about a type
976 FLAGS_ENUM(TypeFlags){
977  eTypeHasChildren = (1u << 0), eTypeHasValue = (1u << 1),
978  eTypeIsArray = (1u << 2), eTypeIsBlock = (1u << 3),
979  eTypeIsBuiltIn = (1u << 4), eTypeIsClass = (1u << 5),
980  eTypeIsCPlusPlus = (1u << 6), eTypeIsEnumeration = (1u << 7),
981  eTypeIsFuncPrototype = (1u << 8), eTypeIsMember = (1u << 9),
982  eTypeIsObjC = (1u << 10), eTypeIsPointer = (1u << 11),
983  eTypeIsReference = (1u << 12), eTypeIsStructUnion = (1u << 13),
984  eTypeIsTemplate = (1u << 14), eTypeIsTypedef = (1u << 15),
985  eTypeIsVector = (1u << 16), eTypeIsScalar = (1u << 17),
986  eTypeIsInteger = (1u << 18), eTypeIsFloat = (1u << 19),
987  eTypeIsComplex = (1u << 20), eTypeIsSigned = (1u << 21),
988  eTypeInstanceIsPointer = (1u << 22)};
989 
990 FLAGS_ENUM(CommandFlags){
991  // eCommandRequiresTarget
992  //
993  // Ensures a valid target is contained in m_exe_ctx prior to executing the
994  // command. If a target doesn't exist or is invalid, the command will fail
995  // and CommandObject::GetInvalidTargetDescription() will be returned as the
996  // error. CommandObject subclasses can override the virtual function for
997  // GetInvalidTargetDescription() to provide custom strings when needed.
998  eCommandRequiresTarget = (1u << 0),
999  // eCommandRequiresProcess
1000  //
1001  // Ensures a valid process is contained in m_exe_ctx prior to executing the
1002  // command. If a process doesn't exist or is invalid, the command will fail
1003  // and CommandObject::GetInvalidProcessDescription() will be returned as
1004  // the error. CommandObject subclasses can override the virtual function
1005  // for GetInvalidProcessDescription() to provide custom strings when
1006  // needed.
1007  eCommandRequiresProcess = (1u << 1),
1008  // eCommandRequiresThread
1009  //
1010  // Ensures a valid thread is contained in m_exe_ctx prior to executing the
1011  // command. If a thread doesn't exist or is invalid, the command will fail
1012  // and CommandObject::GetInvalidThreadDescription() will be returned as the
1013  // error. CommandObject subclasses can override the virtual function for
1014  // GetInvalidThreadDescription() to provide custom strings when needed.
1015  eCommandRequiresThread = (1u << 2),
1016  // eCommandRequiresFrame
1017  //
1018  // Ensures a valid frame is contained in m_exe_ctx prior to executing the
1019  // command. If a frame doesn't exist or is invalid, the command will fail
1020  // and CommandObject::GetInvalidFrameDescription() will be returned as the
1021  // error. CommandObject subclasses can override the virtual function for
1022  // GetInvalidFrameDescription() to provide custom strings when needed.
1023  eCommandRequiresFrame = (1u << 3),
1024  // eCommandRequiresRegContext
1025  //
1026  // Ensures a valid register context (from the selected frame if there is a
1027  // frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
1028  // available from m_exe_ctx prior to executing the command. If a target
1029  // doesn't exist or is invalid, the command will fail and
1030  // CommandObject::GetInvalidRegContextDescription() will be returned as the
1031  // error. CommandObject subclasses can override the virtual function for
1032  // GetInvalidRegContextDescription() to provide custom strings when needed.
1033  eCommandRequiresRegContext = (1u << 4),
1034  // eCommandTryTargetAPILock
1035  //
1036  // Attempts to acquire the target lock if a target is selected in the
1037  // command interpreter. If the command object fails to acquire the API
1038  // lock, the command will fail with an appropriate error message.
1039  eCommandTryTargetAPILock = (1u << 5),
1040  // eCommandProcessMustBeLaunched
1041  //
1042  // Verifies that there is a launched process in m_exe_ctx, if there isn't,
1043  // the command will fail with an appropriate error message.
1044  eCommandProcessMustBeLaunched = (1u << 6),
1045  // eCommandProcessMustBePaused
1046  //
1047  // Verifies that there is a paused process in m_exe_ctx, if there isn't,
1048  // the command will fail with an appropriate error message.
1049  eCommandProcessMustBePaused = (1u << 7)};
1050 
1051 // Whether a summary should cap how much data it returns to users or not
1055 };
1056 } // namespace lldb
1057 
1058 #endif // LLDB_lldb_enumerations_h_
InputReaderGranularity
These are from the ExpressionResults enum.
ExpressionEvaluationPhase
Process is currently trying to attach.
Process or thread is stopped and can be examined.
Unified Parallel C.
POSIX error codes.
FLAGS_ENUM(LaunchFlags)
Process or thread has crashed and can be examined.
Standard Win32 error codes.
Process has exited and can&#39;t be examined.
LanguageType
Programming language type.
InstrumentationRuntimeType
Process is connected to remote debug services, but not launched or attached to anything yet...
Process has been detached and can&#39;t be examined.
Mach kernel error codes.
Process is in the process of launching.
#define LLDB_MARK_AS_BITMASK_ENUM(Enum)
Process or thread is in the process of stepping and can not be examined.
Generic errors that can be any value.
Process is object is valid, but not currently loaded.
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
Unknown or invalid language value.
Non-standardized C, such as K&R.
Definition: SBAddress.h:15
Process or thread is running and can&#39;t be examined.