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