diff --git a/linux-x64/clang/include/lldb/lldb-enumerations.h b/linux-x64/clang/include/lldb/lldb-enumerations.h
new file mode 100644
index 0000000..f9830c0
--- /dev/null
+++ b/linux-x64/clang/include/lldb/lldb-enumerations.h
@@ -0,0 +1,1061 @@
+//===-- lldb-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_enumerations_h_
+#define LLDB_lldb_enumerations_h_
+
+#include <type_traits>
+
+#ifndef SWIG
+// Macro to enable bitmask operations on an enum.  Without this, Enum | Enum
+// gets promoted to an int, so you have to say Enum a = Enum(eFoo | eBar).  If
+// you mark Enum with LLDB_MARK_AS_BITMASK_ENUM(Enum), however, you can simply
+// write Enum a = eFoo | eBar.
+// Unfortunately, swig<3.0 doesn't recognise the constexpr keyword, so remove
+// this entire block, as it is not necessary for swig processing.
+#define LLDB_MARK_AS_BITMASK_ENUM(Enum)                                        \
+  constexpr Enum operator|(Enum a, Enum b) {                                   \
+    return static_cast<Enum>(                                                  \
+        static_cast<std::underlying_type<Enum>::type>(a) |                     \
+        static_cast<std::underlying_type<Enum>::type>(b));                     \
+  }                                                                            \
+  constexpr Enum operator&(Enum a, Enum b) {                                   \
+    return static_cast<Enum>(                                                  \
+        static_cast<std::underlying_type<Enum>::type>(a) &                     \
+        static_cast<std::underlying_type<Enum>::type>(b));                     \
+  }                                                                            \
+  constexpr Enum operator~(Enum a) {                                           \
+    return static_cast<Enum>(                                                  \
+        ~static_cast<std::underlying_type<Enum>::type>(a));                    \
+  }                                                                            \
+  inline Enum &operator|=(Enum &a, Enum b) {                                   \
+    a = a | b;                                                                 \
+    return a;                                                                  \
+  }                                                                            \
+  inline Enum &operator&=(Enum &a, Enum b) {                                   \
+    a = a & b;                                                                 \
+    return a;                                                                  \
+  }
+#else
+#define LLDB_MARK_AS_BITMASK_ENUM(Enum)
+#endif
+
+#ifndef SWIG
+// With MSVC, the default type of an enum is always signed, even if one of the
+// enumerator values is too large to fit into a signed integer but would
+// otherwise fit into an unsigned integer.  As a result of this, all of LLDB's
+// flag-style enumerations that specify something like eValueFoo = 1u << 31
+// result in negative values.  This usually just results in a benign warning,
+// but in a few places we actually do comparisons on the enum values, which
+// would cause a real bug.  Furthermore, there's no way to silence only this
+// warning, as it's part of -Wmicrosoft which also catches a whole slew of
+// other useful issues.
+//
+// To make matters worse, early versions of SWIG don't recognize the syntax of
+// specifying the underlying type of an enum (and Python doesn't care anyway)
+// so we need a way to specify the underlying type when the enum is being used
+// from C++ code, but just use a regular enum when swig is pre-processing.
+#define FLAGS_ENUM(Name) enum Name : unsigned
+#define FLAGS_ANONYMOUS_ENUM() enum : unsigned
+#else
+#define FLAGS_ENUM(Name) enum Name
+#define FLAGS_ANONYMOUS_ENUM() enum
+#endif
+
+namespace lldb {
+
+// Process and Thread States
+enum StateType {
+  eStateInvalid = 0,
+  eStateUnloaded,  ///< Process is object is valid, but not currently loaded
+  eStateConnected, ///< Process is connected to remote debug services, but not
+                   ///launched or attached to anything yet
+  eStateAttaching, ///< Process is currently trying to attach
+  eStateLaunching, ///< Process is in the process of launching
+  // The state changes eStateAttaching and eStateLaunching are both sent while the
+  // private state thread is either not yet started or paused. For that reason, they
+  // should only be signaled as public state changes, and not private state changes.
+  eStateStopped,   ///< Process or thread is stopped and can be examined.
+  eStateRunning,   ///< Process or thread is running and can't be examined.
+  eStateStepping,  ///< Process or thread is in the process of stepping and can
+                   ///not be examined.
+  eStateCrashed,   ///< Process or thread has crashed and can be examined.
+  eStateDetached,  ///< Process has been detached and can't be examined.
+  eStateExited,    ///< Process has exited and can't be examined.
+  eStateSuspended, ///< Process or thread is in a suspended state as far
+                   ///< as the debugger is concerned while other processes
+                   ///< or threads get the chance to run.
+  kLastStateType = eStateSuspended
+};
+
+// Launch Flags
+FLAGS_ENUM(LaunchFlags){
+    eLaunchFlagNone = 0u,
+    eLaunchFlagExec = (1u << 0),  ///< Exec when launching and turn the calling
+                                  ///process into a new process
+    eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to
+                                  ///allow the process to be debugged
+    eLaunchFlagStopAtEntry = (1u << 2), ///< Stop at the program entry point
+                                        ///instead of auto-continuing when
+                                        ///launching or attaching at entry point
+    eLaunchFlagDisableASLR =
+        (1u << 3), ///< Disable Address Space Layout Randomization
+    eLaunchFlagDisableSTDIO =
+        (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app)
+    eLaunchFlagLaunchInTTY =
+        (1u << 5), ///< Launch the process in a new TTY if supported by the host
+    eLaunchFlagLaunchInShell =
+        (1u << 6), ///< Launch the process inside a shell to get shell expansion
+    eLaunchFlagLaunchInSeparateProcessGroup =
+        (1u << 7), ///< Launch the process in a separate process group
+    eLaunchFlagDontSetExitStatus = (1u << 8), ///< If you are going to hand the
+                                              ///process off (e.g. to
+                                              ///debugserver)
+    ///< set this flag so lldb & the handee don't race to set its exit status.
+    eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub
+                                          ///should detach rather than killing
+                                          ///the debugee
+                                          ///< if it loses connection with lldb.
+    eLaunchFlagShellExpandArguments =
+        (1u << 10), ///< Perform shell-style argument expansion
+    eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit
+};
+
+// Thread Run Modes
+enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
+
+// Byte ordering definitions
+enum ByteOrder {
+  eByteOrderInvalid = 0,
+  eByteOrderBig = 1,
+  eByteOrderPDP = 2,
+  eByteOrderLittle = 4
+};
+
+// Register encoding definitions
+enum Encoding {
+  eEncodingInvalid = 0,
+  eEncodingUint,    // unsigned integer
+  eEncodingSint,    // signed integer
+  eEncodingIEEE754, // float
+  eEncodingVector   // vector registers
+};
+
+// Display format definitions
+enum Format {
+  eFormatDefault = 0,
+  eFormatInvalid = 0,
+  eFormatBoolean,
+  eFormatBinary,
+  eFormatBytes,
+  eFormatBytesWithASCII,
+  eFormatChar,
+  eFormatCharPrintable, // Only printable characters, space if not printable
+  eFormatComplex,       // Floating point complex type
+  eFormatComplexFloat = eFormatComplex,
+  eFormatCString, // NULL terminated C strings
+  eFormatDecimal,
+  eFormatEnum,
+  eFormatHex,
+  eFormatHexUppercase,
+  eFormatFloat,
+  eFormatOctal,
+  eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text'
+                 // etc...
+  eFormatUnicode16,
+  eFormatUnicode32,
+  eFormatUnsigned,
+  eFormatPointer,
+  eFormatVectorOfChar,
+  eFormatVectorOfSInt8,
+  eFormatVectorOfUInt8,
+  eFormatVectorOfSInt16,
+  eFormatVectorOfUInt16,
+  eFormatVectorOfSInt32,
+  eFormatVectorOfUInt32,
+  eFormatVectorOfSInt64,
+  eFormatVectorOfUInt64,
+  eFormatVectorOfFloat16,
+  eFormatVectorOfFloat32,
+  eFormatVectorOfFloat64,
+  eFormatVectorOfUInt128,
+  eFormatComplexInteger, // Integer complex type
+  eFormatCharArray,      // Print characters with no single quotes, used for
+                         // character arrays that can contain non printable
+                         // characters
+  eFormatAddressInfo, // Describe what an address points to (func + offset with
+                      // file/line, symbol + offset, data, etc)
+  eFormatHexFloat,    // ISO C99 hex float string
+  eFormatInstruction, // Disassemble an opcode
+  eFormatVoid,        // Do not print this
+  kNumFormats
+};
+
+// Description levels for "void GetDescription(Stream *, DescriptionLevel)"
+// calls
+enum DescriptionLevel {
+  eDescriptionLevelBrief = 0,
+  eDescriptionLevelFull,
+  eDescriptionLevelVerbose,
+  eDescriptionLevelInitial,
+  kNumDescriptionLevels
+};
+
+// Script interpreter types
+enum ScriptLanguage {
+  eScriptLanguageNone,
+  eScriptLanguagePython,
+  eScriptLanguageDefault = eScriptLanguagePython,
+  eScriptLanguageUnknown
+};
+
+// Register numbering types
+// See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
+// these to the lldb internal register numbering scheme (eRegisterKindLLDB).
+enum RegisterKind {
+  eRegisterKindEHFrame = 0, // the register numbers seen in eh_frame
+  eRegisterKindDWARF,       // the register numbers seen DWARF
+  eRegisterKindGeneric, // insn ptr reg, stack ptr reg, etc not specific to any
+                        // particular target
+  eRegisterKindProcessPlugin, // num used by the process plugin - e.g. by the
+                              // remote gdb-protocol stub program
+  eRegisterKindLLDB,          // lldb's internal register numbers
+  kNumRegisterKinds
+};
+
+// Thread stop reasons
+enum StopReason {
+  eStopReasonInvalid = 0,
+  eStopReasonNone,
+  eStopReasonTrace,
+  eStopReasonBreakpoint,
+  eStopReasonWatchpoint,
+  eStopReasonSignal,
+  eStopReasonException,
+  eStopReasonExec, // Program was re-exec'ed
+  eStopReasonPlanComplete,
+  eStopReasonThreadExiting,
+  eStopReasonInstrumentation
+};
+
+// Command Return Status Types
+enum ReturnStatus {
+  eReturnStatusInvalid,
+  eReturnStatusSuccessFinishNoResult,
+  eReturnStatusSuccessFinishResult,
+  eReturnStatusSuccessContinuingNoResult,
+  eReturnStatusSuccessContinuingResult,
+  eReturnStatusStarted,
+  eReturnStatusFailed,
+  eReturnStatusQuit
+};
+
+// The results of expression evaluation:
+enum ExpressionResults {
+  eExpressionCompleted = 0,
+  eExpressionSetupError,
+  eExpressionParseError,
+  eExpressionDiscarded,
+  eExpressionInterrupted,
+  eExpressionHitBreakpoint,
+  eExpressionTimedOut,
+  eExpressionResultUnavailable,
+  eExpressionStoppedForDebug
+};
+
+enum SearchDepth {
+    eSearchDepthInvalid = 0,
+    eSearchDepthTarget,
+    eSearchDepthModule,
+    eSearchDepthCompUnit,
+    eSearchDepthFunction,
+    eSearchDepthBlock,
+    eSearchDepthAddress,
+    kLastSearchDepthKind = eSearchDepthAddress
+};
+
+// Connection Status Types
+enum ConnectionStatus {
+  eConnectionStatusSuccess,        // Success
+  eConnectionStatusEndOfFile,      // End-of-file encountered
+  eConnectionStatusError,          // Check GetError() for details
+  eConnectionStatusTimedOut,       // Request timed out
+  eConnectionStatusNoConnection,   // No connection
+  eConnectionStatusLostConnection, // Lost connection while connected to a valid
+                                   // connection
+  eConnectionStatusInterrupted     // Interrupted read
+};
+
+enum ErrorType {
+  eErrorTypeInvalid,
+  eErrorTypeGeneric,    ///< Generic errors that can be any value.
+  eErrorTypeMachKernel, ///< Mach kernel error codes.
+  eErrorTypePOSIX,      ///< POSIX error codes.
+  eErrorTypeExpression, ///< These are from the ExpressionResults enum.
+  eErrorTypeWin32       ///< Standard Win32 error codes.
+};
+
+enum ValueType {
+  eValueTypeInvalid = 0,
+  eValueTypeVariableGlobal = 1,   // globals variable
+  eValueTypeVariableStatic = 2,   // static variable
+  eValueTypeVariableArgument = 3, // function argument variables
+  eValueTypeVariableLocal = 4,    // function local variables
+  eValueTypeRegister = 5,         // stack frame register value
+  eValueTypeRegisterSet = 6,      // A collection of stack frame register values
+  eValueTypeConstResult = 7,      // constant result variables
+  eValueTypeVariableThreadLocal = 8 // thread local storage variable
+};
+
+// Token size/granularities for Input Readers
+
+enum InputReaderGranularity {
+  eInputReaderGranularityInvalid = 0,
+  eInputReaderGranularityByte,
+  eInputReaderGranularityWord,
+  eInputReaderGranularityLine,
+  eInputReaderGranularityAll
+};
+
+/// These mask bits allow a common interface for queries that can
+/// limit the amount of information that gets parsed to only the
+/// information that is requested. These bits also can indicate what
+/// actually did get resolved during query function calls.
+///
+/// Each definition corresponds to a one of the member variables
+/// in this class, and requests that that item be resolved, or
+/// indicates that the member did get resolved.
+FLAGS_ENUM(SymbolContextItem){
+    eSymbolContextTarget = (1u << 0), ///< Set when \a target is requested from
+                                      /// a query, or was located in query
+                                      /// results
+    eSymbolContextModule = (1u << 1), ///< Set when \a module is requested from
+                                      /// a query, or was located in query
+                                      /// results
+    eSymbolContextCompUnit = (1u << 2), ///< Set when \a comp_unit is requested
+                                        /// from a query, or was located in
+                                        /// query results
+    eSymbolContextFunction = (1u << 3), ///< Set when \a function is requested
+                                        /// from a query, or was located in
+                                        /// query results
+    eSymbolContextBlock = (1u << 4),    ///< Set when the deepest \a block is
+                                     /// requested from a query, or was located
+                                     /// in query results
+    eSymbolContextLineEntry = (1u << 5), ///< Set when \a line_entry is
+                                         /// requested from a query, or was
+                                         /// located in query results
+    eSymbolContextSymbol = (1u << 6), ///< Set when \a symbol is requested from
+                                      /// a query, or was located in query
+                                      /// results
+    eSymbolContextEverything = ((eSymbolContextSymbol << 1) -
+                                1u), ///< Indicates to try and lookup everything
+                                     /// up during a routine symbol context
+                                     /// query.
+    eSymbolContextVariable = (1u << 7), ///< Set when \a global or static
+                                        /// variable is requested from a query,
+                                        /// or was located in query results.
+    ///< eSymbolContextVariable is potentially expensive to lookup so it isn't
+    /// included in
+    ///< eSymbolContextEverything which stops it from being used during frame PC
+    /// lookups and
+    ///< many other potential address to symbol context lookups.
+};
+LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)
+
+FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0),
+                        ePermissionsReadable = (1u << 1),
+                        ePermissionsExecutable = (1u << 2)};
+LLDB_MARK_AS_BITMASK_ENUM(Permissions)
+
+enum InputReaderAction {
+  eInputReaderActivate, // reader is newly pushed onto the reader stack
+  eInputReaderAsynchronousOutputWritten, // an async output event occurred; the
+                                         // reader may want to do something
+  eInputReaderReactivate, // reader is on top of the stack again after another
+                          // reader was popped off
+  eInputReaderDeactivate, // another reader was pushed on the stack
+  eInputReaderGotToken,   // reader got one of its tokens (granularity)
+  eInputReaderInterrupt, // reader received an interrupt signal (probably from a
+                         // control-c)
+  eInputReaderEndOfFile, // reader received an EOF char (probably from a
+                         // control-d)
+  eInputReaderDone       // reader was just popped off the stack and is done
+};
+
+FLAGS_ENUM(BreakpointEventType){
+    eBreakpointEventTypeInvalidType = (1u << 0),
+    eBreakpointEventTypeAdded = (1u << 1),
+    eBreakpointEventTypeRemoved = (1u << 2),
+    eBreakpointEventTypeLocationsAdded = (1u << 3), // Locations added doesn't
+                                                    // get sent when the
+                                                    // breakpoint is created
+    eBreakpointEventTypeLocationsRemoved = (1u << 4),
+    eBreakpointEventTypeLocationsResolved = (1u << 5),
+    eBreakpointEventTypeEnabled = (1u << 6),
+    eBreakpointEventTypeDisabled = (1u << 7),
+    eBreakpointEventTypeCommandChanged = (1u << 8),
+    eBreakpointEventTypeConditionChanged = (1u << 9),
+    eBreakpointEventTypeIgnoreChanged = (1u << 10),
+    eBreakpointEventTypeThreadChanged = (1u << 11),
+    eBreakpointEventTypeAutoContinueChanged = (1u << 12)};
+
+FLAGS_ENUM(WatchpointEventType){
+    eWatchpointEventTypeInvalidType = (1u << 0),
+    eWatchpointEventTypeAdded = (1u << 1),
+    eWatchpointEventTypeRemoved = (1u << 2),
+    eWatchpointEventTypeEnabled = (1u << 6),
+    eWatchpointEventTypeDisabled = (1u << 7),
+    eWatchpointEventTypeCommandChanged = (1u << 8),
+    eWatchpointEventTypeConditionChanged = (1u << 9),
+    eWatchpointEventTypeIgnoreChanged = (1u << 10),
+    eWatchpointEventTypeThreadChanged = (1u << 11),
+    eWatchpointEventTypeTypeChanged = (1u << 12)};
+
+/// Programming language type.
+///
+/// These enumerations use the same language enumerations as the DWARF
+/// specification for ease of use and consistency.
+/// The enum -> string code is in Language.cpp, don't change this
+/// table without updating that code as well.
+enum LanguageType {
+  eLanguageTypeUnknown = 0x0000,        ///< Unknown or invalid language value.
+  eLanguageTypeC89 = 0x0001,            ///< ISO C:1989.
+  eLanguageTypeC = 0x0002,              ///< Non-standardized C, such as K&R.
+  eLanguageTypeAda83 = 0x0003,          ///< ISO Ada:1983.
+  eLanguageTypeC_plus_plus = 0x0004,    ///< ISO C++:1998.
+  eLanguageTypeCobol74 = 0x0005,        ///< ISO Cobol:1974.
+  eLanguageTypeCobol85 = 0x0006,        ///< ISO Cobol:1985.
+  eLanguageTypeFortran77 = 0x0007,      ///< ISO Fortran 77.
+  eLanguageTypeFortran90 = 0x0008,      ///< ISO Fortran 90.
+  eLanguageTypePascal83 = 0x0009,       ///< ISO Pascal:1983.
+  eLanguageTypeModula2 = 0x000a,        ///< ISO Modula-2:1996.
+  eLanguageTypeJava = 0x000b,           ///< Java.
+  eLanguageTypeC99 = 0x000c,            ///< ISO C:1999.
+  eLanguageTypeAda95 = 0x000d,          ///< ISO Ada:1995.
+  eLanguageTypeFortran95 = 0x000e,      ///< ISO Fortran 95.
+  eLanguageTypePLI = 0x000f,            ///< ANSI PL/I:1976.
+  eLanguageTypeObjC = 0x0010,           ///< Objective-C.
+  eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++.
+  eLanguageTypeUPC = 0x0012,            ///< Unified Parallel C.
+  eLanguageTypeD = 0x0013,              ///< D.
+  eLanguageTypePython = 0x0014,         ///< Python.
+  // NOTE: The below are DWARF5 constants, subject to change upon
+  // completion of the DWARF5 specification
+  eLanguageTypeOpenCL = 0x0015,         ///< OpenCL.
+  eLanguageTypeGo = 0x0016,             ///< Go.
+  eLanguageTypeModula3 = 0x0017,        ///< Modula 3.
+  eLanguageTypeHaskell = 0x0018,        ///< Haskell.
+  eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003.
+  eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011.
+  eLanguageTypeOCaml = 0x001b,          ///< OCaml.
+  eLanguageTypeRust = 0x001c,           ///< Rust.
+  eLanguageTypeC11 = 0x001d,            ///< ISO C:2011.
+  eLanguageTypeSwift = 0x001e,          ///< Swift.
+  eLanguageTypeJulia = 0x001f,          ///< Julia.
+  eLanguageTypeDylan = 0x0020,          ///< Dylan.
+  eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014.
+  eLanguageTypeFortran03 = 0x0022,      ///< ISO Fortran 2003.
+  eLanguageTypeFortran08 = 0x0023,      ///< ISO Fortran 2008.
+  // Vendor Extensions
+  // Note: Language::GetNameForLanguageType
+  // assumes these can be used as indexes into array language_names, and
+  // Language::SetLanguageFromCString and Language::AsCString assume these can
+  // be used as indexes into array g_languages.
+  eLanguageTypeMipsAssembler = 0x0024,   ///< Mips_Assembler.
+  eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript.
+  eNumLanguageTypes
+};
+
+enum InstrumentationRuntimeType {
+  eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
+  eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
+  eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
+  eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,
+  eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004,
+  eNumInstrumentationRuntimeTypes
+};
+
+enum DynamicValueType {
+  eNoDynamicValues = 0,
+  eDynamicCanRunTarget = 1,
+  eDynamicDontRunTarget = 2
+};
+
+enum StopShowColumn {
+  eStopShowColumnAnsiOrCaret = 0,
+  eStopShowColumnAnsi = 1,
+  eStopShowColumnCaret = 2,
+  eStopShowColumnNone = 3
+};
+
+enum AccessType {
+  eAccessNone,
+  eAccessPublic,
+  eAccessPrivate,
+  eAccessProtected,
+  eAccessPackage
+};
+
+enum CommandArgumentType {
+  eArgTypeAddress = 0,
+  eArgTypeAddressOrExpression,
+  eArgTypeAliasName,
+  eArgTypeAliasOptions,
+  eArgTypeArchitecture,
+  eArgTypeBoolean,
+  eArgTypeBreakpointID,
+  eArgTypeBreakpointIDRange,
+  eArgTypeBreakpointName,
+  eArgTypeByteSize,
+  eArgTypeClassName,
+  eArgTypeCommandName,
+  eArgTypeCount,
+  eArgTypeDescriptionVerbosity,
+  eArgTypeDirectoryName,
+  eArgTypeDisassemblyFlavor,
+  eArgTypeEndAddress,
+  eArgTypeExpression,
+  eArgTypeExpressionPath,
+  eArgTypeExprFormat,
+  eArgTypeFilename,
+  eArgTypeFormat,
+  eArgTypeFrameIndex,
+  eArgTypeFullName,
+  eArgTypeFunctionName,
+  eArgTypeFunctionOrSymbol,
+  eArgTypeGDBFormat,
+  eArgTypeHelpText,
+  eArgTypeIndex,
+  eArgTypeLanguage,
+  eArgTypeLineNum,
+  eArgTypeLogCategory,
+  eArgTypeLogChannel,
+  eArgTypeMethod,
+  eArgTypeName,
+  eArgTypeNewPathPrefix,
+  eArgTypeNumLines,
+  eArgTypeNumberPerLine,
+  eArgTypeOffset,
+  eArgTypeOldPathPrefix,
+  eArgTypeOneLiner,
+  eArgTypePath,
+  eArgTypePermissionsNumber,
+  eArgTypePermissionsString,
+  eArgTypePid,
+  eArgTypePlugin,
+  eArgTypeProcessName,
+  eArgTypePythonClass,
+  eArgTypePythonFunction,
+  eArgTypePythonScript,
+  eArgTypeQueueName,
+  eArgTypeRegisterName,
+  eArgTypeRegularExpression,
+  eArgTypeRunArgs,
+  eArgTypeRunMode,
+  eArgTypeScriptedCommandSynchronicity,
+  eArgTypeScriptLang,
+  eArgTypeSearchWord,
+  eArgTypeSelector,
+  eArgTypeSettingIndex,
+  eArgTypeSettingKey,
+  eArgTypeSettingPrefix,
+  eArgTypeSettingVariableName,
+  eArgTypeShlibName,
+  eArgTypeSourceFile,
+  eArgTypeSortOrder,
+  eArgTypeStartAddress,
+  eArgTypeSummaryString,
+  eArgTypeSymbol,
+  eArgTypeThreadID,
+  eArgTypeThreadIndex,
+  eArgTypeThreadName,
+  eArgTypeTypeName,
+  eArgTypeUnsignedInteger,
+  eArgTypeUnixSignal,
+  eArgTypeVarName,
+  eArgTypeValue,
+  eArgTypeWidth,
+  eArgTypeNone,
+  eArgTypePlatform,
+  eArgTypeWatchpointID,
+  eArgTypeWatchpointIDRange,
+  eArgTypeWatchType,
+  eArgRawInput,
+  eArgTypeCommand,
+  eArgTypeLastArg // Always keep this entry as the last entry in this
+                  // enumeration!!
+};
+
+// Symbol types
+// Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63 
+// entries you will have to resize that field.
+enum SymbolType {
+  eSymbolTypeAny = 0,
+  eSymbolTypeInvalid = 0,
+  eSymbolTypeAbsolute,
+  eSymbolTypeCode,
+  eSymbolTypeResolver,
+  eSymbolTypeData,
+  eSymbolTypeTrampoline,
+  eSymbolTypeRuntime,
+  eSymbolTypeException,
+  eSymbolTypeSourceFile,
+  eSymbolTypeHeaderFile,
+  eSymbolTypeObjectFile,
+  eSymbolTypeCommonBlock,
+  eSymbolTypeBlock,
+  eSymbolTypeLocal,
+  eSymbolTypeParam,
+  eSymbolTypeVariable,
+  eSymbolTypeVariableType,
+  eSymbolTypeLineEntry,
+  eSymbolTypeLineHeader,
+  eSymbolTypeScopeBegin,
+  eSymbolTypeScopeEnd,
+  eSymbolTypeAdditional, // When symbols take more than one entry, the extra
+                         // entries get this type
+  eSymbolTypeCompiler,
+  eSymbolTypeInstrumentation,
+  eSymbolTypeUndefined,
+  eSymbolTypeObjCClass,
+  eSymbolTypeObjCMetaClass,
+  eSymbolTypeObjCIVar,
+  eSymbolTypeReExported
+};
+
+enum SectionType {
+  eSectionTypeInvalid,
+  eSectionTypeCode,
+  eSectionTypeContainer, // The section contains child sections
+  eSectionTypeData,
+  eSectionTypeDataCString,         // Inlined C string data
+  eSectionTypeDataCStringPointers, // Pointers to C string data
+  eSectionTypeDataSymbolAddress,   // Address of a symbol in the symbol table
+  eSectionTypeData4,
+  eSectionTypeData8,
+  eSectionTypeData16,
+  eSectionTypeDataPointers,
+  eSectionTypeDebug,
+  eSectionTypeZeroFill,
+  eSectionTypeDataObjCMessageRefs, // Pointer to function pointer + selector
+  eSectionTypeDataObjCCFStrings, // Objective-C const CFString/NSString objects
+  eSectionTypeDWARFDebugAbbrev,
+  eSectionTypeDWARFDebugAddr,
+  eSectionTypeDWARFDebugAranges,
+  eSectionTypeDWARFDebugCuIndex,
+  eSectionTypeDWARFDebugFrame,
+  eSectionTypeDWARFDebugInfo,
+  eSectionTypeDWARFDebugLine,
+  eSectionTypeDWARFDebugLoc,
+  eSectionTypeDWARFDebugMacInfo,
+  eSectionTypeDWARFDebugMacro,
+  eSectionTypeDWARFDebugPubNames,
+  eSectionTypeDWARFDebugPubTypes,
+  eSectionTypeDWARFDebugRanges,
+  eSectionTypeDWARFDebugStr,
+  eSectionTypeDWARFDebugStrOffsets,
+  eSectionTypeDWARFAppleNames,
+  eSectionTypeDWARFAppleTypes,
+  eSectionTypeDWARFAppleNamespaces,
+  eSectionTypeDWARFAppleObjC,
+  eSectionTypeELFSymbolTable,       // Elf SHT_SYMTAB section
+  eSectionTypeELFDynamicSymbols,    // Elf SHT_DYNSYM section
+  eSectionTypeELFRelocationEntries, // Elf SHT_REL or SHT_REL section
+  eSectionTypeELFDynamicLinkInfo,   // Elf SHT_DYNAMIC section
+  eSectionTypeEHFrame,
+  eSectionTypeARMexidx,
+  eSectionTypeARMextab,
+  eSectionTypeCompactUnwind, // compact unwind section in Mach-O,
+                             // __TEXT,__unwind_info
+  eSectionTypeGoSymtab,
+  eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
+                               // address
+  eSectionTypeDWARFGNUDebugAltLink,
+  eSectionTypeDWARFDebugTypes, // DWARF .debug_types section
+  eSectionTypeDWARFDebugNames, // DWARF v5 .debug_names
+  eSectionTypeOther,
+  eSectionTypeDWARFDebugLineStr, // DWARF v5 .debug_line_str
+  eSectionTypeDWARFDebugRngLists, // DWARF v5 .debug_rnglists
+  eSectionTypeDWARFDebugLocLists, // DWARF v5 .debug_loclists
+  eSectionTypeDWARFDebugAbbrevDwo,
+  eSectionTypeDWARFDebugInfoDwo,
+  eSectionTypeDWARFDebugStrDwo,
+  eSectionTypeDWARFDebugStrOffsetsDwo,
+  eSectionTypeDWARFDebugTypesDwo,
+};
+
+FLAGS_ENUM(EmulateInstructionOptions){
+    eEmulateInstructionOptionNone = (0u),
+    eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
+    eEmulateInstructionOptionIgnoreConditions = (1u << 1)};
+
+FLAGS_ENUM(FunctionNameType){
+    eFunctionNameTypeNone = 0u,
+    eFunctionNameTypeAuto =
+        (1u << 1), // Automatically figure out which FunctionNameType
+                   // bits to set based on the function name.
+    eFunctionNameTypeFull = (1u << 2), // The function name.
+    // For C this is the same as just the name of the function For C++ this is
+    // the mangled or demangled version of the mangled name. For ObjC this is
+    // the full function signature with the + or - and the square brackets and
+    // the class and selector
+    eFunctionNameTypeBase = (1u << 3), // The function name only, no namespaces
+                                       // or arguments and no class
+                                       // methods or selectors will be searched.
+    eFunctionNameTypeMethod = (1u << 4), // Find function by method name (C++)
+                                         // with no namespace or arguments
+    eFunctionNameTypeSelector =
+        (1u << 5), // Find function by selector name (ObjC) names
+    eFunctionNameTypeAny =
+        eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
+};
+LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
+
+// Basic types enumeration for the public API SBType::GetBasicType()
+enum BasicType {
+  eBasicTypeInvalid = 0,
+  eBasicTypeVoid = 1,
+  eBasicTypeChar,
+  eBasicTypeSignedChar,
+  eBasicTypeUnsignedChar,
+  eBasicTypeWChar,
+  eBasicTypeSignedWChar,
+  eBasicTypeUnsignedWChar,
+  eBasicTypeChar16,
+  eBasicTypeChar32,
+  eBasicTypeShort,
+  eBasicTypeUnsignedShort,
+  eBasicTypeInt,
+  eBasicTypeUnsignedInt,
+  eBasicTypeLong,
+  eBasicTypeUnsignedLong,
+  eBasicTypeLongLong,
+  eBasicTypeUnsignedLongLong,
+  eBasicTypeInt128,
+  eBasicTypeUnsignedInt128,
+  eBasicTypeBool,
+  eBasicTypeHalf,
+  eBasicTypeFloat,
+  eBasicTypeDouble,
+  eBasicTypeLongDouble,
+  eBasicTypeFloatComplex,
+  eBasicTypeDoubleComplex,
+  eBasicTypeLongDoubleComplex,
+  eBasicTypeObjCID,
+  eBasicTypeObjCClass,
+  eBasicTypeObjCSel,
+  eBasicTypeNullPtr,
+  eBasicTypeOther
+};
+
+enum TraceType {
+  eTraceTypeNone = 0,
+
+  // Hardware Trace generated by the processor.
+  eTraceTypeProcessorTrace
+};
+
+enum StructuredDataType {
+  eStructuredDataTypeInvalid = -1,
+  eStructuredDataTypeNull = 0,
+  eStructuredDataTypeGeneric,
+  eStructuredDataTypeArray,
+  eStructuredDataTypeInteger,
+  eStructuredDataTypeFloat,
+  eStructuredDataTypeBoolean,
+  eStructuredDataTypeString,
+  eStructuredDataTypeDictionary
+};
+
+FLAGS_ENUM(TypeClass){
+    eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
+    eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
+    eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
+    eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
+    eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
+    eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
+    eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
+    eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
+    eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
+    eTypeClassVector = (1u << 17),
+    // Define the last type class as the MSBit of a 32 bit value
+    eTypeClassOther = (1u << 31),
+    // Define a mask that can be used for any type when finding types
+    eTypeClassAny = (0xffffffffu)};
+LLDB_MARK_AS_BITMASK_ENUM(TypeClass)
+
+enum TemplateArgumentKind {
+  eTemplateArgumentKindNull = 0,
+  eTemplateArgumentKindType,
+  eTemplateArgumentKindDeclaration,
+  eTemplateArgumentKindIntegral,
+  eTemplateArgumentKindTemplate,
+  eTemplateArgumentKindTemplateExpansion,
+  eTemplateArgumentKindExpression,
+  eTemplateArgumentKindPack,
+  eTemplateArgumentKindNullPtr,
+};
+
+// Options that can be set for a formatter to alter its behavior Not all of
+// these are applicable to all formatter types
+FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
+                        eTypeOptionCascade = (1u << 0),
+                        eTypeOptionSkipPointers = (1u << 1),
+                        eTypeOptionSkipReferences = (1u << 2),
+                        eTypeOptionHideChildren = (1u << 3),
+                        eTypeOptionHideValue = (1u << 4),
+                        eTypeOptionShowOneLiner = (1u << 5),
+                        eTypeOptionHideNames = (1u << 6),
+                        eTypeOptionNonCacheable = (1u << 7),
+                        eTypeOptionHideEmptyAggregates = (1u << 8),
+                        eTypeOptionFrontEndWantsDereference = (1u << 9)
+};
+
+// This is the return value for frame comparisons.  If you are comparing frame
+// A to frame B the following cases arise: 1) When frame A pushes frame B (or a
+// frame that ends up pushing B) A is Older than B. 2) When frame A pushed
+// frame B (or if frame A is on the stack but B is not) A is Younger than B 3)
+// When frame A and frame B have the same StackID, they are Equal. 4) When
+// frame A and frame B have the same immediate parent frame, but are not equal,
+// the comparison yields
+//    SameParent.
+// 5) If the two frames are on different threads or processes the comparison is
+// Invalid 6) If for some reason we can't figure out what went on, we return
+// Unknown.
+enum FrameComparison {
+  eFrameCompareInvalid,
+  eFrameCompareUnknown,
+  eFrameCompareEqual,
+  eFrameCompareSameParent,
+  eFrameCompareYounger,
+  eFrameCompareOlder
+};
+
+// File Permissions
+//
+// Designed to mimic the unix file permission bits so they can be used with
+// functions that set 'mode_t' to certain values for permissions.
+FLAGS_ENUM(FilePermissions){
+    eFilePermissionsUserRead = (1u << 8), eFilePermissionsUserWrite = (1u << 7),
+    eFilePermissionsUserExecute = (1u << 6),
+    eFilePermissionsGroupRead = (1u << 5),
+    eFilePermissionsGroupWrite = (1u << 4),
+    eFilePermissionsGroupExecute = (1u << 3),
+    eFilePermissionsWorldRead = (1u << 2),
+    eFilePermissionsWorldWrite = (1u << 1),
+    eFilePermissionsWorldExecute = (1u << 0),
+
+    eFilePermissionsUserRW = (eFilePermissionsUserRead |
+                              eFilePermissionsUserWrite | 0),
+    eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 |
+                                  eFilePermissionsUserExecute),
+    eFilePermissionsUserRWX = (eFilePermissionsUserRead |
+                               eFilePermissionsUserWrite |
+                               eFilePermissionsUserExecute),
+
+    eFilePermissionsGroupRW = (eFilePermissionsGroupRead |
+                               eFilePermissionsGroupWrite | 0),
+    eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 |
+                               eFilePermissionsGroupExecute),
+    eFilePermissionsGroupRWX = (eFilePermissionsGroupRead |
+                                eFilePermissionsGroupWrite |
+                                eFilePermissionsGroupExecute),
+
+    eFilePermissionsWorldRW = (eFilePermissionsWorldRead |
+                               eFilePermissionsWorldWrite | 0),
+    eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 |
+                               eFilePermissionsWorldExecute),
+    eFilePermissionsWorldRWX = (eFilePermissionsWorldRead |
+                                eFilePermissionsWorldWrite |
+                                eFilePermissionsWorldExecute),
+
+    eFilePermissionsEveryoneR = (eFilePermissionsUserRead |
+                                 eFilePermissionsGroupRead |
+                                 eFilePermissionsWorldRead),
+    eFilePermissionsEveryoneW = (eFilePermissionsUserWrite |
+                                 eFilePermissionsGroupWrite |
+                                 eFilePermissionsWorldWrite),
+    eFilePermissionsEveryoneX = (eFilePermissionsUserExecute |
+                                 eFilePermissionsGroupExecute |
+                                 eFilePermissionsWorldExecute),
+
+    eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR |
+                                  eFilePermissionsEveryoneW | 0),
+    eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 |
+                                  eFilePermissionsEveryoneX),
+    eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR |
+                                   eFilePermissionsEveryoneW |
+                                   eFilePermissionsEveryoneX),
+    eFilePermissionsFileDefault = eFilePermissionsUserRW,
+    eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
+};
+
+// Queue work item types
+//
+// The different types of work that can be enqueued on a libdispatch aka Grand
+// Central Dispatch (GCD) queue.
+enum QueueItemKind {
+  eQueueItemKindUnknown = 0,
+  eQueueItemKindFunction,
+  eQueueItemKindBlock
+};
+
+// Queue type
+// libdispatch aka Grand Central Dispatch (GCD) queues can be either serial
+// (executing on one thread) or concurrent (executing on multiple threads).
+enum QueueKind {
+  eQueueKindUnknown = 0,
+  eQueueKindSerial,
+  eQueueKindConcurrent
+};
+
+// Expression Evaluation Stages
+// These are the cancellable stages of expression evaluation, passed to the
+// expression evaluation callback, so that you can interrupt expression
+// evaluation at the various points in its lifecycle.
+enum ExpressionEvaluationPhase {
+  eExpressionEvaluationParse = 0,
+  eExpressionEvaluationIRGen,
+  eExpressionEvaluationExecution,
+  eExpressionEvaluationComplete
+};
+
+// Watchpoint Kind
+// Indicates what types of events cause the watchpoint to fire. Used by Native
+// *Protocol-related classes.
+FLAGS_ENUM(WatchpointKind){eWatchpointKindWrite = (1u << 0),
+                           eWatchpointKindRead = (1u << 1)};
+
+enum GdbSignal {
+  eGdbSignalBadAccess = 0x91,
+  eGdbSignalBadInstruction = 0x92,
+  eGdbSignalArithmetic = 0x93,
+  eGdbSignalEmulation = 0x94,
+  eGdbSignalSoftware = 0x95,
+  eGdbSignalBreakpoint = 0x96
+};
+
+// Used with SBHost::GetPath (lldb::PathType) to find files that are related to
+// LLDB on the current host machine. Most files are relative to LLDB or are in
+// known locations.
+enum PathType {
+  ePathTypeLLDBShlibDir, // The directory where the lldb.so (unix) or LLDB
+                         // mach-o file in LLDB.framework (MacOSX) exists
+  ePathTypeSupportExecutableDir, // Find LLDB support executable directory
+                                 // (debugserver, etc)
+  ePathTypeHeaderDir,            // Find LLDB header file directory
+  ePathTypePythonDir,            // Find Python modules (PYTHONPATH) directory
+  ePathTypeLLDBSystemPlugins,    // System plug-ins directory
+  ePathTypeLLDBUserPlugins,      // User plug-ins directory
+  ePathTypeLLDBTempSystemDir,    // The LLDB temp directory for this system that
+                                 // will be cleaned up on exit
+  ePathTypeGlobalLLDBTempSystemDir, // The LLDB temp directory for this system,
+                                    // NOT cleaned up on a process exit.
+  ePathTypeClangDir                 // Find path to Clang builtin headers
+};
+
+// Kind of member function
+// Used by the type system
+enum MemberFunctionKind {
+  eMemberFunctionKindUnknown = 0,    // Not sure what the type of this is
+  eMemberFunctionKindConstructor,    // A function used to create instances
+  eMemberFunctionKindDestructor,     // A function used to tear down existing
+                                     // instances
+  eMemberFunctionKindInstanceMethod, // A function that applies to a specific
+                                     // instance
+  eMemberFunctionKindStaticMethod    // A function that applies to a type rather
+                                     // than any instance
+};
+
+// String matching algorithm used by SBTarget
+enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };
+
+// Bitmask that describes details about a type
+FLAGS_ENUM(TypeFlags){
+    eTypeHasChildren = (1u << 0),       eTypeHasValue = (1u << 1),
+    eTypeIsArray = (1u << 2),           eTypeIsBlock = (1u << 3),
+    eTypeIsBuiltIn = (1u << 4),         eTypeIsClass = (1u << 5),
+    eTypeIsCPlusPlus = (1u << 6),       eTypeIsEnumeration = (1u << 7),
+    eTypeIsFuncPrototype = (1u << 8),   eTypeIsMember = (1u << 9),
+    eTypeIsObjC = (1u << 10),           eTypeIsPointer = (1u << 11),
+    eTypeIsReference = (1u << 12),      eTypeIsStructUnion = (1u << 13),
+    eTypeIsTemplate = (1u << 14),       eTypeIsTypedef = (1u << 15),
+    eTypeIsVector = (1u << 16),         eTypeIsScalar = (1u << 17),
+    eTypeIsInteger = (1u << 18),        eTypeIsFloat = (1u << 19),
+    eTypeIsComplex = (1u << 20),        eTypeIsSigned = (1u << 21),
+    eTypeInstanceIsPointer = (1u << 22)};
+
+FLAGS_ENUM(CommandFlags){
+    // eCommandRequiresTarget
+    //
+    // Ensures a valid target is contained in m_exe_ctx prior to executing the
+    // command. If a target doesn't exist or is invalid, the command will fail
+    // and CommandObject::GetInvalidTargetDescription() will be returned as the
+    // error. CommandObject subclasses can override the virtual function for
+    // GetInvalidTargetDescription() to provide custom strings when needed.
+    eCommandRequiresTarget = (1u << 0),
+    // eCommandRequiresProcess
+    //
+    // Ensures a valid process is contained in m_exe_ctx prior to executing the
+    // command. If a process doesn't exist or is invalid, the command will fail
+    // and CommandObject::GetInvalidProcessDescription() will be returned as
+    // the error. CommandObject subclasses can override the virtual function
+    // for GetInvalidProcessDescription() to provide custom strings when
+    // needed.
+    eCommandRequiresProcess = (1u << 1),
+    // eCommandRequiresThread
+    //
+    // Ensures a valid thread is contained in m_exe_ctx prior to executing the
+    // command. If a thread doesn't exist or is invalid, the command will fail
+    // and CommandObject::GetInvalidThreadDescription() will be returned as the
+    // error. CommandObject subclasses can override the virtual function for
+    // GetInvalidThreadDescription() to provide custom strings when needed.
+    eCommandRequiresThread = (1u << 2),
+    // eCommandRequiresFrame
+    //
+    // Ensures a valid frame is contained in m_exe_ctx prior to executing the
+    // command. If a frame doesn't exist or is invalid, the command will fail
+    // and CommandObject::GetInvalidFrameDescription() will be returned as the
+    // error. CommandObject subclasses can override the virtual function for
+    // GetInvalidFrameDescription() to provide custom strings when needed.
+    eCommandRequiresFrame = (1u << 3),
+    // eCommandRequiresRegContext
+    //
+    // Ensures a valid register context (from the selected frame if there is a
+    // frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
+    // available from m_exe_ctx prior to executing the command. If a target
+    // doesn't exist or is invalid, the command will fail and
+    // CommandObject::GetInvalidRegContextDescription() will be returned as the
+    // error. CommandObject subclasses can override the virtual function for
+    // GetInvalidRegContextDescription() to provide custom strings when needed.
+    eCommandRequiresRegContext = (1u << 4),
+    // eCommandTryTargetAPILock
+    //
+    // Attempts to acquire the target lock if a target is selected in the
+    // command interpreter. If the command object fails to acquire the API
+    // lock, the command will fail with an appropriate error message.
+    eCommandTryTargetAPILock = (1u << 5),
+    // eCommandProcessMustBeLaunched
+    //
+    // Verifies that there is a launched process in m_exe_ctx, if there isn't,
+    // the command will fail with an appropriate error message.
+    eCommandProcessMustBeLaunched = (1u << 6),
+    // eCommandProcessMustBePaused
+    //
+    // Verifies that there is a paused process in m_exe_ctx, if there isn't,
+    // the command will fail with an appropriate error message.
+    eCommandProcessMustBePaused = (1u << 7)};
+
+// Whether a summary should cap how much data it returns to users or not
+enum TypeSummaryCapping {
+  eTypeSummaryCapped = true,
+  eTypeSummaryUncapped = false
+};
+} // namespace lldb
+
+#endif // LLDB_lldb_enumerations_h_