1 //===-- lldb-private-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_PRIVATE_ENUMERATIONS_H
10 #define LLDB_LLDB_PRIVATE_ENUMERATIONS_H
11
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/Support/FormatProviders.h"
14 #include "llvm/Support/raw_ostream.h"
15
16 namespace lldb_private {
17
18 // Thread Step Types
19 enum StepType {
20 eStepTypeNone,
21 eStepTypeTrace, ///< Single step one instruction.
22 eStepTypeTraceOver, ///< Single step one instruction, stepping over.
23 eStepTypeInto, ///< Single step into a specified context.
24 eStepTypeOver, ///< Single step over a specified context.
25 eStepTypeOut, ///< Single step out a specified context.
26 eStepTypeScripted ///< A step type implemented by the script interpreter.
27 };
28
29 // Address Types
30 enum AddressType {
31 eAddressTypeInvalid = 0,
32 eAddressTypeFile, ///< Address is an address as found in an object or symbol
33 /// file
34 eAddressTypeLoad, ///< Address is an address as in the current target inferior
35 /// process
36 eAddressTypeHost ///< Address is an address in the process that is running
37 /// this code
38 };
39
40 // Address Class
41 //
42 // A way of classifying an address used for disassembling and setting
43 // breakpoints. Many object files can track exactly what parts of their object
44 // files are code, data and other information. This is of course above and
45 // beyond just looking at the section types. For example, code might contain PC
46 // relative data and the object file might be able to tell us that an address
47 // in code is data.
48 enum class AddressClass {
49 eInvalid,
50 eUnknown,
51 eCode,
52 eCodeAlternateISA,
53 eData,
54 eDebug,
55 eRuntime
56 };
57
58 // Votes - Need a tri-state, yes, no, no opinion...
59 enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 };
60
61 enum ArchitectureType {
62 eArchTypeInvalid,
63 eArchTypeMachO,
64 eArchTypeELF,
65 eArchTypeCOFF,
66 kNumArchTypes
67 };
68
69 /// Settable state variable types.
70 ///
71
72 // typedef enum SettableVariableType
73 //{
74 // eSetVarTypeInt,
75 // eSetVarTypeBoolean,
76 // eSetVarTypeString,
77 // eSetVarTypeArray,
78 // eSetVarTypeDictionary,
79 // eSetVarTypeEnum,
80 // eSetVarTypeNone
81 //} SettableVariableType;
82
83 enum VarSetOperationType {
84 eVarSetOperationReplace,
85 eVarSetOperationInsertBefore,
86 eVarSetOperationInsertAfter,
87 eVarSetOperationRemove,
88 eVarSetOperationAppend,
89 eVarSetOperationClear,
90 eVarSetOperationAssign,
91 eVarSetOperationInvalid
92 };
93
94 enum ArgumentRepetitionType {
95 eArgRepeatPlain, // Exactly one occurrence
96 eArgRepeatOptional, // At most one occurrence, but it's optional
97 eArgRepeatPlus, // One or more occurrences
98 eArgRepeatStar, // Zero or more occurrences
99 eArgRepeatRange, // Repetition of same argument, from 1 to n
100 eArgRepeatPairPlain, // A pair of arguments that must always go together
101 // ([arg-type arg-value]), occurs exactly once
102 eArgRepeatPairOptional, // A pair that occurs at most once (optional)
103 eArgRepeatPairPlus, // One or more occurrences of a pair
104 eArgRepeatPairStar, // Zero or more occurrences of a pair
105 eArgRepeatPairRange, // A pair that repeats from 1 to n
106 eArgRepeatPairRangeOptional // A pair that repeats from 1 to n, but is
107 // optional
108 };
109
110 enum SortOrder { eSortOrderNone, eSortOrderByAddress, eSortOrderByName };
111
112 // LazyBool is for boolean values that need to be calculated lazily. Values
113 // start off set to eLazyBoolCalculate, and then they can be calculated once
114 // and set to eLazyBoolNo or eLazyBoolYes.
115 enum LazyBool { eLazyBoolCalculate = -1, eLazyBoolNo = 0, eLazyBoolYes = 1 };
116
117 /// Instruction types
118 enum InstructionType {
119 eInstructionTypeAny, // Support for any instructions at all (at least one)
120 eInstructionTypePrologueEpilogue, // All prologue and epilogue instructions
121 // that push and pop register values and
122 // modify sp/fp
123 eInstructionTypePCModifying, // Any instruction that modifies the program
124 // counter/instruction pointer
125 eInstructionTypeAll // All instructions of any kind
126
127 };
128
129 /// Format category entry types
130 enum FormatCategoryItem {
131 eFormatCategoryItemSummary = 1,
132 eFormatCategoryItemFilter = 1 << 1,
133 eFormatCategoryItemSynth = 1 << 2,
134 eFormatCategoryItemFormat = 1 << 3,
135 };
136
137 /// Expression execution policies
138 enum ExecutionPolicy {
139 eExecutionPolicyOnlyWhenNeeded,
140 eExecutionPolicyNever,
141 eExecutionPolicyAlways,
142 eExecutionPolicyTopLevel // used for top-level code
143 };
144
145 // Synchronicity behavior of scripted commands
146 enum ScriptedCommandSynchronicity {
147 eScriptedCommandSynchronicitySynchronous,
148 eScriptedCommandSynchronicityAsynchronous,
149 eScriptedCommandSynchronicityCurrentValue // use whatever the current
150 // synchronicity is
151 };
152
153 // Verbosity mode of "po" output
154 enum LanguageRuntimeDescriptionDisplayVerbosity {
155 eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
156 // description string, if
157 // any
158 eLanguageRuntimeDescriptionDisplayVerbosityFull, // print the full-blown
159 // output
160 };
161
162 // Loading modules from memory
163 enum MemoryModuleLoadLevel {
164 eMemoryModuleLoadLevelMinimal, // Load sections only
165 eMemoryModuleLoadLevelPartial, // Load function bounds but no symbols
166 eMemoryModuleLoadLevelComplete, // Load sections and all symbols
167 };
168
169 // Behavior on fork/vfork
170 enum FollowForkMode {
171 eFollowParent, // Follow parent process
172 eFollowChild, // Follow child process
173 };
174
175 // Result enums for when reading multiple lines from IOHandlers
176 enum class LineStatus {
177 Success, // The line that was just edited if good and should be added to the
178 // lines
179 Status, // There is an error with the current line and it needs to be
180 // re-edited
181 // before it can be accepted
182 Done // Lines are complete
183 };
184
185 // Boolean result of running a Type Validator
186 enum class TypeValidatorResult : bool { Success = true, Failure = false };
187
188 // Enumerations that can be used to specify scopes types when looking up types.
189 enum class CompilerContextKind : uint16_t {
190 Invalid = 0,
191 TranslationUnit = 1,
192 Module = 1 << 1,
193 Namespace = 1 << 2,
194 Class = 1 << 3,
195 Struct = 1 << 4,
196 Union = 1 << 5,
197 Function = 1 << 6,
198 Variable = 1 << 7,
199 Enum = 1 << 8,
200 Typedef = 1 << 9,
201 Builtin = 1 << 10,
202
203 Any = 1 << 15,
204 /// Match 0..n nested modules.
205 AnyModule = Any | Module,
206 /// Match any type.
207 AnyType = Any | Class | Struct | Union | Enum | Typedef | Builtin,
208 /// Math any declaration context.
209 AnyDeclContext = Any | Namespace | Class | Struct | Union | Enum | Function
210 };
211
212 // Enumerations that can be used to specify the kind of metric we're looking at
213 // when collecting stats.
214 enum StatisticKind {
215 ExpressionSuccessful = 0,
216 ExpressionFailure = 1,
217 FrameVarSuccess = 2,
218 FrameVarFailure = 3,
219 StatisticMax = 4
220 };
221
222 // Enumeration that can be used to specify a log handler.
223 enum LogHandlerKind {
224 eLogHandlerStream,
225 eLogHandlerCallback,
226 eLogHandlerCircular,
227 eLogHandlerSystem,
228 eLogHandlerDefault = eLogHandlerStream,
229 };
230
231 enum LoadDependentFiles {
232 eLoadDependentsDefault,
233 eLoadDependentsYes,
234 eLoadDependentsNo,
235 };
236
GetStatDescription(lldb_private::StatisticKind K)237 inline std::string GetStatDescription(lldb_private::StatisticKind K) {
238 switch (K) {
239 case StatisticKind::ExpressionSuccessful:
240 return "Number of expr evaluation successes";
241 case StatisticKind::ExpressionFailure:
242 return "Number of expr evaluation failures";
243 case StatisticKind::FrameVarSuccess:
244 return "Number of frame var successes";
245 case StatisticKind::FrameVarFailure:
246 return "Number of frame var failures";
247 case StatisticKind::StatisticMax:
248 return "";
249 }
250 llvm_unreachable("Statistic not registered!");
251 }
252
253 } // namespace lldb_private
254
255 namespace llvm {
256 template <> struct format_provider<lldb_private::Vote> {
257 static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream,
258 StringRef Style) {
259 switch (V) {
260 case lldb_private::eVoteNo:
261 Stream << "no";
262 return;
263 case lldb_private::eVoteNoOpinion:
264 Stream << "no opinion";
265 return;
266 case lldb_private::eVoteYes:
267 Stream << "yes";
268 return;
269 }
270 Stream << "invalid";
271 }
272 };
273 }
274
275 enum SelectMostRelevant : bool {
276 SelectMostRelevantFrame = true,
277 DoNoSelectMostRelevantFrame = false,
278 };
279
280 enum InterruptionControl : bool {
281 AllowInterruption = true,
282 DoNotAllowInterruption = false,
283 };
284
285 #endif // LLDB_LLDB_PRIVATE_ENUMERATIONS_H
286