llvm/lldb/include/lldb/lldb-private-enumerations.h

//===-- lldb-private-enumerations.h -----------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_LLDB_PRIVATE_ENUMERATIONS_H
#define LLDB_LLDB_PRIVATE_ENUMERATIONS_H

#include "lldb/lldb-enumerations.h"
#include "llvm/ADT/BitmaskEnum.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FormatProviders.h"
#include "llvm/Support/raw_ostream.h"

namespace lldb_private {

// Thread Step Types
enum StepType { … };

// Address Types
enum AddressType { … };

// Address Class
//
// A way of classifying an address used for disassembling and setting
// breakpoints. Many object files can track exactly what parts of their object
// files are code, data and other information. This is of course above and
// beyond just looking at the section types. For example, code might contain PC
// relative data and the object file might be able to tell us that an address
// in code is data.
enum class AddressClass { … };

// Votes - Need a tri-state, yes, no, no opinion...
enum Vote { … };

enum ArchitectureType { … };

/// Settable state variable types.
///

// typedef enum SettableVariableType
//{
//    eSetVarTypeInt,
//    eSetVarTypeBoolean,
//    eSetVarTypeString,
//    eSetVarTypeArray,
//    eSetVarTypeDictionary,
//    eSetVarTypeEnum,
//    eSetVarTypeNone
//} SettableVariableType;

enum VarSetOperationType { … };

enum ArgumentRepetitionType { … };

enum SortOrder { … };

// LazyBool is for boolean values that need to be calculated lazily. Values
// start off set to eLazyBoolCalculate, and then they can be calculated once
// and set to eLazyBoolNo or eLazyBoolYes.
enum LazyBool { … };

/// Instruction types
enum InstructionType { … };

/// Format category entry types
enum FormatCategoryItem { … };

/// Expression execution policies
enum ExecutionPolicy { … };

// Synchronicity behavior of scripted commands
enum ScriptedCommandSynchronicity { … };

// Verbosity mode of "po" output
enum LanguageRuntimeDescriptionDisplayVerbosity { … };

// Loading modules from memory
enum MemoryModuleLoadLevel { … };

// Behavior on fork/vfork
enum FollowForkMode { … };

// Result enums for when reading multiple lines from IOHandlers
enum class LineStatus { … };

// Boolean result of running a Type Validator
enum class TypeValidatorResult : bool { … };

// Enumerations that can be used to specify scopes types when looking up types.
enum class CompilerContextKind : uint16_t { … };
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE(…);

// Enumerations that can be used to specify the kind of metric we're looking at
// when collecting stats.
enum StatisticKind { … };

// Enumeration that can be used to specify a log handler.
enum LogHandlerKind { … };

enum LoadDependentFiles { … };

/// Useful for callbacks whose return type indicates
/// whether to continue iteration or short-circuit.
enum class IterationAction { … };

inline std::string GetStatDescription(lldb_private::StatisticKind K) { … }

} // namespace lldb_private

namespace llvm {
template <> struct format_provider<lldb_private::Vote> { … };
}

enum SelectMostRelevant : bool { … };

enum InterruptionControl : bool { … };

/// The hardware and native stub capabilities for a given target,
/// for translating a user's watchpoint request into hardware
/// capable watchpoint resources.
FLAGS_ENUM(WatchpointHardwareFeature){ … };
LLDB_MARK_AS_BITMASK_ENUM(WatchpointHardwareFeature)

#endif // LLDB_LLDB_PRIVATE_ENUMERATIONS_H