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// Ways that the FormatManager picks a particular format for a type
152enum FormatterChoiceCriterion {
153  eFormatterChoiceCriterionDirectChoice = 0x00000000,
154  eFormatterChoiceCriterionStrippedPointerReference = 0x00000001,
155  eFormatterChoiceCriterionNavigatedTypedefs = 0x00000002,
156  eFormatterChoiceCriterionRegularExpressionSummary = 0x00000004,
157  eFormatterChoiceCriterionRegularExpressionFilter = 0x00000004,
158  eFormatterChoiceCriterionLanguagePlugin = 0x00000008,
159  eFormatterChoiceCriterionStrippedBitField = 0x00000010,
160  eFormatterChoiceCriterionWentToStaticValue = 0x00000020
161};
162
163// Synchronicity behavior of scripted commands
164enum ScriptedCommandSynchronicity {
165  eScriptedCommandSynchronicitySynchronous,
166  eScriptedCommandSynchronicityAsynchronous,
167  eScriptedCommandSynchronicityCurrentValue // use whatever the current
168                                            // synchronicity is
169};
170
171// Verbosity mode of "po" output
172enum LanguageRuntimeDescriptionDisplayVerbosity {
173  eLanguageRuntimeDescriptionDisplayVerbosityCompact, // only print the
174                                                      // description string, if
175                                                      // any
176  eLanguageRuntimeDescriptionDisplayVerbosityFull,    // print the full-blown
177                                                      // output
178};
179
180// Loading modules from memory
181enum MemoryModuleLoadLevel {
182  eMemoryModuleLoadLevelMinimal,  // Load sections only
183  eMemoryModuleLoadLevelPartial,  // Load function bounds but no symbols
184  eMemoryModuleLoadLevelComplete, // Load sections and all symbols
185};
186
187// Result enums for when reading multiple lines from IOHandlers
188enum class LineStatus {
189  Success, // The line that was just edited if good and should be added to the
190           // lines
191  Status,  // There is an error with the current line and it needs to be
192           // re-edited
193           // before it can be accepted
194  Done     // Lines are complete
195};
196
197// Boolean result of running a Type Validator
198enum class TypeValidatorResult : bool { Success = true, Failure = false };
199
200// Enumerations that can be used to specify scopes types when looking up types.
201enum class CompilerContextKind : uint16_t {
202  Invalid = 0,
203  TranslationUnit = 1,
204  Module = 1 << 1,
205  Namespace = 1 << 2,
206  Class = 1 << 3,
207  Struct = 1 << 4,
208  Union = 1 << 5,
209  Function = 1 << 6,
210  Variable = 1 << 7,
211  Enum = 1 << 8,
212  Typedef = 1 << 9,
213
214  Any = 1 << 15,
215  /// Match 0..n nested modules.
216  AnyModule = Any | Module,
217  /// Match any type.
218  AnyType = Any | Class | Struct | Union | Enum | Typedef
219};
220
221// Enumerations that can be used to specify the kind of metric we're looking at
222// when collecting stats.
223enum StatisticKind {
224  ExpressionSuccessful = 0,
225  ExpressionFailure = 1,
226  FrameVarSuccess = 2,
227  FrameVarFailure = 3,
228  StatisticMax = 4
229};
230
231
232inline std::string GetStatDescription(lldb_private::StatisticKind K) {
233   switch (K) {
234   case StatisticKind::ExpressionSuccessful:
235     return "Number of expr evaluation successes";
236   case StatisticKind::ExpressionFailure:
237     return "Number of expr evaluation failures";
238   case StatisticKind::FrameVarSuccess:
239     return "Number of frame var successes";
240   case StatisticKind::FrameVarFailure:
241     return "Number of frame var failures";
242   case StatisticKind::StatisticMax:
243     return "";
244   }
245   llvm_unreachable("Statistic not registered!");
246}
247
248} // namespace lldb_private
249
250namespace llvm {
251template <> struct format_provider<lldb_private::Vote> {
252  static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream,
253                     StringRef Style) {
254    switch (V) {
255    case lldb_private::eVoteNo:
256      Stream << "no";
257      return;
258    case lldb_private::eVoteNoOpinion:
259      Stream << "no opinion";
260      return;
261    case lldb_private::eVoteYes:
262      Stream << "yes";
263      return;
264    }
265    Stream << "invalid";
266  }
267};
268}
269
270#endif // LLDB_lldb_private_enumerations_h_
271