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
16namespace lldb_private {
17
18// Thread Step Types
19enum 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
30enum 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.
48enum 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...
59enum Vote { eVoteNo = -1, eVoteNoOpinion = 0, eVoteYes = 1 };
60
61enum 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
83enum VarSetOperationType {
84 eVarSetOperationReplace,
85 eVarSetOperationInsertBefore,
86 eVarSetOperationInsertAfter,
87 eVarSetOperationRemove,
88 eVarSetOperationAppend,
89 eVarSetOperationClear,
90 eVarSetOperationAssign,
91 eVarSetOperationInvalid
92};
93
94enum 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
110enum 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.
115enum LazyBool { eLazyBoolCalculate = -1, eLazyBoolNo = 0, eLazyBoolYes = 1 };
116
117/// Instruction types
118enum 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
130enum FormatCategoryItem {
131 eFormatCategoryItemSummary = 0x0001,
132 eFormatCategoryItemRegexSummary = 0x0002,
133 eFormatCategoryItemFilter = 0x0004,
134 eFormatCategoryItemRegexFilter = 0x0008,
135 eFormatCategoryItemSynth = 0x0010,
136 eFormatCategoryItemRegexSynth = 0x0020,
137 eFormatCategoryItemValue = 0x0040,
138 eFormatCategoryItemRegexValue = 0x0080,
139 eFormatCategoryItemValidator = 0x0100,
140 eFormatCategoryItemRegexValidator = 0x0200
141};
142
143/// Expression execution policies
144enum ExecutionPolicy {
145 eExecutionPolicyOnlyWhenNeeded,
146 eExecutionPolicyNever,
147 eExecutionPolicyAlways,
148 eExecutionPolicyTopLevel // used for top-level code
149};
150
151// Synchronicity behavior of scripted commands
152enum ScriptedCommandSynchronicity {
153 eScriptedCommandSynchronicitySynchronous,
154 eScriptedCommandSynchronicityAsynchronous,
155 eScriptedCommandSynchronicityCurrentValue // use whatever the current
156 // synchronicity is
157};
158
159// Verbosity mode of "po" output
160enum LanguageRuntimeDescriptionDisplayVerbosity {
161 eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
162 // description string, if
163 // any
164 eLanguageRuntimeDescriptionDisplayVerbosityFull, // print the full-blown
165 // output
166};
167
168// Loading modules from memory
169enum MemoryModuleLoadLevel {
170 eMemoryModuleLoadLevelMinimal, // Load sections only
171 eMemoryModuleLoadLevelPartial, // Load function bounds but no symbols
172 eMemoryModuleLoadLevelComplete, // Load sections and all symbols
173};
174
175// Result enums for when reading multiple lines from IOHandlers
176enum 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
186enum class TypeValidatorResult : bool { Success = true, Failure = false };
187
188// Enumerations that can be used to specify scopes types when looking up types.
189enum 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
202 Any = 1 << 15,
203 /// Match 0..n nested modules.
204 AnyModule = Any | Module,
205 /// Match any type.
206 AnyType = Any | Class | Struct | Union | Enum | Typedef
207};
208
209// Enumerations that can be used to specify the kind of metric we're looking at
210// when collecting stats.
211enum StatisticKind {
212 ExpressionSuccessful = 0,
213 ExpressionFailure = 1,
214 FrameVarSuccess = 2,
215 FrameVarFailure = 3,
216 StatisticMax = 4
217};
218
219
220inline std::string GetStatDescription(lldb_private::StatisticKind K) {
221 switch (K) {
222 case StatisticKind::ExpressionSuccessful:
223 return "Number of expr evaluation successes";
224 case StatisticKind::ExpressionFailure:
225 return "Number of expr evaluation failures";
226 case StatisticKind::FrameVarSuccess:
227 return "Number of frame var successes";
228 case StatisticKind::FrameVarFailure:
229 return "Number of frame var failures";
230 case StatisticKind::StatisticMax:
231 return "";
232 }
233 llvm_unreachable("Statistic not registered!");
234}
235
236} // namespace lldb_private
237
238namespace llvm {
239template <> struct format_provider<lldb_private::Vote> {
240 static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream,
241 StringRef Style) {
242 switch (V) {
243 case lldb_private::eVoteNo:
244 Stream << "no";
245 return;
246 case lldb_private::eVoteNoOpinion:
247 Stream << "no opinion";
248 return;
249 case lldb_private::eVoteYes:
250 Stream << "yes";
251 return;
252 }
253 Stream << "invalid";
254 }
255};
256}
257
258#endif // LLDB_LLDB_PRIVATE_ENUMERATIONS_H
259