https://github.com/kastiglione updated https://github.com/llvm/llvm-project/pull/203079
>From ec6e0e3a5b9b35f66eb35a643923c3f1cf4e3415 Mon Sep 17 00:00:00 2001 From: Dave Lee <[email protected]> Date: Wed, 10 Jun 2026 12:19:49 -0700 Subject: [PATCH 1/2] [lldb] Fix doxygen comments in lldb-enumerations.h (NFC) --- lldb/include/lldb/lldb-enumerations.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index a40788fca89e5..ada77147307b5 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -75,7 +75,7 @@ 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 @@ -85,7 +85,7 @@ enum StateType { 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. @@ -99,13 +99,13 @@ enum StateType { 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 + ///< 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 + ///< instead of auto-continuing when + ///< launching or attaching at entry point eLaunchFlagDisableASLR = (1u << 3), ///< Disable Address Space Layout Randomization eLaunchFlagDisableSTDIO = @@ -1321,10 +1321,10 @@ enum DWIMPrintVerbosity { enum WatchpointValueKind { eWatchPointValueKindInvalid = 0, - ///< Watchpoint was created watching a variable + /// Watchpoint was created watching a variable eWatchPointValueKindVariable = 1, - ///< Watchpoint was created watching the result of an expression that was - ///< evaluated at creation time. + /// Watchpoint was created watching the result of an expression that was + /// evaluated at creation time. eWatchPointValueKindExpression = 2, }; >From 0d8c759afbad89f5e1ede643508d78a13baa8064 Mon Sep 17 00:00:00 2001 From: Dave Lee <[email protected]> Date: Wed, 10 Jun 2026 13:01:43 -0700 Subject: [PATCH 2/2] Convert to doxygent comments preceding enumerators --- lldb/include/lldb/lldb-enumerations.h | 593 ++++++++++++++++---------- 1 file changed, 365 insertions(+), 228 deletions(-) diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index ada77147307b5..e01650ca11a88 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -73,69 +73,79 @@ 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 + /// Process is object is valid, but not currently loaded + eStateUnloaded, + /// Process is connected to remote debug services, but not + /// launched or attached to anything yet + eStateConnected, + /// Process is currently trying to attach + eStateAttaching, + /// Process is in the process of launching + eStateLaunching, // 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. + /// Process or thread is stopped and can be examined. + eStateStopped, + /// Process or thread is running and can't be examined. + eStateRunning, + /// Process or thread is in the process of stepping and can + /// not be examined. + eStateStepping, + /// Process or thread has crashed and can be examined. + eStateCrashed, + /// Process has been detached and can't be examined. + eStateDetached, + /// Process has exited and can't be examined. + eStateExited, + /// 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. + eStateSuspended, 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 - ///< If you are going to hand the process off (e.g. to - ///< debugserver) + /// Exec when launching and turn the calling process into a new process. + eLaunchFlagExec = (1u << 0), + /// Stop as soon as the process launches to allow the process to be + /// debugged. + eLaunchFlagDebug = (1u << 1), + /// Stop at the program entry point instead of auto-continuing when + /// launching or attaching at entry point. + eLaunchFlagStopAtEntry = (1u << 2), + /// Disable Address Space Layout Randomization. + eLaunchFlagDisableASLR = (1u << 3), + /// Disable stdio for inferior process (e.g. for a GUI app). + eLaunchFlagDisableSTDIO = (1u << 4), + /// Launch the process in a new TTY if supported by the host. + eLaunchFlagLaunchInTTY = (1u << 5), + /// Launch the process inside a shell to get shell expansion. + eLaunchFlagLaunchInShell = (1u << 6), + /// Launch the process in a separate process group. If you are going to + /// hand the process off (e.g. to debugserver). + eLaunchFlagLaunchInSeparateProcessGroup = (1u << 7), + /// Set this flag so lldb & the handee don't race to set its exit status. 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 - ///< 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. - eLaunchFlagMemoryTagging = - (1u << 13), ///< Launch process with memory tagging explicitly enabled. - eLaunchFlagUsePipes = - (1u << 14), ///< Use anonymous pipes for stdio instead of a ConPTY on - ///< Windows. Useful when terminal emulation is not needed - ///< (e.g. lldb-dap internalConsole mode). + /// If set, then the client stub should detach rather than killing the + /// debugee if it loses connection with lldb. + eLaunchFlagDetachOnError = (1u << 9), + /// Perform shell-style argument expansion. + eLaunchFlagShellExpandArguments = (1u << 10), + /// Close the open TTY on exit. + eLaunchFlagCloseTTYOnExit = (1u << 11), + /// Don't make the inferior responsible for its own TCC permissions but + /// instead inherit them from its parent. + eLaunchFlagInheritTCCFromParent = (1u << 12), + /// Launch process with memory tagging explicitly enabled. + eLaunchFlagMemoryTagging = (1u << 13), + /// Use anonymous pipes for stdio instead of a ConPTY on Windows. Useful + /// when terminal emulation is not needed (e.g. lldb-dap internalConsole + /// mode). + eLaunchFlagUsePipes = (1u << 14), }; /// Thread Run Modes. @@ -155,10 +165,14 @@ enum ByteOrder { /// Register encoding definitions. enum Encoding { eEncodingInvalid = 0, - eEncodingUint, ///< unsigned integer - eEncodingSint, ///< signed integer - eEncodingIEEE754, ///< float - eEncodingVector ///< vector registers + /// unsigned integer + eEncodingUint, + /// signed integer + eEncodingSint, + /// float + eEncodingIEEE754, + /// vector registers + eEncodingVector }; /// Display format definitions. @@ -170,18 +184,22 @@ enum Format { eFormatBytes, eFormatBytesWithASCII, eFormatChar, - eFormatCharPrintable, ///< Only printable characters, '.' if not printable - eFormatComplex, ///< Floating point complex type + /// Only printable characters, '.' if not printable + eFormatCharPrintable, + /// Floating point complex type + eFormatComplex, eFormatComplexFloat = eFormatComplex, - eFormatCString, ///< NULL terminated C strings + /// NULL terminated C strings + eFormatCString, eFormatDecimal, eFormatEnum, eFormatHex, eFormatHexUppercase, eFormatFloat, eFormatOctal, - eFormatOSType, ///< OS character codes encoded into an integer 'PICT' 'text' - ///< etc... + /// OS character codes encoded into an integer 'PICT' 'text' + /// etc... + eFormatOSType, eFormatUnicode16, eFormatUnicode32, eFormatUnsigned, @@ -199,20 +217,27 @@ enum Format { 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 + /// Integer complex type + eFormatComplexInteger, + /// Print characters with no single quotes, used for + /// character arrays that can contain non printable + /// characters + eFormatCharArray, + /// Describe what an address points to (func + offset + /// with file/line, symbol + offset, data, etc) + eFormatAddressInfo, + /// ISO C99 hex float string + eFormatHexFloat, + /// Disassemble an opcode + eFormatInstruction, + /// Do not print this + eFormatVoid, eFormatUnicode8, - eFormatFloat128, ///< Disambiguate between 128-bit `long double` (which uses - ///< `eFormatFloat`) and `__float128` (which uses - ///< `eFormatFloat128`). If the value being formatted is not - ///< 128 bits, then this is identical to `eFormatFloat`. + /// Disambiguate between 128-bit `long double` (which uses + /// `eFormatFloat`) and `__float128` (which uses + /// `eFormatFloat128`). If the value being formatted is not + /// 128 bits, then this is identical to `eFormatFloat`. + eFormatFloat128, kNumFormats }; @@ -239,13 +264,18 @@ enum ScriptLanguage { // 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 + /// the register numbers seen in eh_frame + eRegisterKindEHFrame = 0, + /// the register numbers seen DWARF + eRegisterKindDWARF, + /// insn ptr reg, stack ptr reg, etc not specific to + /// any particular target + eRegisterKindGeneric, + /// num used by the process plugin - e.g. by the + /// remote gdb-protocol stub program + eRegisterKindProcessPlugin, + /// lldb's internal register numbers + eRegisterKindLLDB, kNumRegisterKinds }; @@ -258,7 +288,8 @@ enum StopReason { eStopReasonWatchpoint, eStopReasonSignal, eStopReasonException, - eStopReasonExec, ///< Program was re-exec'ed + /// Program was re-exec'ed + eStopReasonExec, eStopReasonPlanComplete, eStopReasonThreadExiting, eStopReasonInstrumentation, @@ -266,7 +297,8 @@ enum StopReason { eStopReasonFork, eStopReasonVFork, eStopReasonVForkDone, - eStopReasonInterrupt, ///< Thread requested interrupt + /// Thread requested interrupt + eStopReasonInterrupt, // Indicates that execution stopped because the debugger backend relies // on recorded data and we reached the end of that data. eStopReasonHistoryBoundary, @@ -311,37 +343,59 @@ enum SearchDepth { /// 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 + /// Success + eConnectionStatusSuccess, + /// End-of-file encountered + eConnectionStatusEndOfFile, + /// Check GetError() for details + eConnectionStatusError, + /// Request timed out + eConnectionStatusTimedOut, + /// No connection + eConnectionStatusNoConnection, + /// Lost connection while connected to a + /// valid connection + eConnectionStatusLostConnection, + /// Interrupted read + eConnectionStatusInterrupted }; 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. + /// Generic errors that can be any value. + eErrorTypeGeneric, + /// Mach kernel error codes. + eErrorTypeMachKernel, + /// POSIX error codes. + eErrorTypePOSIX, + /// These are from the ExpressionResults enum. + eErrorTypeExpression, + /// Standard Win32 error codes. + eErrorTypeWin32 }; enum ValueType : uint32_t { 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 - eValueTypeVTable = 9, ///< virtual function table - eValueTypeVTableEntry = 10, ///< function pointer in virtual function table + /// globals variable + eValueTypeVariableGlobal = 1, + /// static variable + eValueTypeVariableStatic = 2, + /// function argument variables + eValueTypeVariableArgument = 3, + /// function local variables + eValueTypeVariableLocal = 4, + /// stack frame register value + eValueTypeRegister = 5, + /// A collection of stack frame register values + eValueTypeRegisterSet = 6, + /// constant result variables + eValueTypeConstResult = 7, + /// thread local storage variable + eValueTypeVariableThreadLocal = 8, + /// virtual function table + eValueTypeVTable = 9, + /// function pointer in virtual function table + eValueTypeVTableEntry = 10, }; /// A mask that we can use to check if the value type is synthetic or not. @@ -412,28 +466,37 @@ FLAGS_ENUM(Permissions){ePermissionsWritable = (1u << 0), 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 + /// reader is newly pushed onto the reader stack + eInputReaderActivate, + /// an async output event occurred; + /// the reader may want to do + /// something + eInputReaderAsynchronousOutputWritten, + /// reader is on top of the stack again after another + /// reader was popped off + eInputReaderReactivate, + /// another reader was pushed on the stack + eInputReaderDeactivate, + /// reader got one of its tokens (granularity) + eInputReaderGotToken, + /// reader received an interrupt signal (probably from + /// a control-c) + eInputReaderInterrupt, + /// reader received an EOF char (probably from a + /// control-d) + eInputReaderEndOfFile, + /// reader was just popped off the stack and is done + eInputReaderDone }; 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 + /// Locations added doesn't + /// get sent when the + /// breakpoint is created + eBreakpointEventTypeLocationsAdded = (1u << 3), eBreakpointEventTypeLocationsRemoved = (1u << 4), eBreakpointEventTypeLocationsResolved = (1u << 5), eBreakpointEventTypeEnabled = (1u << 6), @@ -481,51 +544,89 @@ enum WatchpointWriteType { /// This datatype is used in SBExpressionOptions::SetLanguage() which /// makes this type API. Do not change its underlying storage type! 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. + /// Unknown or invalid language value. + eLanguageTypeUnknown = 0x0000, + /// ISO C:1989. + eLanguageTypeC89 = 0x0001, + /// Non-standardized C, such as K&R. + eLanguageTypeC = 0x0002, + /// ISO Ada:1983. + eLanguageTypeAda83 = 0x0003, + /// ISO C++:1998. + eLanguageTypeC_plus_plus = 0x0004, + /// ISO Cobol:1974. + eLanguageTypeCobol74 = 0x0005, + /// ISO Cobol:1985. + eLanguageTypeCobol85 = 0x0006, + /// ISO Fortran 77. + eLanguageTypeFortran77 = 0x0007, + /// ISO Fortran 90. + eLanguageTypeFortran90 = 0x0008, + /// ISO Pascal:1983. + eLanguageTypePascal83 = 0x0009, + /// ISO Modula-2:1996. + eLanguageTypeModula2 = 0x000a, + /// Java. + eLanguageTypeJava = 0x000b, + /// ISO C:1999. + eLanguageTypeC99 = 0x000c, + /// ISO Ada:1995. + eLanguageTypeAda95 = 0x000d, + /// ISO Fortran 95. + eLanguageTypeFortran95 = 0x000e, + /// ANSI PL/I:1976. + eLanguageTypePLI = 0x000f, + /// Objective-C. + eLanguageTypeObjC = 0x0010, + /// Objective-C++. + eLanguageTypeObjC_plus_plus = 0x0011, + /// Unified Parallel C. + eLanguageTypeUPC = 0x0012, + /// D. + eLanguageTypeD = 0x0013, + /// Python. + eLanguageTypePython = 0x0014, // 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. + /// OpenCL. + eLanguageTypeOpenCL = 0x0015, + /// Go. + eLanguageTypeGo = 0x0016, + /// Modula 3. + eLanguageTypeModula3 = 0x0017, + /// Haskell. + eLanguageTypeHaskell = 0x0018, + /// ISO C++:2003. + eLanguageTypeC_plus_plus_03 = 0x0019, + /// ISO C++:2011. + eLanguageTypeC_plus_plus_11 = 0x001a, + /// OCaml. + eLanguageTypeOCaml = 0x001b, + /// Rust. + eLanguageTypeRust = 0x001c, + /// ISO C:2011. + eLanguageTypeC11 = 0x001d, + /// Swift. + eLanguageTypeSwift = 0x001e, + /// Julia. + eLanguageTypeJulia = 0x001f, + /// Dylan. + eLanguageTypeDylan = 0x0020, + /// ISO C++:2014. + eLanguageTypeC_plus_plus_14 = 0x0021, + /// ISO Fortran 2003. + eLanguageTypeFortran03 = 0x0022, + /// ISO Fortran 2008. + eLanguageTypeFortran08 = 0x0023, eLanguageTypeRenderScript = 0x0024, eLanguageTypeBLISS = 0x0025, eLanguageTypeKotlin = 0x0026, eLanguageTypeZig = 0x0027, eLanguageTypeCrystal = 0x0028, - eLanguageTypeC_plus_plus_17 = 0x002a, ///< ISO C++:2017. - eLanguageTypeC_plus_plus_20 = 0x002b, ///< ISO C++:2020. + /// ISO C++:2017. + eLanguageTypeC_plus_plus_17 = 0x002a, + /// ISO C++:2020. + eLanguageTypeC_plus_plus_20 = 0x002b, eLanguageTypeC17 = 0x002c, eLanguageTypeFortran18 = 0x002d, eLanguageTypeAda2005 = 0x002e, @@ -541,7 +642,8 @@ enum LanguageType { // 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, ///< Mips_Assembler. + /// Mips_Assembler. + eLanguageTypeMipsAssembler, eNumLanguageTypes }; @@ -721,8 +823,9 @@ enum SymbolType { eSymbolTypeLineHeader, eSymbolTypeScopeBegin, eSymbolTypeScopeEnd, - eSymbolTypeAdditional, ///< When symbols take more than one entry, the extra - ///< entries get this type + /// When symbols take more than one entry, the extra + /// entries get this type + eSymbolTypeAdditional, eSymbolTypeCompiler, eSymbolTypeInstrumentation, eSymbolTypeUndefined, @@ -735,20 +838,26 @@ enum SymbolType { enum SectionType { eSectionTypeInvalid, eSectionTypeCode, - eSectionTypeContainer, ///< The section contains child sections + /// The section contains child sections + eSectionTypeContainer, eSectionTypeData, - eSectionTypeDataCString, ///< Inlined C string data - eSectionTypeDataCStringPointers, ///< Pointers to C string data - eSectionTypeDataSymbolAddress, ///< Address of a symbol in the symbol table + /// Inlined C string data + eSectionTypeDataCString, + /// Pointers to C string data + eSectionTypeDataCStringPointers, + /// Address of a symbol in the symbol table + eSectionTypeDataSymbolAddress, eSectionTypeData4, eSectionTypeData8, eSectionTypeData16, eSectionTypeDataPointers, eSectionTypeDebug, eSectionTypeZeroFill, - eSectionTypeDataObjCMessageRefs, ///< Pointer to function pointer + selector - eSectionTypeDataObjCCFStrings, ///< Objective-C const CFString/NSString - ///< objects + /// Pointer to function pointer + selector + eSectionTypeDataObjCMessageRefs, + /// Objective-C const CFString/NSString + /// objects + eSectionTypeDataObjCCFStrings, eSectionTypeDWARFDebugAbbrev, eSectionTypeDWARFDebugAddr, eSectionTypeDWARFDebugAranges, @@ -768,25 +877,36 @@ enum SectionType { 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 + /// Elf SHT_SYMTAB section + eSectionTypeELFSymbolTable, + /// Elf SHT_DYNSYM section + eSectionTypeELFDynamicSymbols, + /// Elf SHT_REL or SHT_REL section + eSectionTypeELFRelocationEntries, + /// Elf SHT_DYNAMIC section + eSectionTypeELFDynamicLinkInfo, eSectionTypeEHFrame, eSectionTypeARMexidx, eSectionTypeARMextab, - eSectionTypeCompactUnwind, ///< compact unwind section in Mach-O, - ///< __TEXT,__unwind_info + /// compact unwind section in Mach-O, + /// __TEXT,__unwind_info + eSectionTypeCompactUnwind, eSectionTypeGoSymtab, - eSectionTypeAbsoluteAddress, ///< Dummy section for symbols with absolute - ///< address + /// Dummy section for symbols with absolute + /// address + eSectionTypeAbsoluteAddress, eSectionTypeDWARFGNUDebugAltLink, - eSectionTypeDWARFDebugTypes, ///< DWARF .debug_types section - eSectionTypeDWARFDebugNames, ///< DWARF v5 .debug_names + /// DWARF .debug_types section + eSectionTypeDWARFDebugTypes, + /// DWARF v5 .debug_names + eSectionTypeDWARFDebugNames, eSectionTypeOther, - eSectionTypeDWARFDebugLineStr, ///< DWARF v5 .debug_line_str - eSectionTypeDWARFDebugRngLists, ///< DWARF v5 .debug_rnglists - eSectionTypeDWARFDebugLocLists, ///< DWARF v5 .debug_loclists + /// DWARF v5 .debug_line_str + eSectionTypeDWARFDebugLineStr, + /// DWARF v5 .debug_rnglists + eSectionTypeDWARFDebugRngLists, + /// DWARF v5 .debug_loclists + eSectionTypeDWARFDebugLocLists, eSectionTypeDWARFDebugAbbrevDwo, eSectionTypeDWARFDebugInfoDwo, eSectionTypeDWARFDebugStrDwo, @@ -810,24 +930,23 @@ FLAGS_ENUM(EmulateInstructionOptions){ 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 + /// Automatically figure out which FunctionNameType bits to set based on + /// the function name. + eFunctionNameTypeAuto = (1u << 1), + /// 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. + eFunctionNameTypeFull = (1u << 2), + /// The function name only, no namespaces or arguments and no class + /// methods or selectors will be searched. + eFunctionNameTypeBase = (1u << 3), + /// Find function by method name (C++) with no namespace or arguments. + eFunctionNameTypeMethod = (1u << 4), + /// Find function by selector name (ObjC) names. + eFunctionNameTypeSelector = (1u << 5), + /// DEPRECATED: use eFunctionNameTypeAuto. + eFunctionNameTypeAny = eFunctionNameTypeAuto }; LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType) @@ -1118,34 +1237,48 @@ enum GdbSignal { /// 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 + /// The directory where the lldb.so (unix) or LLDB + /// mach-o file in LLDB.framework (MacOSX) exists + ePathTypeLLDBShlibDir, + /// Find LLDB support executable directory + /// (debugserver, etc) + ePathTypeSupportExecutableDir, + /// Find LLDB header file directory + ePathTypeHeaderDir, + /// Find Python modules (PYTHONPATH) directory + ePathTypePythonDir, + /// System plug-ins directory + ePathTypeLLDBSystemPlugins, + /// User plug-ins directory + ePathTypeLLDBUserPlugins, + /// The LLDB temp directory for this system that + /// will be cleaned up on exit + ePathTypeLLDBTempSystemDir, + /// The LLDB temp directory for this + /// system, NOT cleaned up on a process + /// exit. + ePathTypeGlobalLLDBTempSystemDir, + /// Find path to Clang builtin headers + ePathTypeClangDir }; /// 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 + /// Not sure what the type of this is + eMemberFunctionKindUnknown = 0, + /// A function used to create instances + eMemberFunctionKindConstructor, + /// A function used to tear down existing + /// instances + eMemberFunctionKindDestructor, + /// A function that applies to a specific + /// instance + eMemberFunctionKindInstanceMethod, + /// A function that applies to a type rather + /// than any instance + eMemberFunctionKindStaticMethod }; /// String matching algorithm used by SBTarget. @@ -1367,10 +1500,12 @@ enum CompletionType { /// Specifies if children need to be re-computed /// after a call to \ref SyntheticChildrenFrontEnd::Update. enum ChildCacheState { - eRefetch = 0, ///< Children need to be recomputed dynamically. + /// Children need to be recomputed dynamically. + eRefetch = 0, - eReuse = 1, ///< Children did not change and don't need to be recomputed; - ///< re-use what we computed the last time we called Update. + /// Children did not change and don't need to be recomputed; + /// re-use what we computed the last time we called Update. + eReuse = 1, }; enum SymbolDownload { @@ -1408,9 +1543,11 @@ enum DebuggerBroadcastBit { eBroadcastBitWarning = (1 << 1), eBroadcastBitError = (1 << 2), eBroadcastSymbolChange = (1 << 3), - eBroadcastBitProgressCategory = (1 << 4), ///< Deprecated + /// Deprecated + eBroadcastBitProgressCategory = (1 << 4), eBroadcastBitExternalProgress = (1 << 5), - eBroadcastBitExternalProgressCategory = (1 << 6), ///< Deprecated + /// Deprecated + eBroadcastBitExternalProgressCategory = (1 << 6), }; /// Used for expressing severity in logs and diagnostics. _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
