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