diff --git a/linux-x64/clang/include/lldb/lldb-enumerations.h b/linux-x64/clang/include/lldb/lldb-enumerations.h
index f9830c0..2679ee5 100644
--- a/linux-x64/clang/include/lldb/lldb-enumerations.h
+++ b/linux-x64/clang/include/lldb/lldb-enumerations.h
@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLDB_lldb_enumerations_h_
-#define LLDB_lldb_enumerations_h_
+#ifndef LLDB_LLDB_ENUMERATIONS_H
+#define LLDB_LLDB_ENUMERATIONS_H
 
 #include <type_traits>
 
@@ -69,21 +69,22 @@
 
 namespace lldb {
 
-// Process and Thread States
+/// 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
+                   /// 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.
+  // 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.
+                   /// 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.
@@ -93,16 +94,17 @@
   kLastStateType = eStateSuspended
 };
 
-// Launch Flags
+/// Launch Flags.
 FLAGS_ENUM(LaunchFlags){
     eLaunchFlagNone = 0u,
     eLaunchFlagExec = (1u << 0),  ///< Exec when launching and turn the calling
-                                  ///process into a new process
+                                  /// 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
+                                  /// 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 =
@@ -113,23 +115,26 @@
         (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)
+                   ///< If you are going to hand the process off (e.g. to
+                   ///< debugserver)
+    eLaunchFlagDontSetExitStatus = (1u << 8),
     ///< 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
+                                          ///< 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
+    eLaunchFlagInheritTCCFromParent =
+        (1u << 12), ///< Don't make the inferior responsible for its own TCC
+                    ///< permissions but instead inherit them from its parent.
 };
 
-// Thread Run Modes
+/// Thread Run Modes.
 enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };
 
-// Byte ordering definitions
+/// Byte ordering definitions.
 enum ByteOrder {
   eByteOrderInvalid = 0,
   eByteOrderBig = 1,
@@ -137,16 +142,16 @@
   eByteOrderLittle = 4
 };
 
-// Register encoding definitions
+/// Register encoding definitions.
 enum Encoding {
   eEncodingInvalid = 0,
-  eEncodingUint,    // unsigned integer
-  eEncodingSint,    // signed integer
-  eEncodingIEEE754, // float
-  eEncodingVector   // vector registers
+  eEncodingUint,    ///< unsigned integer
+  eEncodingSint,    ///< signed integer
+  eEncodingIEEE754, ///< float
+  eEncodingVector   ///< vector registers
 };
 
-// Display format definitions
+/// Display format definitions.
 enum Format {
   eFormatDefault = 0,
   eFormatInvalid = 0,
@@ -155,18 +160,18 @@
   eFormatBytes,
   eFormatBytesWithASCII,
   eFormatChar,
-  eFormatCharPrintable, // Only printable characters, space if not printable
-  eFormatComplex,       // Floating point complex type
+  eFormatCharPrintable, ///< Only printable characters, space if not printable
+  eFormatComplex,       ///< Floating point complex type
   eFormatComplexFloat = eFormatComplex,
-  eFormatCString, // NULL terminated C strings
+  eFormatCString, ///< NULL terminated C strings
   eFormatDecimal,
   eFormatEnum,
   eFormatHex,
   eFormatHexUppercase,
   eFormatFloat,
   eFormatOctal,
-  eFormatOSType, // OS character codes encoded into an integer 'PICT' 'text'
-                 // etc...
+  eFormatOSType, ///< OS character codes encoded into an integer 'PICT' 'text'
+                 ///< etc...
   eFormatUnicode16,
   eFormatUnicode32,
   eFormatUnsigned,
@@ -184,20 +189,21 @@
   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
+  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
+  eFormatUnicode8,
   kNumFormats
 };
 
-// Description levels for "void GetDescription(Stream *, DescriptionLevel)"
-// calls
+/// Description levels for "void GetDescription(Stream *, DescriptionLevel)"
+/// calls.
 enum DescriptionLevel {
   eDescriptionLevelBrief = 0,
   eDescriptionLevelFull,
@@ -206,29 +212,30 @@
   kNumDescriptionLevels
 };
 
-// Script interpreter types
+/// Script interpreter types.
 enum ScriptLanguage {
-  eScriptLanguageNone,
+  eScriptLanguageNone = 0,
   eScriptLanguagePython,
-  eScriptLanguageDefault = eScriptLanguagePython,
-  eScriptLanguageUnknown
+  eScriptLanguageLua,
+  eScriptLanguageUnknown,
+  eScriptLanguageDefault = eScriptLanguagePython
 };
 
-// Register numbering types
+/// 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
+  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
+/// Thread stop reasons.
 enum StopReason {
   eStopReasonInvalid = 0,
   eStopReasonNone,
@@ -237,13 +244,13 @@
   eStopReasonWatchpoint,
   eStopReasonSignal,
   eStopReasonException,
-  eStopReasonExec, // Program was re-exec'ed
+  eStopReasonExec, ///< Program was re-exec'ed
   eStopReasonPlanComplete,
   eStopReasonThreadExiting,
   eStopReasonInstrumentation
 };
 
-// Command Return Status Types
+/// Command Return Status Types.
 enum ReturnStatus {
   eReturnStatusInvalid,
   eReturnStatusSuccessFinishNoResult,
@@ -255,7 +262,7 @@
   eReturnStatusQuit
 };
 
-// The results of expression evaluation:
+/// The results of expression evaluation.
 enum ExpressionResults {
   eExpressionCompleted = 0,
   eExpressionSetupError,
@@ -265,30 +272,31 @@
   eExpressionHitBreakpoint,
   eExpressionTimedOut,
   eExpressionResultUnavailable,
-  eExpressionStoppedForDebug
+  eExpressionStoppedForDebug,
+  eExpressionThreadVanished
 };
 
 enum SearchDepth {
-    eSearchDepthInvalid = 0,
-    eSearchDepthTarget,
-    eSearchDepthModule,
-    eSearchDepthCompUnit,
-    eSearchDepthFunction,
-    eSearchDepthBlock,
-    eSearchDepthAddress,
-    kLastSearchDepthKind = eSearchDepthAddress
+  eSearchDepthInvalid = 0,
+  eSearchDepthTarget,
+  eSearchDepthModule,
+  eSearchDepthCompUnit,
+  eSearchDepthFunction,
+  eSearchDepthBlock,
+  eSearchDepthAddress,
+  kLastSearchDepthKind = eSearchDepthAddress
 };
 
-// Connection Status Types
+/// 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
+  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 {
@@ -302,17 +310,17 @@
 
 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
+  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
+/// Token size/granularities for Input Readers.
 
 enum InputReaderGranularity {
   eInputReaderGranularityInvalid = 0,
@@ -331,39 +339,37 @@
 /// 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.
+    /// Set when \a target is requested from a query, or was located
+    /// in query results
+    eSymbolContextTarget = (1u << 0),
+    /// Set when \a module is requested from a query, or was located
+    /// in query results
+    eSymbolContextModule = (1u << 1),
+    /// Set when \a comp_unit is requested from a query, or was
+    /// located in query results
+    eSymbolContextCompUnit = (1u << 2),
+    /// Set when \a function is requested from a query, or was located
+    /// in query results
+    eSymbolContextFunction = (1u << 3),
+    /// Set when the deepest \a block is requested from a query, or
+    /// was located in query results
+    eSymbolContextBlock = (1u << 4),
+    /// Set when \a line_entry is requested from a query, or was
+    /// located in query results
+    eSymbolContextLineEntry = (1u << 5),
+    /// Set when \a symbol is requested from a query, or was located
+    /// in query results
+    eSymbolContextSymbol = (1u << 6),
+    /// Indicates to try and lookup everything up during a routine
+    /// symbol context query.
+    eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1u),
+    /// 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.
+    eSymbolContextVariable = (1u << 7),
 };
 LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)
 
@@ -373,27 +379,28 @@
 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
+  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
+    eBreakpointEventTypeLocationsAdded = (1u << 3), ///< Locations added doesn't
+                                                    ///< get sent when the
+                                                    ///< breakpoint is created
     eBreakpointEventTypeLocationsRemoved = (1u << 4),
     eBreakpointEventTypeLocationsResolved = (1u << 5),
     eBreakpointEventTypeEnabled = (1u << 6),
@@ -522,6 +529,7 @@
   eArgTypeExpression,
   eArgTypeExpressionPath,
   eArgTypeExprFormat,
+  eArgTypeFileLineColumn,
   eArgTypeFilename,
   eArgTypeFormat,
   eArgTypeFrameIndex,
@@ -587,12 +595,14 @@
   eArgTypeWatchType,
   eArgRawInput,
   eArgTypeCommand,
+  eArgTypeColumnNum,
+  eArgTypeModuleUUID,
   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 
+/// 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,
@@ -617,8 +627,8 @@
   eSymbolTypeLineHeader,
   eSymbolTypeScopeBegin,
   eSymbolTypeScopeEnd,
-  eSymbolTypeAdditional, // When symbols take more than one entry, the extra
-                         // entries get this type
+  eSymbolTypeAdditional, ///< When symbols take more than one entry, the extra
+                         ///< entries get this type
   eSymbolTypeCompiler,
   eSymbolTypeInstrumentation,
   eSymbolTypeUndefined,
@@ -631,19 +641,20 @@
 enum SectionType {
   eSectionTypeInvalid,
   eSectionTypeCode,
-  eSectionTypeContainer, // The section contains child sections
+  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
+  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
+  eSectionTypeDataObjCMessageRefs, ///< Pointer to function pointer + selector
+  eSectionTypeDataObjCCFStrings,   ///< Objective-C const CFString/NSString
+                                   ///< objects
   eSectionTypeDWARFDebugAbbrev,
   eSectionTypeDWARFDebugAddr,
   eSectionTypeDWARFDebugAranges,
@@ -663,30 +674,34 @@
   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
+  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
+  eSectionTypeCompactUnwind, ///< compact unwind section in Mach-O,
+                             ///< __TEXT,__unwind_info
   eSectionTypeGoSymtab,
-  eSectionTypeAbsoluteAddress, // Dummy section for symbols with absolute
-                               // address
+  eSectionTypeAbsoluteAddress, ///< Dummy section for symbols with absolute
+                               ///< address
   eSectionTypeDWARFGNUDebugAltLink,
-  eSectionTypeDWARFDebugTypes, // DWARF .debug_types section
-  eSectionTypeDWARFDebugNames, // DWARF v5 .debug_names
+  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
+  eSectionTypeDWARFDebugLineStr,  ///< DWARF v5 .debug_line_str
+  eSectionTypeDWARFDebugRngLists, ///< DWARF v5 .debug_rnglists
+  eSectionTypeDWARFDebugLocLists, ///< DWARF v5 .debug_loclists
   eSectionTypeDWARFDebugAbbrevDwo,
   eSectionTypeDWARFDebugInfoDwo,
   eSectionTypeDWARFDebugStrDwo,
   eSectionTypeDWARFDebugStrOffsetsDwo,
   eSectionTypeDWARFDebugTypesDwo,
+  eSectionTypeDWARFDebugRngListsDwo,
+  eSectionTypeDWARFDebugLocDwo,
+  eSectionTypeDWARFDebugLocListsDwo,
+  eSectionTypeDWARFDebugTuIndex,
 };
 
 FLAGS_ENUM(EmulateInstructionOptions){
@@ -697,26 +712,27 @@
 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
+        (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
+        (1u << 5), ///< Find function by selector name (ObjC) names
     eFunctionNameTypeAny =
-        eFunctionNameTypeAuto // DEPRECATED: use eFunctionNameTypeAuto
+        eFunctionNameTypeAuto ///< DEPRECATED: use eFunctionNameTypeAuto
 };
 LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)
 
-// Basic types enumeration for the public API SBType::GetBasicType()
+/// Basic types enumeration for the public API SBType::GetBasicType().
 enum BasicType {
   eBasicTypeInvalid = 0,
   eBasicTypeVoid = 1,
@@ -753,10 +769,11 @@
   eBasicTypeOther
 };
 
+/// Deprecated
 enum TraceType {
   eTraceTypeNone = 0,
 
-  // Hardware Trace generated by the processor.
+  /// Intel Processor Trace
   eTraceTypeProcessorTrace
 };
 
@@ -801,8 +818,8 @@
   eTemplateArgumentKindNullPtr,
 };
 
-// Options that can be set for a formatter to alter its behavior Not all of
-// these are applicable to all formatter types
+/// 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),
@@ -813,20 +830,28 @@
                         eTypeOptionHideNames = (1u << 6),
                         eTypeOptionNonCacheable = (1u << 7),
                         eTypeOptionHideEmptyAggregates = (1u << 8),
-                        eTypeOptionFrontEndWantsDereference = (1u << 9)
-};
+                        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.
+/// 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 frameA 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,
@@ -836,12 +861,13 @@
   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.
+/// 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),
+    eFilePermissionsUserRead = (1u << 8),
+    eFilePermissionsUserWrite = (1u << 7),
     eFilePermissionsUserExecute = (1u << 6),
     eFilePermissionsGroupRead = (1u << 5),
     eFilePermissionsGroupWrite = (1u << 4),
@@ -895,29 +921,32 @@
     eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
 };
 
-// Queue work item types
-//
-// The different types of work that can be enqueued on a libdispatch aka Grand
-// Central Dispatch (GCD) queue.
+/// 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).
+/// 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.
+/// 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,
@@ -925,9 +954,10 @@
   eExpressionEvaluationComplete
 };
 
-// Watchpoint Kind
-// Indicates what types of events cause the watchpoint to fire. Used by Native
-// *Protocol-related classes.
+/// 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)};
 
@@ -940,42 +970,44 @@
   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.
+/// 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
+  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
+/// 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
+  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
+/// String matching algorithm used by SBTarget.
 enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };
 
-// Bitmask that describes details about a type
+/// Bitmask that describes details about a type.
 FLAGS_ENUM(TypeFlags){
     eTypeHasChildren = (1u << 0),       eTypeHasValue = (1u << 1),
     eTypeIsArray = (1u << 2),           eTypeIsBlock = (1u << 3),
@@ -991,71 +1023,90 @@
     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
+    ///
+    /// 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
+    ///
+    /// 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
+    ///
+    /// 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
+    ///
+    /// 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
+    ///
+    /// 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
+    ///
+    /// 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
+    ///
+    /// 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)};
+    /// 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),
+    /// eCommandProcessMustBeTraced
+    ///
+    /// Verifies that the process is being traced by a Trace plug-in, if it
+    /// isn't the command will fail with an appropriate error message.
+    eCommandProcessMustBeTraced = (1u << 8)};
 
-// Whether a summary should cap how much data it returns to users or not
+/// Whether a summary should cap how much data it returns to users or not.
 enum TypeSummaryCapping {
   eTypeSummaryCapped = true,
   eTypeSummaryUncapped = false
 };
+
+/// The result from a command interpreter run.
+enum CommandInterpreterResult {
+  /// Command interpreter finished successfully.
+  eCommandInterpreterResultSuccess,
+  /// Stopped because the corresponding option was set and the inferior
+  /// crashed.
+  eCommandInterpreterResultInferiorCrash,
+  /// Stopped because the corresponding option was set and a command returned
+  /// an error.
+  eCommandInterpreterResultCommandError,
+  /// Stopped because quit was requested.
+  eCommandInterpreterResultQuitRequested,
+};
 } // namespace lldb
 
-#endif // LLDB_lldb_enumerations_h_
+#endif // LLDB_LLDB_ENUMERATIONS_H