Enable AUTOBRIEF in doxygen configuration.

[aprantl]

Summary

This brings the LLDB configuration closer to LLVM's and removes visual clutter in the source code by removing the @brief commands from comments.

See also https://reviews.llvm.org/D46290.

[labath]

I don't really have an opinion on this, but I don't see why not.

[JDevlieghere]

Thanks Adrian, this is great. Did you run your reflow script over this patch again after this change?

docs/doxygen.cfg.in

 # comments will behave just like regular Qt-style comments
 # (thus requiring an explicit @brief command for a brief description.)
 
-JAVADOC_AUTOBRIEF      = NO
+JAVADOC_AUTOBRIEF      = YES
 
 # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
 # interpret the first line (until the first dot) of a Qt-style

 # will behave just like regular Qt-style comments (thus requiring
 # an explicit \brief command for a brief description.)
 
-QT_AUTOBRIEF           = NO
+QT_AUTOBRIEF           = YES
 
 # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
 # treat a multi-line C++ special comment block (i.e. a block of //! or ///

include/lldb/Breakpoint/Breakpoint.h

 
 //----------------------------------------------------------------------
 /// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h"
-/// @brief Class that manages logical breakpoint setting.
+/// Class that manages logical breakpoint setting.
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointList.h

 
 //----------------------------------------------------------------------
 /// @class BreakpointList BreakpointList.h "lldb/Breakpoint/BreakpointList.h"
-/// @brief This class manages a list of breakpoints.
+/// This class manages a list of breakpoints.
 //----------------------------------------------------------------------
 
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointLocation.h

 //----------------------------------------------------------------------
 /// @class BreakpointLocation BreakpointLocation.h
 /// "lldb/Breakpoint/BreakpointLocation.h"
-/// @brief Class that manages one unique (by address) instance of a logical
+/// Class that manages one unique (by address) instance of a logical
 /// breakpoint.
 //----------------------------------------------------------------------
 

include/lldb/Breakpoint/BreakpointLocationList.h

 //----------------------------------------------------------------------
 /// @class BreakpointLocationList BreakpointLocationList.h
 /// "lldb/Breakpoint/BreakpointLocationList.h"
-/// @brief This class is used by Breakpoint to manage a list of breakpoint
+/// This class is used by Breakpoint to manage a list of breakpoint
 /// locations,
 //  each breakpoint location in the list
 /// has a unique ID, and is unique by Address as well.

include/lldb/Breakpoint/BreakpointOptions.h

 //----------------------------------------------------------------------
 /// @class BreakpointOptions BreakpointOptions.h
 /// "lldb/Breakpoint/BreakpointOptions.h"
-/// @brief Class that manages the options on a breakpoint or breakpoint
+/// Class that manages the options on a breakpoint or breakpoint
 /// location.
 //----------------------------------------------------------------------
 

include/lldb/Breakpoint/BreakpointResolver.h

 //----------------------------------------------------------------------
 /// @class BreakpointResolver BreakpointResolver.h
 /// "lldb/Breakpoint/BreakpointResolver.h"
-/// @brief This class works with SearchFilter to resolve logical breakpoints to
+/// This class works with SearchFilter to resolve logical breakpoints to
 /// their
 /// of concrete breakpoint locations.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointResolverAddress.h

 //----------------------------------------------------------------------
 /// @class BreakpointResolverAddress BreakpointResolverAddress.h
 /// "lldb/Breakpoint/BreakpointResolverAddress.h"
-/// @brief This class sets breakpoints on a given Address.  This breakpoint only
+/// This class sets breakpoints on a given Address.  This breakpoint only
 /// takes
 /// once, and then it won't attempt to reset itself.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointResolverFileLine.h

 //----------------------------------------------------------------------
 /// @class BreakpointResolverFileLine BreakpointResolverFileLine.h
 /// "lldb/Breakpoint/BreakpointResolverFileLine.h"
-/// @brief This class sets breakpoints by file and line.  Optionally, it will
+/// This class sets breakpoints by file and line.  Optionally, it will
 /// look for inlined
 /// instances of the file and line specification.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointResolverFileRegex.h

 //----------------------------------------------------------------------
 /// @class BreakpointResolverFileRegex BreakpointResolverFileRegex.h
 /// "lldb/Breakpoint/BreakpointResolverFileRegex.h"
-/// @brief This class sets breakpoints by file and line.  Optionally, it will
+/// This class sets breakpoints by file and line.  Optionally, it will
 /// look for inlined
 /// instances of the file and line specification.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointResolverName.h

 //----------------------------------------------------------------------
 /// @class BreakpointResolverName BreakpointResolverName.h
 /// "lldb/Breakpoint/BreakpointResolverName.h"
-/// @brief This class sets breakpoints on a given function name, either by exact
+/// This class sets breakpoints on a given function name, either by exact
 /// match
 /// or by regular expression.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/BreakpointSite.h

 
 //----------------------------------------------------------------------
 /// @class BreakpointSite BreakpointSite.h "lldb/Breakpoint/BreakpointSite.h"
-/// @brief Class that manages the actual breakpoint that will be inserted
+/// Class that manages the actual breakpoint that will be inserted
 /// into the running program.
 ///
 /// The BreakpointSite class handles the physical breakpoint that is

include/lldb/Breakpoint/BreakpointSiteList.h

 //----------------------------------------------------------------------
 /// @class BreakpointSiteList BreakpointSiteList.h
 /// "lldb/Breakpoint/BreakpointSiteList.h"
-/// @brief Class that manages lists of BreakpointSite shared pointers.
+/// Class that manages lists of BreakpointSite shared pointers.
 //----------------------------------------------------------------------
 class BreakpointSiteList {
   // At present Process directly accesses the map of BreakpointSites so it can

include/lldb/Breakpoint/StoppointCallbackContext.h

 //----------------------------------------------------------------------
 /// @class StoppointCallbackContext StoppointCallbackContext.h
 /// "lldb/Breakpoint/StoppointCallbackContext.h"
-/// @brief Class holds the information that a breakpoint callback needs to
+/// Class holds the information that a breakpoint callback needs to
 /// evaluate this stop.
 //----------------------------------------------------------------------
 

include/lldb/Breakpoint/WatchpointList.h

 
 //----------------------------------------------------------------------
 /// @class WatchpointList WatchpointList.h "lldb/Breakpoint/WatchpointList.h"
-/// @brief This class is used by Watchpoint to manage a list of watchpoints,
+/// This class is used by Watchpoint to manage a list of watchpoints,
 //  each watchpoint in the list has a unique ID, and is unique by Address as
 //  well.
 //----------------------------------------------------------------------

include/lldb/Breakpoint/WatchpointOptions.h

 //----------------------------------------------------------------------
 /// @class WatchpointOptions WatchpointOptions.h
 /// "lldb/Breakpoint/WatchpointOptions.h"
-/// @brief Class that manages the options on a watchpoint.
+/// Class that manages the options on a watchpoint.
 //----------------------------------------------------------------------
 
 class WatchpointOptions {

include/lldb/Core/Address.h

 
 //----------------------------------------------------------------------
 /// @class Address Address.h "lldb/Core/Address.h"
-/// @brief A section + offset based address class.
+/// A section + offset based address class.
 ///
 /// The Address class allows addresses to be relative to a section
 /// that can move during runtime due to images (executables, shared

include/lldb/Core/AddressRange.h

 
 //----------------------------------------------------------------------
 /// @class AddressRange AddressRange.h "lldb/Core/AddressRange.h"
-/// @brief A section + offset based address range class.
+/// A section + offset based address range class.
 //----------------------------------------------------------------------
 class AddressRange {
 public:

include/lldb/Core/AddressResolver.h

 
 //----------------------------------------------------------------------
 /// @class AddressResolver AddressResolver.h "lldb/Core/AddressResolver.h"
-/// @brief This class works with SearchFilter to resolve function names and
+/// This class works with SearchFilter to resolve function names and
 /// source file locations to their concrete addresses.
 //----------------------------------------------------------------------
 

include/lldb/Core/AddressResolverFileLine.h

 //----------------------------------------------------------------------
 /// @class AddressResolverFileLine AddressResolverFileLine.h
 /// "lldb/Core/AddressResolverFileLine.h"
-/// @brief This class finds address for source file and line.  Optionally, it
+/// This class finds address for source file and line.  Optionally, it
 /// will look for inlined
 /// instances of the file and line specification.
 //----------------------------------------------------------------------

include/lldb/Core/AddressResolverName.h

 //----------------------------------------------------------------------
 /// @class AddressResolverName AddressResolverName.h
 /// "lldb/Core/AddressResolverName.h"
-/// @brief This class finds addresses for a given function name, either by exact
+/// This class finds addresses for a given function name, either by exact
 /// match
 /// or by regular expression.
 //----------------------------------------------------------------------

include/lldb/Core/Broadcaster.h

 
 //----------------------------------------------------------------------
 /// @class Broadcaster Broadcaster.h "lldb/Core/Broadcaster.h"
-/// @brief An event broadcasting class.
+/// An event broadcasting class.
 ///
 /// The Broadcaster class is designed to be subclassed by objects that
 /// wish to vend events in a multi-threaded environment. Broadcaster

include/lldb/Core/Communication.h

 
 //----------------------------------------------------------------------
 /// @class Communication Communication.h "lldb/Core/Communication.h"
-/// @brief An abstract communications class.
+/// An abstract communications class.
 ///
 /// Communication is an class that handles data communication
 /// between two data sources. It uses a Connection class to do the

include/lldb/Core/Debugger.h

 
 //----------------------------------------------------------------------
 /// @class Debugger Debugger.h "lldb/Core/Debugger.h"
-/// @brief A class to manage flag bits.
+/// A class to manage flag bits.
 ///
 /// Provides a global root objects for the debugger core.
 //----------------------------------------------------------------------

include/lldb/Core/EmulateInstruction.h

 //----------------------------------------------------------------------
 /// @class EmulateInstruction EmulateInstruction.h
 /// "lldb/Core/EmulateInstruction.h"
-/// @brief A class that allows emulation of CPU opcodes.
+/// A class that allows emulation of CPU opcodes.
 ///
 /// This class is a plug-in interface that is accessed through the
 /// standard static FindPlugin function call in the EmulateInstruction

include/lldb/Core/FileLineResolver.h

 
 //----------------------------------------------------------------------
 /// @class FileLineResolver FileLineResolver.h "lldb/Core/FileLineResolver.h"
-/// @brief This class finds address for source file and line.  Optionally, it
+/// This class finds address for source file and line.  Optionally, it
 /// will look for inlined
 /// instances of the file and line specification.
 //----------------------------------------------------------------------

include/lldb/Core/FileSpecList.h

 
 //----------------------------------------------------------------------
 /// @class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
-/// @brief A file collection class.
+/// A file collection class.
 ///
 /// A class that contains a mutable list of FileSpec objects.
 //----------------------------------------------------------------------

include/lldb/Core/Mangled.h

 
 //----------------------------------------------------------------------
 /// @class Mangled Mangled.h "lldb/Core/Mangled.h"
-/// @brief A class that handles mangled names.
+/// A class that handles mangled names.
 ///
 /// Designed to handle mangled names. The demangled version of any names
 /// will be computed when the demangled name is accessed through the

include/lldb/Core/Module.h

 
 //----------------------------------------------------------------------
 /// @class Module Module.h "lldb/Core/Module.h"
-/// @brief A class that describes an executable image and its associated
+/// A class that describes an executable image and its associated
 ///        object and symbol files.
 ///
 /// The module is designed to be able to select a single slice of an

 
   //----------------------------------------------------------------------
   /// @class LookupInfo Module.h "lldb/Core/Module.h"
-  /// @brief A class that encapsulates name lookup information.
+  /// A class that encapsulates name lookup information.
   ///
   /// Users can type a wide variety of partial names when setting
   /// breakpoints by name or when looking for functions by name.

include/lldb/Core/ModuleChild.h

 
 //----------------------------------------------------------------------
 /// @class ModuleChild ModuleChild.h "lldb/Core/ModuleChild.h"
-/// @brief A mix in class that contains a pointer back to the module
+/// A mix in class that contains a pointer back to the module
 ///        that owns the object which inherits from it.
 //----------------------------------------------------------------------
 class ModuleChild {

include/lldb/Core/ModuleList.h

 
 //----------------------------------------------------------------------
 /// @class ModuleList ModuleList.h "lldb/Core/ModuleList.h"
-/// @brief A collection class for Module objects.
+/// A collection class for Module objects.
 ///
 /// Modules in the module collection class are stored as reference
 /// counted shared pointers to Module objects.

include/lldb/Core/SearchFilter.h

 
 //----------------------------------------------------------------------
 /// @class Searcher SearchFilter.h "lldb/Core/SearchFilter.h"
-/// @brief Class that is driven by the SearchFilter to search the
+/// Class that is driven by the SearchFilter to search the
 /// SymbolContext space of the target program.
 //----------------------------------------------------------------------
 

 
 //----------------------------------------------------------------------
 /// @class SearchFilter SearchFilter.h "lldb/Core/SearchFilter.h"
-/// @brief Class descends through the SymbolContext space of the target,
+/// Class descends through the SymbolContext space of the target,
 /// applying a filter at each stage till it reaches the depth specified by
 /// the GetDepth method of the searcher, and calls its callback at that point.
 //----------------------------------------------------------------------

 //----------------------------------------------------------------------
 /// @class SearchFilterForUnconstrainedSearches SearchFilter.h
 /// "lldb/Core/SearchFilter.h"
-/// @brief This is a SearchFilter that searches through all modules.  It also
+/// This is a SearchFilter that searches through all modules.  It also
 /// consults the Target::ModuleIsExcludedForUnconstrainedSearches.
 //----------------------------------------------------------------------
 class SearchFilterForUnconstrainedSearches : public SearchFilter {

 
 //----------------------------------------------------------------------
 /// @class SearchFilterByModule SearchFilter.h "lldb/Core/SearchFilter.h"
-/// @brief This is a SearchFilter that restricts the search to a given module.
+/// This is a SearchFilter that restricts the search to a given module.
 //----------------------------------------------------------------------
 
 class SearchFilterByModule : public SearchFilter {

include/lldb/Expression/DWARFExpression.h

 
 //----------------------------------------------------------------------
 /// @class DWARFExpression DWARFExpression.h "lldb/Expression/DWARFExpression.h"
-/// @brief Encapsulates a DWARF location expression and interprets it.
+/// Encapsulates a DWARF location expression and interprets it.
 ///
 /// DWARF location expressions are used in two ways by LLDB.  The first
 /// use is to find entities specified in the debug information, since

include/lldb/Expression/Expression.h

 
 //----------------------------------------------------------------------
 /// @class Expression Expression.h "lldb/Expression/Expression.h"
-/// @brief Encapsulates a single expression for use in lldb
+/// Encapsulates a single expression for use in lldb
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  Expression encapsulates

include/lldb/Expression/ExpressionParser.h

 //----------------------------------------------------------------------
 /// @class ExpressionParser ExpressionParser.h
 /// "lldb/Expression/ExpressionParser.h"
-/// @brief Encapsulates an instance of a compiler that can parse expressions.
+/// Encapsulates an instance of a compiler that can parse expressions.
 ///
 /// ExpressionParser is the base class for llvm based Expression parsers.
 //----------------------------------------------------------------------

include/lldb/Expression/ExpressionTypeSystemHelper.h

 //----------------------------------------------------------------------
 /// @class ExpressionTypeSystemHelper ExpressionTypeSystemHelper.h
 /// "lldb/Expression/ExpressionTypeSystemHelper.h"
-/// @brief A helper object that the Expression can pass to its ExpressionParser
+/// A helper object that the Expression can pass to its ExpressionParser
 /// to provide generic information that
 /// any type of expression will need to supply.  It's only job is to support
 /// dyn_cast so that the expression parser

include/lldb/Expression/ExpressionVariable.h

 //----------------------------------------------------------------------
 /// @class ExpressionVariableList ExpressionVariable.h
 /// "lldb/Expression/ExpressionVariable.h"
-/// @brief A list of variable references.
+/// A list of variable references.
 ///
 /// This class stores variables internally, acting as the permanent store.
 //----------------------------------------------------------------------

include/lldb/Expression/FunctionCaller.h

 
 //----------------------------------------------------------------------
 /// @class FunctionCaller FunctionCaller.h "lldb/Expression/FunctionCaller.h"
-/// @brief Encapsulates a function that can be called.
+/// Encapsulates a function that can be called.
 ///
 /// A given FunctionCaller object can handle a single function signature.
 /// Once constructed, it can set up any number of concurrent calls to

include/lldb/Expression/IRDynamicChecks.h

 //----------------------------------------------------------------------
 /// @class DynamicCheckerFunctions IRDynamicChecks.h
 /// "lldb/Expression/IRDynamicChecks.h"
-/// @brief Encapsulates dynamic check functions used by expressions.
+/// Encapsulates dynamic check functions used by expressions.
 ///
 /// Each of the utility functions encapsulated in this class is responsible
 /// for validating some data that an expression is about to use.  Examples are:

 
 //----------------------------------------------------------------------
 /// @class IRDynamicChecks IRDynamicChecks.h "lldb/Expression/IRDynamicChecks.h"
-/// @brief Adds dynamic checks to a user-entered expression to reduce its
+/// Adds dynamic checks to a user-entered expression to reduce its
 /// likelihood of crashing
 ///
 /// When an IR function is executed in the target process, it may cause

include/lldb/Expression/IRExecutionUnit.h

 
 //----------------------------------------------------------------------
 /// @class IRExecutionUnit IRExecutionUnit.h "lldb/Expression/IRExecutionUnit.h"
-/// @brief Contains the IR and, optionally, JIT-compiled code for a module.
+/// Contains the IR and, optionally, JIT-compiled code for a module.
 ///
 /// This class encapsulates the compiled version of an expression, in IR
 /// form (for interpretation purposes) and in raw machine code form (for

   //----------------------------------------------------------------------
   /// @class JittedFunction IRExecutionUnit.h
   /// "lldb/Expression/IRExecutionUnit.h"
-  /// @brief Encapsulates a single function that has been generated by the JIT.
+  /// Encapsulates a single function that has been generated by the JIT.
   ///
   /// Functions that have been generated by the JIT are first resident in the
   /// local process, and then placed in the target process.  JittedFunction

   //----------------------------------------------------------------------
   /// @class AllocationRecord IRExecutionUnit.h
   /// "lldb/Expression/IRExecutionUnit.h"
-  /// @brief Encapsulates a single allocation request made by the JIT.
+  /// Encapsulates a single allocation request made by the JIT.
   ///
   /// Allocations made by the JIT are first queued up and then applied in
   /// bulk to the underlying process.

include/lldb/Expression/IRInterpreter.h

 
 //----------------------------------------------------------------------
 /// @class IRInterpreter IRInterpreter.h "lldb/Expression/IRInterpreter.h"
-/// @brief Attempt to interpret the function's code if it does not require
+/// Attempt to interpret the function's code if it does not require
 ///        running the target.
 ///
 /// In some cases, the IR for an expression can be evaluated entirely

include/lldb/Expression/IRMemoryMap.h

 
 //----------------------------------------------------------------------
 /// @class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h"
-/// @brief Encapsulates memory that may exist in the process but must
+/// Encapsulates memory that may exist in the process but must
 ///     also be available in the host process.
 ///
 /// This class encapsulates a group of memory objects that must be readable

include/lldb/Expression/LLVMUserExpression.h

 //----------------------------------------------------------------------
 /// @class LLVMUserExpression LLVMUserExpression.h
 /// "lldb/Expression/LLVMUserExpression.h"
-/// @brief Encapsulates a one-time expression for use in lldb.
+/// Encapsulates a one-time expression for use in lldb.
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  LLVMUserExpression is a virtual base

include/lldb/Expression/UserExpression.h

 
 //----------------------------------------------------------------------
 /// @class UserExpression UserExpression.h "lldb/Expression/UserExpression.h"
-/// @brief Encapsulates a one-time expression for use in lldb.
+/// Encapsulates a one-time expression for use in lldb.
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  UserExpression is a virtual base

include/lldb/Expression/UtilityFunction.h

 
 //----------------------------------------------------------------------
 /// @class UtilityFunction UtilityFunction.h "lldb/Expression/UtilityFunction.h"
-/// @brief Encapsulates a bit of source code that provides a function that is
+/// Encapsulates a bit of source code that provides a function that is
 /// callable
 ///
 /// LLDB uses expressions for various purposes, notably to call functions

include/lldb/Host/File.h

 
 //----------------------------------------------------------------------
 /// @class File File.h "lldb/Host/File.h"
-/// @brief A file class.
+/// A file class.
 ///
 /// A file class that divides abstracts the LLDB core from host file
 /// functionality.

include/lldb/Host/Host.h

 
 //----------------------------------------------------------------------
 /// @class Host Host.h "lldb/Host/Host.h"
-/// @brief A class that provides host computer information.
+/// A class that provides host computer information.
 ///
 /// Host is a class that answers information about the host operating
 /// system.

include/lldb/Host/HostInfo.h

 
 //----------------------------------------------------------------------
 /// @class HostInfo HostInfo.h "lldb/Host/HostInfo.h"
-/// @brief A class that provides host computer information.
+/// A class that provides host computer information.
 ///
 /// HostInfo is a class that answers information about the host operating
 /// system.  Note that HostInfo is NOT intended to be used to manipulate or

include/lldb/Host/HostProcess.h

 
 //----------------------------------------------------------------------
 /// @class HostInfo HostInfo.h "lldb/Host/HostProcess.h"
-/// @brief A class that represents a running process on the host machine.
+/// A class that represents a running process on the host machine.
 ///
 /// HostProcess allows querying and manipulation of processes running on the
 /// host machine.  It is not intended to be represent a process which is

include/lldb/Host/HostThread.h

 
 //----------------------------------------------------------------------
 /// @class HostInfo HostInfo.h "lldb/Host/HostThread.h"
-/// @brief A class that represents a thread running inside of a process on the
+/// A class that represents a thread running inside of a process on the
 ///        local machine.
 ///
 /// HostThread allows querying and manipulation of threads running on the host

include/lldb/Host/Predicate.h

 
 //----------------------------------------------------------------------
 /// @class Predicate Predicate.h "lldb/Host/Predicate.h"
-/// @brief A C++ wrapper class for providing threaded access to a value
+/// A C++ wrapper class for providing threaded access to a value
 /// of type T.
 ///
 /// A templatized class that provides multi-threaded access to a value

include/lldb/Host/ProcessRunLock.h

 
 //----------------------------------------------------------------------
 /// @class ProcessRunLock ProcessRunLock.h "lldb/Host/ProcessRunLock.h"
-/// @brief A class used to prevent the process from starting while other
+/// A class used to prevent the process from starting while other
 /// threads are accessing its data, and prevent access to its data while
 /// it is running.
 //----------------------------------------------------------------------

include/lldb/Host/PseudoTerminal.h

 
 //----------------------------------------------------------------------
 /// @class PseudoTerminal PseudoTerminal.h "lldb/Host/PseudoTerminal.h"
-/// @brief A pseudo terminal helper class.
+/// A pseudo terminal helper class.
 ///
 /// The pseudo terminal class abstracts the use of pseudo terminals on
 /// the host system.

include/lldb/Host/StringConvert.h

 
 //----------------------------------------------------------------------
 /// @namespace StringConvert StringConvert.h "lldb/Host/StringConvert.h"
-/// @brief Utility classes for converting strings into Integers
+/// Utility classes for converting strings into Integers
 //----------------------------------------------------------------------
 
 int32_t ToSInt32(const char *s, int32_t fail_value = 0, int base = 0,

include/lldb/Host/Terminal.h

 
 //----------------------------------------------------------------------
 /// @class State Terminal.h "lldb/Host/Terminal.h"
-/// @brief A terminal state saving/restoring class.
+/// A terminal state saving/restoring class.
 ///
 /// This class can be used to remember the terminal state for a file
 /// descriptor and later restore that state as it originally was.

 
 //----------------------------------------------------------------------
 /// @class TerminalStateSwitcher Terminal.h "lldb/Host/Terminal.h"
-/// @brief A TTY state switching class.
+/// A TTY state switching class.
 ///
 /// This class can be used to remember 2 TTY states for a given file
 /// descriptor and switch between the two states.

include/lldb/Host/posix/PipePosix.h

 
 //----------------------------------------------------------------------
 /// @class PipePosix PipePosix.h "lldb/Host/posix/PipePosix.h"
-/// @brief A posix-based implementation of Pipe, a class that abtracts
+/// A posix-based implementation of Pipe, a class that abtracts
 ///        unix style pipes.
 ///
 /// A class that abstracts the LLDB core from host pipe functionality.

include/lldb/Host/windows/PipeWindows.h

 
 //----------------------------------------------------------------------
 /// @class Pipe PipeWindows.h "lldb/Host/windows/PipeWindows.h"
-/// @brief A windows-based implementation of Pipe, a class that abtracts
+/// A windows-based implementation of Pipe, a class that abtracts
 ///        unix style pipes.
 ///
 /// A class that abstracts the LLDB core from host pipe functionality.

include/lldb/Interpreter/Options.h

 
 //----------------------------------------------------------------------
 /// @class Options Options.h "lldb/Interpreter/Options.h"
-/// @brief A command line option parsing protocol class.
+/// A command line option parsing protocol class.
 ///
 /// Options is designed to be subclassed to contain all needed
 /// options for a given command. The options can be parsed by calling the Parse

include/lldb/Symbol/Block.h

 
 //----------------------------------------------------------------------
 /// @class Block Block.h "lldb/Symbol/Block.h"
-/// @brief A class that describes a single lexical block.
+/// A class that describes a single lexical block.
 ///
 /// A Function object owns a BlockList object which owns one or more
 /// Block objects. The BlockList object contains a section offset

include/lldb/Symbol/CompileUnit.h

 namespace lldb_private {
 //----------------------------------------------------------------------
 /// @class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h"
-/// @brief A class that describes a compilation unit.
+/// A class that describes a compilation unit.
 ///
 /// A representation of a compilation unit, or compiled source file.
 /// The UserID of the compile unit is specified by the SymbolFile

include/lldb/Symbol/Declaration.h

 
 //----------------------------------------------------------------------
 /// @class Declaration Declaration.h "lldb/Symbol/Declaration.h"
-/// @brief A class that describes the declaration location of a
+/// A class that describes the declaration location of a
 ///        lldb object.
 ///
 /// The declarations include the file specification, line number, and

include/lldb/Symbol/Function.h

 
 //----------------------------------------------------------------------
 /// @class FunctionInfo Function.h "lldb/Symbol/Function.h"
-/// @brief A class that contains generic function information.
+/// A class that contains generic function information.
 ///
 /// This provides generic function information that gets reused between
 /// inline functions and function types.

 
 //----------------------------------------------------------------------
 /// @class InlineFunctionInfo Function.h "lldb/Symbol/Function.h"
-/// @brief A class that describes information for an inlined function.
+/// A class that describes information for an inlined function.
 //----------------------------------------------------------------------
 class InlineFunctionInfo : public FunctionInfo {
 public:

 
 //----------------------------------------------------------------------
 /// @class Function Function.h "lldb/Symbol/Function.h"
-/// @brief A class that describes a function.
+/// A class that describes a function.
 ///
 /// Functions belong to CompileUnit objects (Function::m_comp_unit),
 /// have unique user IDs (Function::UserID), know how to reconstruct

include/lldb/Symbol/LineEntry.h

 
 //----------------------------------------------------------------------
 /// @class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h"
-/// @brief A line table entry class.
+/// A line table entry class.
 //----------------------------------------------------------------------
 struct LineEntry {
   //------------------------------------------------------------------

include/lldb/Symbol/LineTable.h

 
 //----------------------------------------------------------------------
 /// @class LineSequence LineTable.h "lldb/Symbol/LineTable.h"
-/// @brief An abstract base class used during symbol table creation.
+/// An abstract base class used during symbol table creation.
 //----------------------------------------------------------------------
 class LineSequence {
 public:

 
 //----------------------------------------------------------------------
 /// @class LineTable LineTable.h "lldb/Symbol/LineTable.h"
-/// @brief A line table class.
+/// A line table class.
 //----------------------------------------------------------------------
 class LineTable {
 public:

include/lldb/Symbol/ObjectContainer.h

 
 //----------------------------------------------------------------------
 /// @class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h"
-/// @brief A plug-in interface definition class for object containers.
+/// A plug-in interface definition class for object containers.
 ///
 /// Object containers contain object files from one or more
 /// architectures, and also can contain one or more named objects.

include/lldb/Symbol/ObjectFile.h

 
 //----------------------------------------------------------------------
 /// @class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h"
-/// @brief A plug-in interface definition class for object file parsers.
+/// A plug-in interface definition class for object file parsers.
 ///
 /// Object files belong to Module objects and know how to extract
 /// information from executable, shared library, and object (.o) files

include/lldb/Symbol/SymbolContext.h

 
 //----------------------------------------------------------------------
 /// @class SymbolContext SymbolContext.h "lldb/Symbol/SymbolContext.h"
-/// @brief Defines a symbol context baton that can be handed other debug
+/// Defines a symbol context baton that can be handed other debug
 /// core functions.
 ///
 /// Many debugger functions require a context when doing lookups. This

 
 //----------------------------------------------------------------------
 /// @class SymbolContextList SymbolContext.h "lldb/Symbol/SymbolContext.h"
-/// @brief Defines a list of symbol context objects.
+/// Defines a list of symbol context objects.
 ///
 /// This class provides a common structure that can be used to contain
 /// the result of a query that can contain a multiple results. Examples

include/lldb/Symbol/SymbolContextScope.h

 //----------------------------------------------------------------------
 /// @class SymbolContextScope SymbolContextScope.h
 /// "lldb/Symbol/SymbolContextScope.h"
-/// @brief Inherit from this if your object is part of a symbol context
+/// Inherit from this if your object is part of a symbol context
 ///        and can reconstruct its symbol context.
 ///
 /// Many objects that are part of a symbol context that have pointers

include/lldb/Target/DynamicLoader.h

 
 //----------------------------------------------------------------------
 /// @class DynamicLoader DynamicLoader.h "lldb/Target/DynamicLoader.h"
-/// @brief A plug-in interface definition class for dynamic loaders.
+/// A plug-in interface definition class for dynamic loaders.
 ///
 /// Dynamic loader plug-ins track image (shared library) loading and
 /// unloading. The class is initialized given a live process that is

include/lldb/Target/ExecutionContext.h

 //----------------------------------------------------------------------
 /// @class ExecutionContextRef ExecutionContext.h
 /// "lldb/Target/ExecutionContext.h"
-/// @brief A class that holds a weak reference to an execution context.
+/// A class that holds a weak reference to an execution context.
 ///
 /// ExecutionContextRef objects are designed to hold onto an execution
 /// context that might change over time. For example, if an object wants

 
 //----------------------------------------------------------------------
 /// @class ExecutionContext ExecutionContext.h "lldb/Target/ExecutionContext.h"
-/// @brief A class that contains an execution context.
+/// A class that contains an execution context.
 ///
 /// This baton object can be passed into any function that requires
 /// a context that specifies a target, process, thread and frame.

include/lldb/Target/ExecutionContextScope.h

 //----------------------------------------------------------------------
 /// @class ExecutionContextScope ExecutionContextScope.h
 /// "lldb/Symbol/ExecutionContextScope.h"
-/// @brief Inherit from this if your object can reconstruct its
+/// Inherit from this if your object can reconstruct its
 ///        execution context.
 ///
 /// Many objects that have pointers back to parent execution context

include/lldb/Target/JITLoader.h

 
 //----------------------------------------------------------------------
 /// @class JITLoader JITLoader.h "lldb/Target/JITLoader.h"
-/// @brief A plug-in interface definition class for JIT loaders.
+/// A plug-in interface definition class for JIT loaders.
 ///
 /// Plugins of this kind listen for code generated at runtime in the
 /// target. They are very similar to dynamic loader, with the difference

include/lldb/Target/ModuleCache.h

 
 //----------------------------------------------------------------------
 /// @class ModuleCache ModuleCache.h "lldb/Target/ModuleCache.h"
-/// @brief A module cache class.
+/// A module cache class.
 ///
 /// Caches locally modules that are downloaded from remote targets.
 /// Each cached module maintains 2 views:

include/lldb/Target/OperatingSystem.h

 
 //----------------------------------------------------------------------
 /// @class OperatingSystem OperatingSystem.h "lldb/Target/OperatingSystem.h"
-/// @brief A plug-in interface definition class for halted OS helpers.
+/// A plug-in interface definition class for halted OS helpers.
 ///
 /// Halted OS plug-ins can be used by any process to locate and create
 /// OS objects, like threads, during the lifetime of a debug session.

include/lldb/Target/Platform.h

 
 //----------------------------------------------------------------------
 /// @class Platform Platform.h "lldb/Target/Platform.h"
-/// @brief A plug-in interface definition class for debug platform that
+/// A plug-in interface definition class for debug platform that
 /// includes many platform abilities such as:
 ///     @li getting platform information such as supported architectures,
 ///         supported binary file formats and more

include/lldb/Target/Process.h

 
 //----------------------------------------------------------------------
 /// @class Process Process.h "lldb/Target/Process.h"
-/// @brief A plug-in interface definition class for debugging a process.
+/// A plug-in interface definition class for debugging a process.
 //----------------------------------------------------------------------
 class Process : public std::enable_shared_from_this<Process>,
                 public ProcessProperties,

include/lldb/Target/StackFrame.h

 
 /// @class StackFrame StackFrame.h "lldb/Target/StackFrame.h"
 ///
-/// @brief This base class provides an interface to stack frames.
+/// This base class provides an interface to stack frames.
 ///
 /// StackFrames may have a Canonical Frame Address (CFA) or not.
 /// A frame may have a plain pc value or it may have a pc value + stop_id

include/lldb/Target/SystemRuntime.h

 
 //----------------------------------------------------------------------
 /// @class SystemRuntime SystemRuntime.h "lldb/Target/SystemRuntime.h"
-/// @brief A plug-in interface definition class for system runtimes.
+/// A plug-in interface definition class for system runtimes.
 ///
 /// The system runtime plugins can collect information from the system
 /// libraries during a Process' lifetime and provide information about

include/lldb/Utility/ArchSpec.h

 
 //----------------------------------------------------------------------
 /// @class ArchSpec ArchSpec.h "lldb/Utility/ArchSpec.h"
-/// @brief An architecture specification class.
+/// An architecture specification class.
 ///
 /// A class designed to be created from a cpu type and subtype, a
 /// string representation, or an llvm::Triple.  Keeping all of the

 
 //------------------------------------------------------------------
 /// @fn bool operator< (const ArchSpec& lhs, const ArchSpec& rhs)
-/// @brief Less than operator.
+/// Less than operator.
 ///
 /// Tests two ArchSpec objects to see if \a lhs is less than \a
 /// rhs.

include/lldb/Utility/Args.h

 
 //----------------------------------------------------------------------
 /// @class Args Args.h "lldb/Utility/Args.h"
-/// @brief A command line argument class.
+/// A command line argument class.
 ///
 /// The Args class is designed to be fed a command line. The
 /// command line is copied into an internal buffer and then split up

include/lldb/Utility/Baton.h

 
 //----------------------------------------------------------------------
 /// @class Baton Baton.h "lldb/Core/Baton.h"
-/// @brief A class designed to wrap callback batons so they can cleanup
+/// A class designed to wrap callback batons so they can cleanup
 ///        any acquired resources
 ///
 /// This class is designed to be used by any objects that have a

include/lldb/Utility/Connection.h

 
 //----------------------------------------------------------------------
 /// @class Connection Connection.h "lldb/Utility/Connection.h"
-/// @brief A communication connection class.
+/// A communication connection class.
 ///
 /// A class that implements that actual communication functions for
 /// connecting/disconnecting, reading/writing, and waiting for bytes

include/lldb/Utility/ConstString.h

 
 //----------------------------------------------------------------------
 /// @class ConstString ConstString.h "lldb/Utility/ConstString.h"
-/// @brief A uniqued constant string class.
+/// A uniqued constant string class.
 ///
 /// Provides an efficient way to store strings as uniqued strings. After
 /// the strings are uniqued, finding strings that are equal to one

include/lldb/Utility/DataBuffer.h

 
 //----------------------------------------------------------------------
 /// @class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
-/// @brief A pure virtual protocol class for abstracted data buffers.
+/// A pure virtual protocol class for abstracted data buffers.
 ///
 /// DataBuffer is an abstract class that gets packaged into a shared pointer
 /// that can use to implement various ways to store data (on the heap,

include/lldb/Utility/DataBufferHeap.h

 
 //----------------------------------------------------------------------
 /// @class DataBufferHeap DataBufferHeap.h "lldb/Core/DataBufferHeap.h"
-/// @brief A subclass of DataBuffer that stores a data buffer on the heap.
+/// A subclass of DataBuffer that stores a data buffer on the heap.
 ///
 /// This class keeps its data in a heap based buffer that is owned by
 /// the object. This class is best used to store chunks of data that

include/lldb/Utility/DataBufferLLVM.h

   char *GetChars() { return reinterpret_cast<char *>(GetBytes()); }
 
 private:
-  /// \brief Construct a DataBufferLLVM from \p Buffer.  \p Buffer must be a
+  /// Construct a DataBufferLLVM from \p Buffer.  \p Buffer must be a
   /// valid pointer.
   explicit DataBufferLLVM(std::unique_ptr<llvm::WritableMemoryBuffer> Buffer);
 

include/lldb/Utility/DataEncoder.h

 
 //----------------------------------------------------------------------
 /// @class DataEncoder DataEncoder.h "lldb/Core/DataEncoder.h"
-/// @brief An binary data encoding class.
+/// An binary data encoding class.
 ///
 /// DataEncoder is a class that can encode binary data (swapping if needed)
 /// to a data buffer. The data buffer can be caller owned, or can be

include/lldb/Utility/DataExtractor.h

 
 //----------------------------------------------------------------------
 /// @class DataExtractor DataExtractor.h "lldb/Core/DataExtractor.h"
-/// @brief An data extractor class.
+/// An data extractor class.
 ///
 /// DataExtractor is a class that can extract data (swapping if needed)
 /// from a data buffer. The data buffer can be caller owned, or can be

 public:
   //------------------------------------------------------------------
   /// @typedef DataExtractor::Type
-  /// @brief Type enumerations used in the dump routines.
+  /// Type enumerations used in the dump routines.
   //------------------------------------------------------------------
   typedef enum {
     TypeUInt8,   ///< Format output as unsigned 8 bit integers

include/lldb/Utility/FileSpec.h

 
 //----------------------------------------------------------------------
 /// @class FileSpec FileSpec.h "lldb/Host/FileSpec.h"
-/// @brief A file utility class.
+/// A file utility class.
 ///
 /// A file specification class that divides paths up into a directory
 /// and basename. These string values of the paths are put into uniqued

include/lldb/Utility/Flags.h

 
 //----------------------------------------------------------------------
 /// @class Flags Flags.h "lldb/Utility/Flags.h"
-/// @brief A class to manage flags.
+/// A class to manage flags.
 ///
 /// The Flags class managed flag bits and allows testing and
 /// modification of individual or multiple flag bits.

include/lldb/Utility/History.h

 
 //----------------------------------------------------------------------
 /// @class HistorySource History.h "lldb/Core/History.h"
-/// @brief A class that defines history events.
+/// A class that defines history events.
 //----------------------------------------------------------------------
 
 class HistorySource {

 
 //----------------------------------------------------------------------
 /// @class HistorySourceUInt History.h "lldb/Core/History.h"
-/// @brief A class that defines history events that are represented by
+/// A class that defines history events that are represented by
 /// unsigned integers.
 ///
 /// Any history event that is defined by a unique monotonically

include/lldb/Utility/RegularExpression.h

 //----------------------------------------------------------------------
 /// @class RegularExpression RegularExpression.h
 /// "lldb/Utility/RegularExpression.h"
-/// @brief A C++ wrapper class for regex.
+/// A C++ wrapper class for regex.
 ///
 /// This regular expression class wraps the posix regex functions
 /// \c regcomp(), \c regerror(), \c regexec(), and \c regfree() from

include/lldb/Utility/Status.h

 
 //----------------------------------------------------------------------
 /// @class Status Status.h "lldb/Utility/Status.h"
-/// @brief An error handling class.
+/// An error handling class.
 ///
 /// This class is designed to be able to hold any error code that can be
 /// encountered on a given platform. The errors are stored as a value

include/lldb/Utility/Stream.h

 
 //----------------------------------------------------------------------
 /// @class Stream Stream.h "lldb/Utility/Stream.h"
-/// @brief A stream class that can stream formatted output to a file.
+/// A stream class that can stream formatted output to a file.
 //----------------------------------------------------------------------
 class Stream {
 public:

include/lldb/Utility/StructuredData.h

 
 //----------------------------------------------------------------------
 /// @class StructuredData StructuredData.h "lldb/Utility/StructuredData.h"
-/// @brief A class which can hold structured data
+/// A class which can hold structured data
 ///
 /// The StructuredData class is designed to hold the data from a JSON
 /// or plist style file -- a serialized data structure with dictionaries

include/lldb/Utility/TildeExpressionResolver.h

 public:
   virtual ~TildeExpressionResolver();
 
-  /// \brief Resolve a Tilde Expression contained according to bash rules.
+  /// Resolve a Tilde Expression contained according to bash rules.
   ///
   /// \param Expr Contains the tilde expression to resolve.  A valid tilde
   ///             expression must begin with a tilde and contain only non

   virtual bool ResolveExact(llvm::StringRef Expr,
                             llvm::SmallVectorImpl<char> &Output) = 0;
 
-  /// \brief Auto-complete a tilde expression with all matching values.
+  /// Auto-complete a tilde expression with all matching values.
   ///
   /// \param Expr Contains the tilde expression prefix to resolve.  See
   ///             ResolveExact() for validity rules.

   virtual bool ResolvePartial(llvm::StringRef Expr,
                               llvm::StringSet<> &Output) = 0;
 
-  /// \brief Resolve an entire path that begins with a tilde expression,
+  /// Resolve an entire path that begins with a tilde expression,
   /// replacing the username portion with the matched result.
   bool ResolveFullPath(llvm::StringRef Expr,
                        llvm::SmallVectorImpl<char> &Output);

include/lldb/Utility/Timer.h

 
 //----------------------------------------------------------------------
 /// @class Timer Timer.h "lldb/Utility/Timer.h"
-/// @brief A timer class that simplifies common timing metrics.
+/// A timer class that simplifies common timing metrics.
 //----------------------------------------------------------------------
 
 class Timer {

include/lldb/Utility/UserID.h

 
 //----------------------------------------------------------------------
 /// @class UserID UserID.h "lldb/Core/UserID.h"
-/// @brief A mix in class that contains a generic user ID.
+/// A mix in class that contains a generic user ID.
 ///
 /// UserID is designed as a mix in class that can contain an integer
 /// based unique identifier for a variety of objects in lldb.

include/lldb/lldb-private-defines.h

 #endif
 
 /// \macro LLVM_FALLTHROUGH
-/// \brief Marks an empty statement preceding a deliberate switch fallthrough.
+/// Marks an empty statement preceding a deliberate switch fallthrough.
 #if __has_cpp_attribute(clang::fallthrough)
 #define LLVM_FALLTHROUGH [[clang::fallthrough]]
 #else

source/Expression/IRDynamicChecks.cpp

 
 //----------------------------------------------------------------------
 /// @class Instrumenter IRDynamicChecks.cpp
-/// @brief Finds and instruments individual LLVM IR instructions
+/// Finds and instruments individual LLVM IR instructions
 ///
 /// When instrumenting LLVM IR, it is frequently desirable to first search
 /// for instructions, and then later modify them.  This way iterators

source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h

 }
 
 /// @class HexagonDYLDRendezvous
-/// @brief Interface to the runtime linker.
+/// Interface to the runtime linker.
 ///
 /// A structure is present in a processes memory space which is updated by the
 /// runtime liker each time a module is loaded or unloaded.  This class provides

 
   void DumpToLog(lldb_private::Log *log) const;
 
-  /// @brief Constants describing the state of the rendezvous.
+  /// Constants describing the state of the rendezvous.
   ///
   /// @see GetState().
   enum RendezvousState {

     eDelete,
   };
 
-  /// @brief Structure representing the shared objects currently loaded into
+  /// Structure representing the shared objects currently loaded into
   /// the inferior process.
   ///
   /// This object is a rough analogue to the struct link_map object which

source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h

 }
 
 /// @class AuxVector
-/// @brief Represents a processes auxiliary vector.
+/// Represents a processes auxiliary vector.
 ///
 /// When a process is loaded on Linux a vector of values is placed onto the
 /// stack communicating operating system specific information.  On construction

source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h

 }
 
 /// @class DYLDRendezvous
-/// @brief Interface to the runtime linker.
+/// Interface to the runtime linker.
 ///
 /// A structure is present in a processes memory space which is updated by the
 /// runtime liker each time a module is loaded or unloaded.  This class provides

 
   void DumpToLog(lldb_private::Log *log) const;
 
-  /// @brief Constants describing the state of the rendezvous.
+  /// Constants describing the state of the rendezvous.
   ///
   /// @see GetState().
   enum RendezvousState { eConsistent, eAdd, eDelete };
 
-  /// @brief Structure representing the shared objects currently loaded into
+  /// Structure representing the shared objects currently loaded into
   /// the inferior process.
   ///
   /// This object is a rough analogue to the struct link_map object which

source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h

 //----------------------------------------------------------------------
 /// @class ASTResultSynthesizer ASTResultSynthesizer.h
 /// "lldb/Expression/ASTResultSynthesizer.h"
-/// @brief Adds a result variable declaration to the ASTs for an expression.
+/// Adds a result variable declaration to the ASTs for an expression.
 ///
 /// Users expect the expression "i + 3" to return a result, even if a result
 /// variable wasn't specifically declared.  To fulfil this requirement, LLDB

source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h

 //----------------------------------------------------------------------
 /// @class ASTStructExtractor ASTStructExtractor.h
 /// "lldb/Expression/ASTStructExtractor.h"
-/// @brief Extracts and describes the argument structure for a wrapped function.
+/// Extracts and describes the argument structure for a wrapped function.
 ///
 /// This pass integrates with ClangFunctionCaller, which calls functions with
 /// custom

source/Plugins/ExpressionParser/Clang/ClangASTSource.h

 
 //----------------------------------------------------------------------
 /// @class ClangASTSource ClangASTSource.h "lldb/Expression/ClangASTSource.h"
-/// @brief Provider for named objects defined in the debug info for Clang
+/// Provider for named objects defined in the debug info for Clang
 ///
 /// As Clang parses an expression, it may encounter names that are not
 /// defined inside the expression, including variables, functions, and

   //----------------------------------------------------------------------
   /// @class ClangASTSourceProxy ClangASTSource.h
   /// "lldb/Expression/ClangASTSource.h"
-  /// @brief Proxy for ClangASTSource
+  /// Proxy for ClangASTSource
   ///
   /// Clang AST contexts like to own their AST sources, so this is a
   /// state-free proxy object.

 
 //----------------------------------------------------------------------
 /// @class NameSearchContext ClangASTSource.h "lldb/Expression/ClangASTSource.h"
-/// @brief Container for all objects relevant to a single name lookup
+/// Container for all objects relevant to a single name lookup
 ///
 /// LLDB needs to create Decls for entities it finds.  This class communicates
 /// what name is being searched for and provides helper functions to construct

source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

 //----------------------------------------------------------------------
 /// @class ClangExpressionDeclMap ClangExpressionDeclMap.h
 /// "lldb/Expression/ClangExpressionDeclMap.h"
-/// @brief Manages named entities that are defined in LLDB's debug information.
+/// Manages named entities that are defined in LLDB's debug information.
 ///
 /// The Clang parser uses the ClangASTSource as an interface to request named
 /// entities from outside an expression.  The ClangASTSource reports back,

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h

 //----------------------------------------------------------------------
 /// @class ClangExpressionParser ClangExpressionParser.h
 /// "lldb/Expression/ClangExpressionParser.h"
-/// @brief Encapsulates an instance of Clang that can parse expressions.
+/// Encapsulates an instance of Clang that can parse expressions.
 ///
 /// ClangExpressionParser is responsible for preparing an instance of
 /// ClangExpression for execution.  ClangExpressionParser uses ClangExpression

source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

 //----------------------------------------------------------------------
 /// @class ClangExpressionVariable ClangExpressionVariable.h
 /// "lldb/Expression/ClangExpressionVariable.h"
-/// @brief Encapsulates one variable for the expression parser.
+/// Encapsulates one variable for the expression parser.
 ///
 /// The expression parser uses variables in three different contexts:
 ///

source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h

 //----------------------------------------------------------------------
 /// @class ClangFunctionCaller ClangFunctionCaller.h
 /// "lldb/Expression/ClangFunctionCaller.h"
-/// @brief Encapsulates a function that can be called.
+/// Encapsulates a function that can be called.
 ///
 /// A given ClangFunctionCaller object can handle a single function signature.
 /// Once constructed, it can set up any number of concurrent calls to

source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

 //----------------------------------------------------------------------
 /// @class ClangPersistentVariables ClangPersistentVariables.h
 /// "lldb/Expression/ClangPersistentVariables.h"
-/// @brief Manages persistent values that need to be preserved between
+/// Manages persistent values that need to be preserved between
 /// expression invocations.
 ///
 /// A list of variables that can be accessed and updated by any expression.  See

source/Plugins/ExpressionParser/Clang/ClangUserExpression.h

 //----------------------------------------------------------------------
 /// @class ClangUserExpression ClangUserExpression.h
 /// "lldb/Expression/ClangUserExpression.h"
-/// @brief Encapsulates a single expression for use with Clang
+/// Encapsulates a single expression for use with Clang
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUserExpression encapsulates

source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h

 //----------------------------------------------------------------------
 /// @class ClangUtilityFunction ClangUtilityFunction.h
 /// "lldb/Expression/ClangUtilityFunction.h"
-/// @brief Encapsulates a single expression for use with Clang
+/// Encapsulates a single expression for use with Clang
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  ClangUtilityFunction encapsulates

source/Plugins/ExpressionParser/Clang/IRForTarget.h

 
 //----------------------------------------------------------------------
 /// @class IRForTarget IRForTarget.h "lldb/Expression/IRForTarget.h"
-/// @brief Transforms the IR for a function to run in the target
+/// Transforms the IR for a function to run in the target
 ///
 /// Once an expression has been parsed and converted to IR, it can run
 /// in two contexts: interpreted by LLDB as a DWARF location expression,

source/Plugins/ExpressionParser/Go/GoUserExpression.h

 //----------------------------------------------------------------------
 /// @class GoUserExpression GoUserExpression.h
 /// "lldb/Expression/GoUserExpression.h"
-/// @brief Encapsulates a single expression for use with Go
+/// Encapsulates a single expression for use with Go
 ///
 /// LLDB uses expressions for various purposes, notably to call functions
 /// and as a backend for the expr command.  GoUserExpression encapsulates

source/Plugins/ObjectFile/ELF/ELFHeader.h

 //===----------------------------------------------------------------------===//
 //
 /// @file
-/// @brief Generic structures and typedefs for ELF files.
+/// Generic structures and typedefs for ELF files.
 ///
 /// This file provides definitions for the various entities comprising an ELF
 /// file.  The structures are generic in the sense that they do not correspond

 
 //------------------------------------------------------------------------------
 /// @class ELFHeader
-/// @brief Generic representation of an ELF file header.
+/// Generic representation of an ELF file header.
 ///
 /// This object is used to identify the general attributes on an ELF file and to
 /// locate additional sections within the file.

 
 //------------------------------------------------------------------------------
 /// @class ELFSectionHeader
-/// @brief Generic representation of an ELF section header.
+/// Generic representation of an ELF section header.
 struct ELFSectionHeader {
   elf_word sh_name;       ///< Section name string index.
   elf_word sh_type;       ///< Section type.

 
 //------------------------------------------------------------------------------
 /// @class ELFProgramHeader
-/// @brief Generic representation of an ELF program header.
+/// Generic representation of an ELF program header.
 struct ELFProgramHeader {
   elf_word p_type;    ///< Type of program segment.
   elf_word p_flags;   ///< Segment attributes.

 
 //------------------------------------------------------------------------------
 /// @class ELFSymbol
-/// @brief Represents a symbol within an ELF symbol table.
+/// Represents a symbol within an ELF symbol table.
 struct ELFSymbol {
   elf_addr st_value;      ///< Absolute or relocatable address.
   elf_xword st_size;      ///< Size of the symbol or zero.

 
 //------------------------------------------------------------------------------
 /// @class ELFDynamic
-/// @brief Represents an entry in an ELF dynamic table.
+/// Represents an entry in an ELF dynamic table.
 struct ELFDynamic {
   elf_sxword d_tag; ///< Type of dynamic table entry.
   union {

 
 //------------------------------------------------------------------------------
 /// @class ELFRel
-/// @brief Represents a relocation entry with an implicit addend.
+/// Represents a relocation entry with an implicit addend.
 struct ELFRel {
   elf_addr r_offset; ///< Address of reference.
   elf_xword r_info;  ///< symbol index and type of relocation.

 
 //------------------------------------------------------------------------------
 /// @class ELFRela
-/// @brief Represents a relocation entry with an explicit addend.
+/// Represents a relocation entry with an explicit addend.
 struct ELFRela {
   elf_addr r_offset;   ///< Address of reference.
   elf_xword r_info;    ///< Symbol index and type of relocation.

source/Plugins/ObjectFile/ELF/ObjectFileELF.h

 
 //------------------------------------------------------------------------------
 /// @class ObjectFileELF
-/// @brief Generic ELF object file reader.
+/// Generic ELF object file reader.
 ///
 /// This class provides a generic ELF (32/64 bit) reader plugin implementing the
 /// ObjectFile protocol.

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

 
 //===----------------------------------------------------------------------===//
 /// @class ELFRelocation
-/// @brief Generic wrapper for ELFRel and ELFRela.
+/// Generic wrapper for ELFRel and ELFRela.
 ///
 /// This helper class allows us to parse both ELFRel and ELFRela relocation
 /// entries in a generic manner.

source/Plugins/Process/Darwin/NativeProcessDarwin.h

 namespace process_darwin {
 
 /// @class NativeProcessDarwin
-/// @brief Manages communication with the inferior (debugee) process.
+/// Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior
 /// process for debugging.

source/Plugins/Process/FreeBSD/FreeBSDThread.h

 
 //------------------------------------------------------------------------------
 // @class FreeBSDThread
-// @brief Abstraction of a FreeBSD thread.
+// Abstraction of a FreeBSD thread.
 class FreeBSDThread : public lldb_private::Thread {
 public:
   //------------------------------------------------------------------

source/Plugins/Process/FreeBSD/POSIXStopInfo.h

 
 //===----------------------------------------------------------------------===//
 /// @class POSIXStopInfo
-/// @brief Simple base class for all POSIX-specific StopInfo objects.
+/// Simple base class for all POSIX-specific StopInfo objects.
 ///
 class POSIXStopInfo : public lldb_private::StopInfo {
 public:

 
 //===----------------------------------------------------------------------===//
 /// @class POSIXLimboStopInfo
-/// @brief Represents the stop state of a process ready to exit.
+/// Represents the stop state of a process ready to exit.
 ///
 class POSIXLimboStopInfo : public POSIXStopInfo {
 public:

 
 //===----------------------------------------------------------------------===//
 /// @class POSIXNewThreadStopInfo
-/// @brief Represents the stop state of process when a new thread is spawned.
+/// Represents the stop state of process when a new thread is spawned.
 ///
 
 class POSIXNewThreadStopInfo : public POSIXStopInfo {

source/Plugins/Process/FreeBSD/ProcessMonitor.h

 class Operation;
 
 /// @class ProcessMonitor
-/// @brief Manages communication with the inferior (debugee) process.
+/// Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior process for
 /// debugging.

 
   /// @class LauchArgs
   ///
-  /// @brief Simple structure to pass data to the thread responsible for
+  /// Simple structure to pass data to the thread responsible for
   /// launching a child process.
   struct LaunchArgs : OperationArgs {
     LaunchArgs(ProcessMonitor *monitor, lldb_private::Module *module,

source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

 
 //------------------------------------------------------------------------------
 /// @class Operation
-/// @brief Represents a ProcessMonitor operation.
+/// Represents a ProcessMonitor operation.
 ///
 /// Under FreeBSD, it is not possible to ptrace() from any other thread but the
 /// one that spawned or attached to the process from the start.  Therefore, when

 
 //------------------------------------------------------------------------------
 /// @class ReadOperation
-/// @brief Implements ProcessMonitor::ReadMemory.
+/// Implements ProcessMonitor::ReadMemory.
 class ReadOperation : public Operation {
 public:
   ReadOperation(lldb::addr_t addr, void *buff, size_t size, Status &error,

 
 //------------------------------------------------------------------------------
 /// @class WriteOperation
-/// @brief Implements ProcessMonitor::WriteMemory.
+/// Implements ProcessMonitor::WriteMemory.
 class WriteOperation : public Operation {
 public:
   WriteOperation(lldb::addr_t addr, const void *buff, size_t size,

 
 //------------------------------------------------------------------------------
 /// @class ReadRegOperation
-/// @brief Implements ProcessMonitor::ReadRegisterValue.
+/// Implements ProcessMonitor::ReadRegisterValue.
 class ReadRegOperation : public Operation {
 public:
   ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,

 
 //------------------------------------------------------------------------------
 /// @class WriteRegOperation
-/// @brief Implements ProcessMonitor::WriteRegisterValue.
+/// Implements ProcessMonitor::WriteRegisterValue.
 class WriteRegOperation : public Operation {
 public:
   WriteRegOperation(lldb::tid_t tid, unsigned offset,

 
 //------------------------------------------------------------------------------
 /// @class ReadDebugRegOperation
-/// @brief Implements ProcessMonitor::ReadDebugRegisterValue.
+/// Implements ProcessMonitor::ReadDebugRegisterValue.
 class ReadDebugRegOperation : public Operation {
 public:
   ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size,

 
 //------------------------------------------------------------------------------
 /// @class WriteDebugRegOperation
-/// @brief Implements ProcessMonitor::WriteDebugRegisterValue.
+/// Implements ProcessMonitor::WriteDebugRegisterValue.
 class WriteDebugRegOperation : public Operation {
 public:
   WriteDebugRegOperation(lldb::tid_t tid, unsigned offset,

 
 //------------------------------------------------------------------------------
 /// @class ReadGPROperation
-/// @brief Implements ProcessMonitor::ReadGPR.
+/// Implements ProcessMonitor::ReadGPR.
 class ReadGPROperation : public Operation {
 public:
   ReadGPROperation(lldb::tid_t tid, void *buf, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class ReadFPROperation
-/// @brief Implements ProcessMonitor::ReadFPR.
+/// Implements ProcessMonitor::ReadFPR.
 class ReadFPROperation : public Operation {
 public:
   ReadFPROperation(lldb::tid_t tid, void *buf, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class WriteGPROperation
-/// @brief Implements ProcessMonitor::WriteGPR.
+/// Implements ProcessMonitor::WriteGPR.
 class WriteGPROperation : public Operation {
 public:
   WriteGPROperation(lldb::tid_t tid, void *buf, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class WriteFPROperation
-/// @brief Implements ProcessMonitor::WriteFPR.
+/// Implements ProcessMonitor::WriteFPR.
 class WriteFPROperation : public Operation {
 public:
   WriteFPROperation(lldb::tid_t tid, void *buf, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class ResumeOperation
-/// @brief Implements ProcessMonitor::Resume.
+/// Implements ProcessMonitor::Resume.
 class ResumeOperation : public Operation {
 public:
   ResumeOperation(uint32_t signo, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class SingleStepOperation
-/// @brief Implements ProcessMonitor::SingleStep.
+/// Implements ProcessMonitor::SingleStep.
 class SingleStepOperation : public Operation {
 public:
   SingleStepOperation(uint32_t signo, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class LwpInfoOperation
-/// @brief Implements ProcessMonitor::GetLwpInfo.
+/// Implements ProcessMonitor::GetLwpInfo.
 class LwpInfoOperation : public Operation {
 public:
   LwpInfoOperation(lldb::tid_t tid, void *info, bool &result, int &ptrace_err)

 
 //------------------------------------------------------------------------------
 /// @class ThreadSuspendOperation
-/// @brief Implements ProcessMonitor::ThreadSuspend.
+/// Implements ProcessMonitor::ThreadSuspend.
 class ThreadSuspendOperation : public Operation {
 public:
   ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class EventMessageOperation
-/// @brief Implements ProcessMonitor::GetEventMessage.
+/// Implements ProcessMonitor::GetEventMessage.
 class EventMessageOperation : public Operation {
 public:
   EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result)

 
 //------------------------------------------------------------------------------
 /// @class KillOperation
-/// @brief Implements ProcessMonitor::Kill.
+/// Implements ProcessMonitor::Kill.
 class KillOperation : public Operation {
 public:
   KillOperation(bool &result) : m_result(result) {}

 
 //------------------------------------------------------------------------------
 /// @class DetachOperation
-/// @brief Implements ProcessMonitor::Detach.
+/// Implements ProcessMonitor::Detach.
 class DetachOperation : public Operation {
 public:
   DetachOperation(Status &result) : m_error(result) {}

source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h

 //------------------------------------------------------------------------------
 /// @class POSIXBreakpointProtocol
 ///
-/// @brief Extends RegisterClass with a few virtual operations useful on POSIX.
+/// Extends RegisterClass with a few virtual operations useful on POSIX.
 class POSIXBreakpointProtocol {
 public:
   POSIXBreakpointProtocol() { m_watchpoints_initialized = false; }

source/Plugins/Process/Linux/NativeProcessLinux.h

 
 namespace process_linux {
 /// @class NativeProcessLinux
-/// @brief Manages communication with the inferior (debugee) process.
+/// Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior process for
 /// debugging.

source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

 namespace lldb_private {
 namespace process_netbsd {
 /// @class NativeProcessNetBSD
-/// @brief Manages communication with the inferior (debugee) process.
+/// Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior process for
 /// debugging.

source/Plugins/Process/Utility/HistoryThread.h

 
 //----------------------------------------------------------------------
 /// @class HistoryThread HistoryThread.h "HistoryThread.h"
-/// @brief A thread object representing a backtrace from a previous point in the
+/// A thread object representing a backtrace from a previous point in the
 /// process execution
 ///
 /// This subclass of Thread is used to provide a backtrace from earlier in

source/Plugins/Process/Utility/RegisterInfoInterface.h

 ///------------------------------------------------------------------------------
 /// @class RegisterInfoInterface
 ///
-/// @brief RegisterInfo interface to patch RegisterInfo structure for archs.
+/// RegisterInfo interface to patch RegisterInfo structure for archs.
 ///------------------------------------------------------------------------------
 class RegisterInfoInterface {
 public:

source/Symbol/ClangASTContext.cpp

 clang::FunctionTemplateDecl *ClangASTContext::CreateFunctionTemplateDecl(
     clang::DeclContext *decl_ctx, clang::FunctionDecl *func_decl,
     const char *name, const TemplateParameterInfos &template_param_infos) {
-  //    /// \brief Create a function template node.
+  //    /// Create a function template node.
   ASTContext *ast = getASTContext();
 
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;

source/Utility/FastDemangle.cpp

 
 namespace {
 
-/// @brief Represents the collection of qualifiers on a type
+/// Represents the collection of qualifiers on a type
 
 enum Qualifiers {
   QualifierNone = 0,

   QualifierPointer = 32
 };
 
-/// @brief Categorizes the recognized operators
+/// Categorizes the recognized operators
 
 enum class OperatorKind {
   Unary,

   NoMatch
 };
 
-/// @brief Represents one of the recognized two-character operator
+/// Represents one of the recognized two-character operator
 /// abbreviations used when parsing operators as names and expressions
 
 struct Operator {

   OperatorKind kind;
 };
 
-/// @brief Represents a range of characters in the output buffer, typically for
+/// Represents a range of characters in the output buffer, typically for
 /// use with RewriteRange()
 
 struct BufferRange {

   int length;
 };
 
-/// @brief Transient state required while parsing a name
+/// Transient state required while parsing a name
 
 struct NameState {
   bool parse_function_params;

   BufferRange last_name_range;
 };
 
-/// @brief LLDB's fast C++ demangler
+/// LLDB's fast C++ demangler
 ///
 /// This is an incomplete implementation designed to speed up the demangling
 /// process that is often a bottleneck when LLDB stops a process for the first

   // Public API
   //----------------------------------------------------
 
-  /// @brief Create a SymbolDemangler
+  /// Create a SymbolDemangler
   ///
   /// The newly created demangler allocates and owns scratch memory sufficient
   /// for demangling typical symbols.  Additional memory will be allocated if

     m_owns_m_rewrite_ranges = true;
   }
 
-  /// @brief Create a SymbolDemangler that uses provided scratch memory
+  /// Create a SymbolDemangler that uses provided scratch memory
   ///
   /// The provided memory is not owned by the demangler.  It will be
   /// overwritten during calls to GetDemangledCopy() but can be used for

     m_owns_buffer = false;
   }
 
-  /// @brief Destroys the SymbolDemangler and deallocates any scratch
+  /// Destroys the SymbolDemangler and deallocates any scratch
   /// memory that it owns
 
   ~SymbolDemangler() {

   int highwater_buffer = 0;
 #endif
 
-  /// @brief Parses the provided mangled name and returns a newly allocated
+  /// Parses the provided mangled name and returns a newly allocated
   /// demangling
   ///
   /// @param mangled_name Valid null-terminated C++ mangled name following

tools/debugserver/source/JSONGenerator.h

 
 //----------------------------------------------------------------------
 /// @class JSONGenerator JSONGenerator.h
-/// @brief A class which can construct structured data for the sole purpose
+/// A class which can construct structured data for the sole purpose
 /// of printing it in JSON format.
 ///
 /// A stripped down version of lldb's StructuredData objects which are much

tools/intel-features/intel-pt/Decoder.h

 namespace ptdecoder_private {
 //----------------------------------------------------------------------
 /// @class Instruction
-/// @brief Represents an assembly instruction containing raw
+/// Represents an assembly instruction containing raw
 ///     instruction bytes, instruction address along with information
 ///     regarding execution flow context and Intel(R) Processor Trace
 ///     context.

 
 //---------------------------------------------------------------------------
 /// @class InstructionList
-/// @brief Represents a list of assembly instructions. Each instruction is of
+/// Represents a list of assembly instructions. Each instruction is of
 ///     type Instruction.
 //---------------------------------------------------------------------------
 class InstructionList {

 
 //----------------------------------------------------------------------
 /// @class TraceOptions
-/// @brief Provides Intel(R) Processor Trace specific configuration options and
+/// Provides Intel(R) Processor Trace specific configuration options and
 ///     other information obtained by decoding and post-processing the trace
 ///     data. Currently, this information comprises of the total number of
 ///     assembly instructions executed for an inferior.

 
 //----------------------------------------------------------------------
 /// @class Decoder
-/// @brief This class makes use of Intel(R) Processor Trace hardware feature
+/// This class makes use of Intel(R) Processor Trace hardware feature
 ///     (implememted inside LLDB) to gather trace data for an inferior (being
 ///     debugged with LLDB) to provide meaningful information out of it.
 ///

tools/intel-features/intel-pt/PTDecoder.h

 
 //----------------------------------------------------------------------
 /// @class PTInstruction
-/// @brief Represents an assembly instruction containing raw
+/// Represents an assembly instruction containing raw
 ///     instruction bytes, instruction address along with information
 ///     regarding execution flow context and Intel(R) Processor Trace
 ///     context.

 
 //---------------------------------------------------------------------------
 /// @class PTInstructionList
-/// @brief Represents a list of assembly instructions. Each instruction is of
+/// Represents a list of assembly instructions. Each instruction is of
 ///     type PTInstruction.
 //---------------------------------------------------------------------------
 class PTInstructionList {

 
 //----------------------------------------------------------------------
 /// @class PTTraceOptions
-/// @brief Provides configuration options like trace type, trace buffer size,
+/// Provides configuration options like trace type, trace buffer size,
 ///     meta data buffer size along with other Intel(R) Processor Trace
 ///     specific options.
 //----------------------------------------------------------------------

 
 //----------------------------------------------------------------------
 /// @class PTDecoder
-/// @brief This class makes use of Intel(R) Processor Trace hardware feature
+/// This class makes use of Intel(R) Processor Trace hardware feature
 ///     (implememted inside LLDB) to gather trace data for an inferior (being
 ///     debugged with LLDB) to provide meaningful information out of it.
 ///