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 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. 211 enum StatisticKind { 212 ExpressionSuccessful = 0, 213 ExpressionFailure = 1, 214 FrameVarSuccess = 2, 215 FrameVarFailure = 3, 216 StatisticMax = 4 217 }; 218 219 // Enumeration that can be used to specify a log handler. 220 enum LogHandlerKind { 221 eLogHandlerStream, 222 eLogHandlerCallback, 223 eLogHandlerCircular, 224 eLogHandlerSystem, 225 eLogHandlerDefault = eLogHandlerStream, 226 }; 227 228 enum LoadDependentFiles { 229 eLoadDependentsDefault, 230 eLoadDependentsYes, 231 eLoadDependentsNo, 232 }; 233 234 inline std::string GetStatDescription(lldb_private::StatisticKind K) { 235 switch (K) { 236 case StatisticKind::ExpressionSuccessful: 237 return "Number of expr evaluation successes"; 238 case StatisticKind::ExpressionFailure: 239 return "Number of expr evaluation failures"; 240 case StatisticKind::FrameVarSuccess: 241 return "Number of frame var successes"; 242 case StatisticKind::FrameVarFailure: 243 return "Number of frame var failures"; 244 case StatisticKind::StatisticMax: 245 return ""; 246 } 247 llvm_unreachable("Statistic not registered!"); 248 } 249 250 } // namespace lldb_private 251 252 namespace llvm { 253 template <> struct format_provider<lldb_private::Vote> { 254 static void format(const lldb_private::Vote &V, llvm::raw_ostream &Stream, 255 StringRef Style) { 256 switch (V) { 257 case lldb_private::eVoteNo: 258 Stream << "no"; 259 return; 260 case lldb_private::eVoteNoOpinion: 261 Stream << "no opinion"; 262 return; 263 case lldb_private::eVoteYes: 264 Stream << "yes"; 265 return; 266 } 267 Stream << "invalid"; 268 } 269 }; 270 } 271 272 enum SelectMostRelevant : bool { 273 SelectMostRelevantFrame = true, 274 DoNoSelectMostRelevantFrame = false, 275 }; 276 277 enum InterruptionControl : bool { 278 AllowInterruption = true, 279 DoNotAllowInterruption = false, 280 }; 281 282 #endif // LLDB_LLDB_PRIVATE_ENUMERATIONS_H 283