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