diff options
| author | Adrian Prantl <aprantl@apple.com> | 2018-05-02 16:55:16 +0000 |
|---|---|---|
| committer | Adrian Prantl <aprantl@apple.com> | 2018-05-02 16:55:16 +0000 |
| commit | 062371defaacc01b03455bf9621ea05288636808 (patch) | |
| tree | 40690517e512478cc0d7447a6464670708da09f9 /lldb/source | |
| parent | 1421de57625172a91645413aa64ae98793e7f08e (diff) | |
Enable AUTOBRIEF in doxygen configuration.
This brings the LLDB configuration closer to LLVM's and removes visual
clutter in the source code by removing the @brief commands from
comments.
This patch also reflows the paragraphs in all doxygen comments.
See also https://reviews.llvm.org/D46290.
Differential Revision: https://reviews.llvm.org/D46321
Diffstat (limited to 'lldb/source')
31 files changed, 349 insertions, 362 deletions
diff --git a/lldb/source/Expression/IRDynamicChecks.cpp b/lldb/source/Expression/IRDynamicChecks.cpp index 0c8cba2050c..e0a7dca4113 100644 --- a/lldb/source/Expression/IRDynamicChecks.cpp +++ b/lldb/source/Expression/IRDynamicChecks.cpp @@ -109,17 +109,17 @@ static std::string PrintValue(llvm::Value *V, bool truncate = false) { //---------------------------------------------------------------------- /// @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 -/// remain intact, and multiple passes can look at the same code base without +/// When instrumenting LLVM IR, it is frequently desirable to first search for +/// instructions, and then later modify them. This way iterators remain +/// intact, and multiple passes can look at the same code base without /// treading on each other's toes. /// /// The Instrumenter class implements this functionality. A client first -/// calls Inspect on a function, which populates a list of instructions to -/// be instrumented. Then, later, when all passes' Inspect functions have -/// been called, the client calls Instrument, which adds the desired +/// calls Inspect on a function, which populates a list of instructions to be +/// instrumented. Then, later, when all passes' Inspect functions have been +/// called, the client calls Instrument, which adds the desired /// instrumentation. /// /// A subclass of Instrumenter must override InstrumentInstruction, which @@ -200,8 +200,8 @@ protected: } //------------------------------------------------------------------ - /// Determine whether a single instruction is interesting to - /// instrument, and, if so, call RegisterInstruction + /// Determine whether a single instruction is interesting to instrument, + /// and, if so, call RegisterInstruction /// /// @param[in] i /// The instruction to be inspected. @@ -250,8 +250,8 @@ protected: } //------------------------------------------------------------------ - /// Build a function pointer for a function with signature - /// void (*)(uint8_t*) with a given address + /// Build a function pointer for a function with signature void + /// (*)(uint8_t*) with a given address /// /// @param[in] start_address /// The address of the function. @@ -275,8 +275,8 @@ protected: } //------------------------------------------------------------------ - /// Build a function pointer for a function with signature - /// void (*)(uint8_t*, uint8_t*) with a given address + /// Build a function pointer for a function with signature void + /// (*)(uint8_t*, uint8_t*) with a given address /// /// @param[in] start_address /// The address of the function. diff --git a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h index b68f89b9ce8..9e7129461f0 100644 --- a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h +++ b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h @@ -24,12 +24,12 @@ class Process; } /// @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 -/// an interface to this structure and maintains a consistent snapshot of the -/// currently loaded modules. +/// runtime liker each time a module is loaded or unloaded. This class +/// provides an interface to this structure and maintains a consistent +/// snapshot of the currently loaded modules. class HexagonDYLDRendezvous { // This structure is used to hold the contents of the debug rendezvous @@ -124,7 +124,7 @@ public: 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 { @@ -133,8 +133,8 @@ public: eDelete, }; - /// @brief Structure representing the shared objects currently loaded into - /// the inferior process. + /// Structure representing the shared objects currently loaded into the + /// inferior process. /// /// This object is a rough analogue to the struct link_map object which /// actually lives in the inferiors memory. @@ -198,7 +198,8 @@ protected: /// List of SOEntry objects corresponding to the current link map state. SOEntryList m_soentries; - /// List of SOEntry's added to the link map since the last call to Resolve(). + /// List of SOEntry's added to the link map since the last call to + /// Resolve(). SOEntryList m_added_soentries; /// List of SOEntry's removed from the link map since the last call to diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h index cf9da080835..3b06fe18f0c 100644 --- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h +++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h @@ -22,12 +22,12 @@ class DataExtractor; } /// @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 -/// this class locates and parses this information and provides a simple -/// read-only interface to the entries found. +/// stack communicating operating system specific information. On +/// construction this class locates and parses this information and provides a +/// simple read-only interface to the entries found. class AuxVector { public: @@ -41,8 +41,9 @@ public: }; /// Constants describing the type of entry. - /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX information. - /// Added AUXV prefix to avoid potential conflicts with system-defined macros + /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX + /// information. Added AUXV prefix to avoid potential conflicts with system- + /// defined macros enum EntryType { AUXV_AT_NULL = 0, ///< End of auxv. AUXV_AT_IGNORE = 1, ///< Ignore entry. diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h index 295ae55e1b8..a7071801f56 100644 --- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h +++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h @@ -29,12 +29,12 @@ class Process; } /// @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 -/// an interface to this structure and maintains a consistent snapshot of the -/// currently loaded modules. +/// runtime liker each time a module is loaded or unloaded. This class +/// provides an interface to this structure and maintains a consistent +/// snapshot of the currently loaded modules. class DYLDRendezvous { // This structure is used to hold the contents of the debug rendezvous @@ -119,13 +119,13 @@ public: 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 - /// the inferior process. + /// Structure representing the shared objects currently loaded into the + /// inferior process. /// /// This object is a rough analogue to the struct link_map object which /// actually lives in the inferiors memory. @@ -194,7 +194,8 @@ protected: /// List of SOEntry objects corresponding to the current link map state. SOEntryList m_soentries; - /// List of SOEntry's added to the link map since the last call to Resolve(). + /// List of SOEntry's added to the link map since the last call to + /// Resolve(). SOEntryList m_added_soentries; /// List of SOEntry's removed from the link map since the last call to diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h index c0e6c0358a2..859a1dfa5f7 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h @@ -18,18 +18,17 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ASTResultSynthesizer ASTResultSynthesizer.h -/// "lldb/Expression/ASTResultSynthesizer.h" -/// @brief Adds a result variable declaration to the ASTs for an expression. +/// "lldb/Expression/ASTResultSynthesizer.h" 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 -/// adds -/// a result variable to the expression, transforming it to -/// "int $__lldb_expr_result = i + 3." The IR transformers ensure that the +/// adds a result variable to the expression, transforming it to "int +/// $__lldb_expr_result = i + 3." The IR transformers ensure that the /// resulting variable is mapped to the right piece of memory. -/// ASTResultSynthesizer's job is to add the variable and its initialization to -/// the ASTs for the expression, and it does so by acting as a SemaConsumer for -/// Clang. +/// ASTResultSynthesizer's job is to add the variable and its initialization +/// to the ASTs for the expression, and it does so by acting as a SemaConsumer +/// for Clang. //---------------------------------------------------------------------- class ASTResultSynthesizer : public clang::SemaConsumer { public: @@ -68,8 +67,8 @@ public: void Initialize(clang::ASTContext &Context) override; //---------------------------------------------------------------------- - /// Examine a list of Decls to find the function $__lldb_expr and - /// transform its code + /// Examine a list of Decls to find the function $__lldb_expr and transform + /// its code /// /// @param[in] D /// The list of Decls to search. These may contain LinkageSpecDecls, @@ -124,8 +123,8 @@ public: private: //---------------------------------------------------------------------- - /// Hunt the given Decl for FunctionDecls named $__lldb_expr, recursing - /// as necessary through LinkageSpecDecls, and calling SynthesizeResult on + /// Hunt the given Decl for FunctionDecls named $__lldb_expr, recursing as + /// necessary through LinkageSpecDecls, and calling SynthesizeResult on /// anything that was found /// /// @param[in] D @@ -164,8 +163,8 @@ private: bool SynthesizeBodyResult(clang::CompoundStmt *Body, clang::DeclContext *DC); //---------------------------------------------------------------------- - /// Given a DeclContext for a function or method, find all types - /// declared in the context and record any persistent types found. + /// Given a DeclContext for a function or method, find all types declared in + /// the context and record any persistent types found. /// /// @param[in] FunDeclCtx /// The context for the function to process. @@ -173,8 +172,8 @@ private: void RecordPersistentTypes(clang::DeclContext *FunDeclCtx); //---------------------------------------------------------------------- - /// Given a TypeDecl, if it declares a type whose name starts with a - /// dollar sign, register it as a pointer type in the target's scratch + /// Given a TypeDecl, if it declares a type whose name starts with a dollar + /// sign, register it as a pointer type in the target's scratch /// AST context. /// /// @param[in] Body diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h index 63e3161cae8..65f4b00a865 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h @@ -20,20 +20,19 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ASTStructExtractor ASTStructExtractor.h -/// "lldb/Expression/ASTStructExtractor.h" -/// @brief Extracts and describes the argument structure for a wrapped function. +/// "lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument +/// structure for a wrapped function. /// /// This pass integrates with ClangFunctionCaller, which calls functions with -/// custom -/// sets of arguments. To avoid having to implement the full calling convention -/// for the target's architecture, ClangFunctionCaller writes a simple wrapper -/// function that takes a pointer to an argument structure that contains room -/// for the address of the function to be called, the values of all its -/// arguments, and room for the function's return value. +/// custom sets of arguments. To avoid having to implement the full calling +/// convention for the target's architecture, ClangFunctionCaller writes a +/// simple wrapper function that takes a pointer to an argument structure that +/// contains room for the address of the function to be called, the values of +/// all its arguments, and room for the function's return value. /// -/// The definition of this struct is itself in the body of the wrapper function, -/// so Clang does the structure layout itself. ASTStructExtractor reads through -/// the AST for the wrapper function and finds the struct. +/// The definition of this struct is itself in the body of the wrapper +/// function, so Clang does the structure layout itself. ASTStructExtractor +/// reads through the AST for the wrapper function and finds the struct. //---------------------------------------------------------------------- class ASTStructExtractor : public clang::SemaConsumer { public: @@ -73,8 +72,8 @@ public: void Initialize(clang::ASTContext &Context) override; //---------------------------------------------------------------------- - /// Examine a list of Decls to find the function $__lldb_expr and - /// transform its code + /// Examine a list of Decls to find the function $__lldb_expr and transform + /// its code /// /// @param[in] D /// The list of Decls to search. These may contain LinkageSpecDecls, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h index 6f72ad92dc8..a42422b0f97 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h @@ -25,14 +25,13 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @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 -/// types. Clang knows the name it is looking for, but nothing else. -/// The ExternalSemaSource class provides Decls (VarDecl, FunDecl, TypeDecl) -/// to Clang for these names, consulting the ClangExpressionDeclMap to do -/// the actual lookups. +/// As Clang parses an expression, it may encounter names that are not defined +/// inside the expression, including variables, functions, and types. Clang +/// knows the name it is looking for, but nothing else. The ExternalSemaSource +/// class provides Decls (VarDecl, FunDecl, TypeDecl) to Clang for these +/// names, consulting the ClangExpressionDeclMap to do the actual lookups. //---------------------------------------------------------------------- class ClangASTSource : public ClangExternalASTSourceCommon, public ClangASTImporter::MapCompleter { @@ -78,8 +77,8 @@ public: //------------------------------------------------------------------ /// Look up all Decls that match a particular name. Only handles /// Identifiers and DeclContexts that are either NamespaceDecls or - /// TranslationUnitDecls. Calls SetExternalVisibleDeclsForName with - /// the result. + /// TranslationUnitDecls. Calls SetExternalVisibleDeclsForName with the + /// result. /// /// The work for this function is done by /// void FindExternalVisibleDecls (NameSearchContext &); @@ -173,8 +172,8 @@ public: //------------------------------------------------------------------ /// Called on entering a translation unit. Tells Clang by calling - /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage() - /// that this object has something to say about undefined names. + /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage() that + /// this object has something to say about undefined names. /// /// @param[in] ASTConsumer /// Unused. @@ -186,8 +185,8 @@ public: // //------------------------------------------------------------------ - /// Look up the modules containing a given namespace and put the - /// appropriate entries in the namespace map. + /// Look up the modules containing a given namespace and put the appropriate + /// entries in the namespace map. /// /// @param[in] namespace_map /// The map to be completed. @@ -231,11 +230,10 @@ public: //---------------------------------------------------------------------- /// @class ClangASTSourceProxy ClangASTSource.h - /// "lldb/Expression/ClangASTSource.h" - /// @brief Proxy for ClangASTSource + /// "lldb/Expression/ClangASTSource.h" Proxy for ClangASTSource /// - /// Clang AST contexts like to own their AST sources, so this is a - /// state-free proxy object. + /// Clang AST contexts like to own their AST sources, so this is a state- + /// free proxy object. //---------------------------------------------------------------------- class ClangASTSourceProxy : public ClangExternalASTSourceCommon { public: @@ -298,8 +296,8 @@ public: protected: //------------------------------------------------------------------ - /// Look for the complete version of an Objective-C interface, and - /// return it if found. + /// Look for the complete version of an Objective-C interface, and return it + /// if found. /// /// @param[in] interface_decl /// An ObjCInterfaceDecl that may not be the complete one. @@ -312,8 +310,8 @@ protected: GetCompleteObjCInterface(const clang::ObjCInterfaceDecl *interface_decl); //------------------------------------------------------------------ - /// Find all entities matching a given name in a given module, - /// using a NameSearchContext to make Decls for them. + /// Find all entities matching a given name in a given module, using a + /// NameSearchContext to make Decls for them. /// /// @param[in] context /// The NameSearchContext that can construct Decls for this name. @@ -474,8 +472,9 @@ protected: }; //---------------------------------------------------------------------- -/// @class NameSearchContext ClangASTSource.h "lldb/Expression/ClangASTSource.h" -/// @brief Container for all objects relevant to a single name lookup +/// @class NameSearchContext ClangASTSource.h +/// "lldb/Expression/ClangASTSource.h" 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 @@ -532,8 +531,8 @@ struct NameSearchContext { } //------------------------------------------------------------------ - /// Create a VarDecl with the name being searched for and the provided - /// type and register it in the right places. + /// Create a VarDecl with the name being searched for and the provided type + /// and register it in the right places. /// /// @param[in] type /// The opaque QualType for the VarDecl being registered. @@ -541,8 +540,8 @@ struct NameSearchContext { clang::NamedDecl *AddVarDecl(const CompilerType &type); //------------------------------------------------------------------ - /// Create a FunDecl with the name being searched for and the provided - /// type and register it in the right places. + /// Create a FunDecl with the name being searched for and the provided type + /// and register it in the right places. /// /// @param[in] type /// The opaque QualType for the FunDecl being registered. @@ -553,15 +552,14 @@ struct NameSearchContext { clang::NamedDecl *AddFunDecl(const CompilerType &type, bool extern_c = false); //------------------------------------------------------------------ - /// Create a FunDecl with the name being searched for and generic - /// type (i.e. intptr_t NAME_GOES_HERE(...)) and register it in the - /// right places. + /// Create a FunDecl with the name being searched for and generic type (i.e. + /// intptr_t NAME_GOES_HERE(...)) and register it in the right places. //------------------------------------------------------------------ clang::NamedDecl *AddGenericFunDecl(); //------------------------------------------------------------------ - /// Create a TypeDecl with the name being searched for and the provided - /// type and register it in the right places. + /// Create a TypeDecl with the name being searched for and the provided type + /// and register it in the right places. /// /// @param[in] compiler_type /// The opaque QualType for the TypeDecl being registered. @@ -569,8 +567,8 @@ struct NameSearchContext { clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type); //------------------------------------------------------------------ - /// Add Decls from the provided DeclContextLookupResult to the list - /// of results. + /// Add Decls from the provided DeclContextLookupResult to the list of + /// results. /// /// @param[in] result /// The DeclContextLookupResult, usually returned as the result diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h index d163ad4f7e2..b6738793019 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h @@ -36,29 +36,28 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ClangExpressionDeclMap ClangExpressionDeclMap.h -/// "lldb/Expression/ClangExpressionDeclMap.h" -/// @brief Manages named entities that are defined in LLDB's debug information. +/// "lldb/Expression/ClangExpressionDeclMap.h" 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, -/// listing -/// all possible objects corresponding to a particular name. But it in turn -/// relies on ClangExpressionDeclMap, which performs several important +/// listing all possible objects corresponding to a particular name. But it +/// in turn relies on ClangExpressionDeclMap, which performs several important /// functions. /// -/// First, it records what variables and functions were looked up and what Decls -/// were returned for them. +/// First, it records what variables and functions were looked up and what +/// Decls were returned for them. /// /// Second, it constructs a struct on behalf of IRForTarget, recording which -/// variables should be placed where and relaying this information back so that -/// IRForTarget can generate context-independent code. +/// variables should be placed where and relaying this information back so +/// that IRForTarget can generate context-independent code. /// /// Third, it "materializes" this struct on behalf of the expression command, /// finding the current values of each variable and placing them into the /// struct so that it can be passed to the JITted version of the IR. /// -/// Fourth and finally, it "dematerializes" the struct after the JITted code has -/// has executed, placing the new values back where it found the old ones. +/// Fourth and finally, it "dematerializes" the struct after the JITted code +/// has has executed, placing the new values back where it found the old ones. //---------------------------------------------------------------------- class ClangExpressionDeclMap : public ClangASTSource { public: @@ -169,8 +168,8 @@ public: lldb::offset_t alignment); //------------------------------------------------------------------ - /// [Used by IRForTarget] Finalize the struct, laying out the position - /// of each object in it. + /// [Used by IRForTarget] Finalize the struct, laying out the position of + /// each object in it. /// /// @return /// True on success; false otherwise. @@ -178,8 +177,8 @@ public: bool DoStructLayout(); //------------------------------------------------------------------ - /// [Used by IRForTarget] Get general information about the laid-out - /// struct after DoStructLayout() has been called. + /// [Used by IRForTarget] Get general information about the laid-out struct + /// after DoStructLayout() has been called. /// /// @param[out] num_elements /// The number of elements in the struct. @@ -197,8 +196,8 @@ public: lldb::offset_t &alignment); //------------------------------------------------------------------ - /// [Used by IRForTarget] Get specific information about one field - /// of the laid-out struct after DoStructLayout() has been called. + /// [Used by IRForTarget] Get specific information about one field of the + /// laid-out struct after DoStructLayout() has been called. /// /// @param[out] decl /// The parsed Decl for the field, as generated by ClangASTSource @@ -232,8 +231,7 @@ public: uint32_t index); //------------------------------------------------------------------ - /// [Used by IRForTarget] Get information about a function given its - /// Decl. + /// [Used by IRForTarget] Get information about a function given its Decl. /// /// @param[in] decl /// The parsed Decl for the Function, as generated by ClangASTSource @@ -248,8 +246,8 @@ public: bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr); //------------------------------------------------------------------ - /// [Used by IRForTarget] Get the address of a symbol given nothing - /// but its name. + /// [Used by IRForTarget] Get the address of a symbol given nothing but its + /// name. /// /// @param[in] target /// The target to find the symbol in. If not provided, @@ -303,8 +301,8 @@ public: TargetInfo GetTargetInfo(); //------------------------------------------------------------------ - /// [Used by ClangASTSource] Find all entities matching a given name, - /// using a NameSearchContext to make Decls for them. + /// [Used by ClangASTSource] Find all entities matching a given name, using + /// a NameSearchContext to make Decls for them. /// /// @param[in] context /// The NameSearchContext that can construct Decls for this name. @@ -442,14 +440,13 @@ private: void DisableStructVars() { m_struct_vars.reset(); } //---------------------------------------------------------------------- - /// Get this parser's ID for use in extracting parser- and JIT-specific - /// data from persistent variables. + /// Get this parser's ID for use in extracting parser- and JIT-specific data + /// from persistent variables. //---------------------------------------------------------------------- uint64_t GetParserID() { return (uint64_t) this; } //------------------------------------------------------------------ - /// Given a target, find a variable that matches the given name and - /// type. + /// Given a target, find a variable that matches the given name and type. /// /// @param[in] target /// The target to use as a basis for finding the variable. @@ -477,8 +474,8 @@ private: TypeFromUser *type = NULL); //------------------------------------------------------------------ - /// Get the value of a variable in a given execution context and return - /// the associated Types if needed. + /// Get the value of a variable in a given execution context and return the + /// associated Types if needed. /// /// @param[in] var /// The variable to evaluate. @@ -524,8 +521,8 @@ private: lldb::ValueObjectSP valobj, unsigned int current_id); //------------------------------------------------------------------ - /// Use the NameSearchContext to generate a Decl for the given - /// persistent variable, and put it in the list of found entities. + /// Use the NameSearchContext to generate a Decl for the given persistent + /// variable, and put it in the list of found entities. /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. @@ -542,9 +539,8 @@ private: unsigned int current_id); //------------------------------------------------------------------ - /// Use the NameSearchContext to generate a Decl for the given LLDB - /// symbol (treated as a variable), and put it in the list of found - /// entities. + /// Use the NameSearchContext to generate a Decl for the given LLDB symbol + /// (treated as a variable), and put it in the list of found entities. /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. @@ -556,9 +552,9 @@ private: unsigned int current_id); //------------------------------------------------------------------ - /// Use the NameSearchContext to generate a Decl for the given - /// function. (Functions are not placed in the Tuple list.) Can - /// handle both fully typed functions and generic functions. + /// Use the NameSearchContext to generate a Decl for the given function. + /// (Functions are not placed in the Tuple list.) Can handle both fully + /// typed functions and generic functions. /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. @@ -575,8 +571,7 @@ private: unsigned int current_id); //------------------------------------------------------------------ - /// Use the NameSearchContext to generate a Decl for the given - /// register. + /// Use the NameSearchContext to generate a Decl for the given register. /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. @@ -588,8 +583,8 @@ private: unsigned int current_id); //------------------------------------------------------------------ - /// Use the NameSearchContext to generate a Decl for the given - /// type. (Types are not placed in the Tuple list.) + /// Use the NameSearchContext to generate a Decl for the given type. (Types + /// are not placed in the Tuple list.) /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. @@ -601,8 +596,8 @@ private: unsigned int current_id); //------------------------------------------------------------------ - /// Generate a Decl for "*this" and add a member function declaration - /// to it for the expression, then report it. + /// Generate a Decl for "*this" and add a member function declaration to it + /// for the expression, then report it. /// /// @param[in] context /// The NameSearchContext to use when constructing the Decl. diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h index 41f290f2e12..4058ec1270b 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h @@ -26,14 +26,14 @@ class IRExecutionUnit; //---------------------------------------------------------------------- /// @class ClangExpressionParser ClangExpressionParser.h -/// "lldb/Expression/ClangExpressionParser.h" -/// @brief Encapsulates an instance of Clang that can parse expressions. +/// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of +/// Clang that can parse expressions. /// /// ClangExpressionParser is responsible for preparing an instance of /// ClangExpression for execution. ClangExpressionParser uses ClangExpression /// as a glorified parameter list, performing the required parsing and -/// conversion to formats (DWARF bytecode, or JIT compiled machine code) -/// that can be executed. +/// conversion to formats (DWARF bytecode, or JIT compiled machine code) that +/// can be executed. //---------------------------------------------------------------------- class ClangExpressionParser : public ExpressionParser { public: @@ -59,8 +59,8 @@ public: ~ClangExpressionParser() override; //------------------------------------------------------------------ - /// Parse a single expression and convert it to IR using Clang. Don't - /// wrap the expression in anything at all. + /// Parse a single expression and convert it to IR using Clang. Don't wrap + /// the expression in anything at all. /// /// @param[in] diagnostic_manager /// The diagnostic manager to report errors to. @@ -74,8 +74,8 @@ public: bool RewriteExpression(DiagnosticManager &diagnostic_manager) override; //------------------------------------------------------------------ - /// Ready an already-parsed expression for execution, possibly - /// evaluating it statically. + /// Ready an already-parsed expression for execution, possibly evaluating it + /// statically. /// /// @param[out] func_addr /// The address to which the function has been written. diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h index baa80d7ba0d..7d5ced5b470 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h @@ -41,27 +41,25 @@ class ValueObjectConstResult; //---------------------------------------------------------------------- /// @class ClangExpressionVariable ClangExpressionVariable.h -/// "lldb/Expression/ClangExpressionVariable.h" -/// @brief Encapsulates one variable for the expression parser. +/// "lldb/Expression/ClangExpressionVariable.h" Encapsulates one variable for +/// the expression parser. /// /// The expression parser uses variables in three different contexts: /// -/// First, it stores persistent variables along with the process for use -/// in expressions. These persistent variables contain their own data -/// and are typed. +/// First, it stores persistent variables along with the process for use in +/// expressions. These persistent variables contain their own data and are +/// typed. /// -/// Second, in an interpreted expression, it stores the local variables -/// for the expression along with the expression. These variables -/// contain their own data and are typed. +/// Second, in an interpreted expression, it stores the local variables for +/// the expression along with the expression. These variables contain their +/// own data and are typed. /// -/// Third, in a JIT-compiled expression, it stores the variables that -/// the expression needs to have materialized and dematerialized at each -/// execution. These do not contain their own data but are named and -/// typed. +/// Third, in a JIT-compiled expression, it stores the variables that the +/// expression needs to have materialized and dematerialized at each +/// execution. These do not contain their own data but are named and typed. /// -/// This class supports all of these use cases using simple type -/// polymorphism, and provides necessary support methods. Its interface -/// is RTTI-neutral. +/// This class supports all of these use cases using simple type polymorphism, +/// and provides necessary support methods. Its interface is RTTI-neutral. //---------------------------------------------------------------------- class ClangExpressionVariable : public ExpressionVariable { public: @@ -79,8 +77,8 @@ public: lldb::ByteOrder byte_order, uint32_t addr_byte_size); //---------------------------------------------------------------------- - /// Utility functions for dealing with ExpressionVariableLists in - /// Clang-specific ways + /// Utility functions for dealing with ExpressionVariableLists in Clang- + /// specific ways //---------------------------------------------------------------------- //---------------------------------------------------------------------- @@ -112,9 +110,9 @@ public: } //---------------------------------------------------------------------- - /// If the variable contains its own data, make a Value point at it. - /// If \a exe_ctx in not NULL, the value will be resolved in with - /// that execution context. + /// If the variable contains its own data, make a Value point at it. If \a + /// exe_ctx in not NULL, the value will be resolved in with that execution + /// context. /// /// @param[in] value /// The value to point at the data. @@ -156,8 +154,8 @@ private: public: //---------------------------------------------------------------------- - /// Make this variable usable by the parser by allocating space for - /// parser-specific variables + /// Make this variable usable by the parser by allocating space for parser- + /// specific variables //---------------------------------------------------------------------- void EnableParserVars(uint64_t parser_id) { m_parser_vars.insert(std::make_pair(parser_id, ParserVars())); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h index 0596d8fde7b..438cf0c713d 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h @@ -31,8 +31,8 @@ class ClangExpressionParser; //---------------------------------------------------------------------- /// @class ClangFunctionCaller ClangFunctionCaller.h -/// "lldb/Expression/ClangFunctionCaller.h" -/// @brief Encapsulates a function that can be called. +/// "lldb/Expression/ClangFunctionCaller.h" 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 @@ -56,8 +56,8 @@ class ClangExpressionParser; /// If you need to call the function on the thread plan stack, you can also /// call InsertFunction() followed by GetThreadPlanToCallFunction(). /// -/// Any of the methods that take arg_addr_ptr or arg_addr_ref can be passed -/// a pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated +/// Any of the methods that take arg_addr_ptr or arg_addr_ref can be passed a +/// pointer set to LLDB_INVALID_ADDRESS and new structure will be allocated /// and its address returned in that variable. /// /// Any of the methods that take arg_addr_ptr can be passed NULL, and the @@ -79,8 +79,8 @@ class ClangFunctionCaller : public FunctionCaller { ClangExpressionDeclMap *DeclMap() override { return NULL; } //------------------------------------------------------------------ - /// Return the object that the parser should allow to access ASTs. - /// May be NULL if the ASTs do not need to be transformed. + /// Return the object that the parser should allow to access ASTs. May be + /// NULL if the ASTs do not need to be transformed. /// /// @param[in] passthrough /// The ASTConsumer that the returned transformer should send diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h index 1432fae711e..59126974616 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h @@ -25,9 +25,8 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ClangPersistentVariables ClangPersistentVariables.h -/// "lldb/Expression/ClangPersistentVariables.h" -/// @brief Manages persistent values that need to be preserved between -/// expression invocations. +/// "lldb/Expression/ClangPersistentVariables.h" 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 /// ClangPersistentVariable for more discussion. Also provides an increasing, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h index 16d4af8b167..434168e2ce5 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h @@ -35,13 +35,13 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ClangUserExpression ClangUserExpression.h -/// "lldb/Expression/ClangUserExpression.h" -/// @brief Encapsulates a single expression for use with Clang +/// "lldb/Expression/ClangUserExpression.h" 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 -/// the objects needed to parse and interpret or JIT an expression. It -/// uses the Clang parser to produce LLVM IR from the expression. +/// the objects needed to parse and interpret or JIT an expression. It uses +/// the Clang parser to produce LLVM IR from the expression. //---------------------------------------------------------------------- class ClangUserExpression : public LLVMUserExpression { public: @@ -69,8 +69,8 @@ public: bool keep_result_in_memory); //------------------------------------------------------------------ - /// Return the object that the parser should allow to access ASTs. - /// May be NULL if the ASTs do not need to be transformed. + /// Return the object that the parser should allow to access ASTs. May be + /// NULL if the ASTs do not need to be transformed. /// /// @param[in] passthrough /// The ASTConsumer that the returned transformer should send diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h index 80577199b81..a897a2b1708 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h @@ -29,15 +29,15 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @class ClangUtilityFunction ClangUtilityFunction.h -/// "lldb/Expression/ClangUtilityFunction.h" -/// @brief Encapsulates a single expression for use with Clang +/// "lldb/Expression/ClangUtilityFunction.h" 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 /// a self-contained function meant to be used from other code. Utility /// functions can perform error-checking for ClangUserExpressions, or can -/// simply provide a way to push a function into the target for the debugger to -/// call later on. +/// simply provide a way to push a function into the target for the debugger +/// to call later on. //---------------------------------------------------------------------- class ClangUtilityFunction : public UtilityFunction { public: @@ -60,8 +60,8 @@ public: void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory); //------------------------------------------------------------------ - /// Return the object that the parser should allow to access ASTs. - /// May be NULL if the ASTs do not need to be transformed. + /// Return the object that the parser should allow to access ASTs. May be + /// NULL if the ASTs do not need to be transformed. /// /// @param[in] passthrough /// The ASTConsumer that the returned transformer should send diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h index 93ce8aa44eb..c6c44b46023 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h @@ -47,12 +47,11 @@ class IRMemoryMap; //---------------------------------------------------------------------- /// @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, -/// or compiled by the JIT and inserted into the target process for -/// execution. +/// Once an expression has been parsed and converted to IR, it can run in two +/// contexts: interpreted by LLDB as a DWARF location expression, or compiled +/// by the JIT and inserted into the target process for execution. /// /// IRForTarget makes the second possible, by applying a series of /// transformations to the IR which make it relocatable. These @@ -126,8 +125,7 @@ public: //------------------------------------------------------------------ /// Interface stub /// - /// Implementation of the llvm::ModulePass::assignPassManager() - /// function. + /// Implementation of the llvm::ModulePass::assignPassManager() function. //------------------------------------------------------------------ void assignPassManager(llvm::PMStack &pass_mgr_stack, llvm::PassManagerType pass_mgr_type = @@ -179,8 +177,8 @@ private: //------------------------------------------------------------------ //------------------------------------------------------------------ - /// Get the address of a function, and a location to put the complete - /// Value of the function if one is available. + /// Get the address of a function, and a location to put the complete Value + /// of the function if one is available. /// /// @param[in] function /// The function to find the location of. @@ -204,13 +202,13 @@ private: //------------------------------------------------------------------ /// A function-level pass to take the generated global value - /// $__lldb_expr_result and make it into a persistent variable. - /// Also see ASTResultSynthesizer. + /// $__lldb_expr_result and make it into a persistent variable. Also see + /// ASTResultSynthesizer. //------------------------------------------------------------------ //------------------------------------------------------------------ - /// Find the NamedDecl corresponding to a Value. This interface is - /// exposed for the IR interpreter. + /// Find the NamedDecl corresponding to a Value. This interface is exposed + /// for the IR interpreter. /// /// @param[in] module /// The module containing metadata to search @@ -230,8 +228,8 @@ private: //------------------------------------------------------------------ /// Set the constant result variable m_const_result to the provided - /// constant, assuming it can be evaluated. The result variable - /// will be reset to NULL later if the expression has side effects. + /// constant, assuming it can be evaluated. The result variable will be + /// reset to NULL later if the expression has side effects. /// /// @param[in] initializer /// The constant initializer for the variable. @@ -247,8 +245,8 @@ private: lldb_private::TypeFromParser type); //------------------------------------------------------------------ - /// If the IR represents a cast of a variable, set m_const_result - /// to the result of the cast. The result variable will be reset to + /// If the IR represents a cast of a variable, set m_const_result to the + /// result of the cast. The result variable will be reset to /// NULL latger if the expression has side effects. /// /// @param[in] type @@ -301,10 +299,9 @@ private: /// rewrite them to use sel_registerName instead of statically allocated /// selectors. The reason is that the selectors are created on the /// assumption that the Objective-C runtime will scan the appropriate - /// section and prepare them. This doesn't happen when code is copied - /// into the target, though, and there's no easy way to induce the - /// runtime to scan them. So instead we get our selectors from - /// sel_registerName. + /// section and prepare them. This doesn't happen when code is copied into + /// the target, though, and there's no easy way to induce the runtime to + /// scan them. So instead we get our selectors from sel_registerName. //------------------------------------------------------------------ //------------------------------------------------------------------ @@ -359,13 +356,12 @@ private: //------------------------------------------------------------------ /// A basic block-level pass to find all newly-declared persistent - /// variables and register them with the ClangExprDeclMap. This - /// allows them to be materialized and dematerialized like normal - /// external variables. Before transformation, these persistent - /// variables look like normal locals, so they have an allocation. - /// This pass excises these allocations and makes references look - /// like external references where they will be resolved -- like all - /// other external references -- by ResolveExternals(). + /// variables and register them with the ClangExprDeclMap. This allows them + /// to be materialized and dematerialized like normal external variables. + /// Before transformation, these persistent variables look like normal + /// locals, so they have an allocation. This pass excises these allocations + /// and makes references look like external references where they will be + /// resolved -- like all other external references -- by ResolveExternals(). //------------------------------------------------------------------ //------------------------------------------------------------------ @@ -389,15 +385,14 @@ private: //------------------------------------------------------------------ /// A function-level pass to find all external variables and functions - /// used in the IR. Each found external variable is added to the - /// struct, and each external function is resolved in place, its call - /// replaced with a call to a function pointer whose value is the - /// address of the function in the target process. + /// used in the IR. Each found external variable is added to the struct, + /// and each external function is resolved in place, its call replaced with + /// a call to a function pointer whose value is the address of the function + /// in the target process. //------------------------------------------------------------------ //------------------------------------------------------------------ - /// Write an initializer to a memory array of assumed sufficient - /// size. + /// Write an initializer to a memory array of assumed sufficient size. /// /// @param[in] data /// A pointer to the data to write to. @@ -504,8 +499,8 @@ private: //------------------------------------------------------------------ /// A basic block-level pass to excise guard variables from the code. /// The result for the function is passed through Clang as a static - /// variable. Static variables normally have guard variables to - /// ensure that they are only initialized once. + /// variable. Static variables normally have guard variables to ensure that + /// they are only initialized once. //------------------------------------------------------------------ //------------------------------------------------------------------ @@ -529,9 +524,9 @@ private: //------------------------------------------------------------------ /// A function-level pass to make all external variable references - /// point at the correct offsets from the void* passed into the - /// function. ClangExpressionDeclMap::DoStructLayout() must be called - /// beforehand, so that the offsets are valid. + /// point at the correct offsets from the void* passed into the function. + /// ClangExpressionDeclMap::DoStructLayout() must be called beforehand, so + /// that the offsets are valid. //------------------------------------------------------------------ //------------------------------------------------------------------ @@ -583,7 +578,8 @@ private: llvm::StoreInst *m_result_store; ///< If non-NULL, the store instruction that ///writes to the result variable. If - /// m_has_side_effects is true, this is NULL. + /// m_has_side_effects is true, this is + /// NULL. bool m_result_is_pointer; ///< True if the function's result in the AST is a ///pointer (see comments in /// ASTResultSynthesizer::SynthesizeBodyResult) @@ -594,18 +590,17 @@ private: /// location of the static allocation. //------------------------------------------------------------------ - /// UnfoldConstant operates on a constant [Old] which has just been - /// replaced with a value [New]. We assume that new_value has - /// been properly placed early in the function, in front of the - /// first instruction in the entry basic block - /// [FirstEntryInstruction]. + /// UnfoldConstant operates on a constant [Old] which has just been replaced + /// with a value [New]. We assume that new_value has been properly placed + /// early in the function, in front of the first instruction in the entry + /// basic block [FirstEntryInstruction]. /// - /// UnfoldConstant reads through the uses of Old and replaces Old - /// in those uses with New. Where those uses are constants, the - /// function generates new instructions to compute the result of the - /// new, non-constant expression and places them before - /// FirstEntryInstruction. These instructions replace the constant - /// uses, so UnfoldConstant calls itself recursively for those. + /// UnfoldConstant reads through the uses of Old and replaces Old in those + /// uses with New. Where those uses are constants, the function generates + /// new instructions to compute the result of the new, non-constant + /// expression and places them before FirstEntryInstruction. These + /// instructions replace the constant uses, so UnfoldConstant calls itself + /// recursively for those. /// /// @param[in] llvm_function /// The function currently being processed. @@ -637,8 +632,8 @@ private: lldb_private::Stream &error_stream); //------------------------------------------------------------------ - /// Construct a reference to m_reloc_placeholder with a given type - /// and offset. This typically happens after inserting data into + /// Construct a reference to m_reloc_placeholder with a given type and + /// offset. This typically happens after inserting data into /// m_data_allocator. /// /// @param[in] type @@ -653,8 +648,8 @@ private: llvm::Constant *BuildRelocation(llvm::Type *type, uint64_t offset); //------------------------------------------------------------------ - /// Commit the allocation in m_data_allocator and use its final - /// location to replace m_reloc_placeholder. + /// Commit the allocation in m_data_allocator and use its final location to + /// replace m_reloc_placeholder. /// /// @param[in] module /// The module that m_data_allocator resides in diff --git a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h index 5d55b296ed3..e2839da9bfd 100644 --- a/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h +++ b/lldb/source/Plugins/ExpressionParser/Go/GoUserExpression.h @@ -50,12 +50,12 @@ private: //---------------------------------------------------------------------- /// @class GoUserExpression GoUserExpression.h -/// "lldb/Expression/GoUserExpression.h" -/// @brief Encapsulates a single expression for use with Go +/// "lldb/Expression/GoUserExpression.h" 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 -/// the objects needed to parse and interpret an expression. +/// and as a backend for the expr command. GoUserExpression encapsulates the +/// objects needed to parse and interpret an expression. //---------------------------------------------------------------------- class GoUserExpression : public UserExpression { public: diff --git a/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h b/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h index 4e2d3155ebb..faaf8be99d6 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h +++ b/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h @@ -8,14 +8,14 @@ //===----------------------------------------------------------------------===// // /// @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 /// to the exact binary layout of an ELF, but can be used to hold the /// information present in both 32 and 64 bit variants of the format. Each -/// entity provides a \c Parse method which is capable of transparently reading -/// both 32 and 64 bit instances of the object. +/// entity provides a \c Parse method which is capable of transparently +/// reading both 32 and 64 bit instances of the object. //===----------------------------------------------------------------------===// #ifndef liblldb_ELFHeader_h_ @@ -35,8 +35,9 @@ namespace elf { //------------------------------------------------------------------------------ /// @name ELF type definitions. /// -/// Types used to represent the various components of ELF structures. All types -/// are signed or unsigned integral types wide enough to hold values from both +/// Types used to represent the various components of ELF structures. All +/// types are signed or unsigned integral types wide enough to hold values +/// from both /// 32 and 64 bit ELF variants. //@{ typedef uint64_t elf_addr; @@ -51,10 +52,10 @@ typedef int64_t elf_sxword; //------------------------------------------------------------------------------ /// @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. +/// This object is used to identify the general attributes on an ELF file and +/// to locate additional sections within the file. struct ELFHeader { unsigned char e_ident[llvm::ELF::EI_NIDENT]; ///< ELF file identification. elf_addr e_entry; ///< Virtual address program entry point. @@ -118,9 +119,9 @@ struct ELFHeader { bool HasHeaderExtension() const; //-------------------------------------------------------------------------- - /// Parse an ELFHeader entry starting at position \p offset and - /// update the data extractor with the address size and byte order - /// attributes as defined by the header. + /// Parse an ELFHeader entry starting at position \p offset and update the + /// data extractor with the address size and byte order attributes as + /// defined by the header. /// /// @param[in,out] data /// The DataExtractor to read from. Updated with the address size and @@ -157,8 +158,8 @@ struct ELFHeader { private: //-------------------------------------------------------------------------- - /// Parse an ELFHeader header extension entry. This method is called - /// by Parse(). + /// Parse an ELFHeader header extension entry. This method is called by + /// Parse(). /// /// @param[in] data /// The DataExtractor to read from. @@ -167,7 +168,7 @@ private: //------------------------------------------------------------------------------ /// @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. @@ -202,7 +203,7 @@ struct ELFSectionHeader { //------------------------------------------------------------------------------ /// @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. @@ -235,7 +236,7 @@ struct ELFProgramHeader { //------------------------------------------------------------------------------ /// @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. @@ -288,7 +289,7 @@ struct ELFSymbol { //------------------------------------------------------------------------------ /// @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 { @@ -318,7 +319,7 @@ struct ELFDynamic { //------------------------------------------------------------------------------ /// @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. @@ -360,7 +361,7 @@ struct ELFRel { //------------------------------------------------------------------------------ /// @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. diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index 923a74935a7..3fbcaa28a91 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -113,7 +113,7 @@ const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02; //===----------------------------------------------------------------------===// /// @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. diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h index 7b2a379f392..e84c8038b19 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h @@ -54,10 +54,10 @@ struct ELFNote { //------------------------------------------------------------------------------ /// @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. +/// This class provides a generic ELF (32/64 bit) reader plugin implementing +/// the ObjectFile protocol. class ObjectFileELF : public lldb_private::ObjectFile { public: ~ObjectFileELF() override; @@ -260,8 +260,8 @@ private: uint64_t length, lldb_private::ArchSpec &arch_spec); - /// Parses the elf section headers and returns the uuid, debug link name, crc, - /// archspec. + /// Parses the elf section headers and returns the uuid, debug link name, + /// crc, archspec. static size_t GetSectionHeaderInfo(SectionHeaderColl §ion_headers, lldb_private::DataExtractor &object_data, const elf::ELFHeader &header, diff --git a/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h index 649280c17a8..0b186fd7d80 100644 --- a/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h +++ b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h @@ -43,10 +43,10 @@ class Scalar; 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. +/// Upon construction, this class prepares and launches an inferior process +/// for debugging. /// /// Changes in the inferior process state are broadcasted. class NativeProcessDarwin : public NativeProcessProtocol { @@ -205,10 +205,10 @@ private: // ----------------------------------------------------------------- /// Finalize the launch. /// - /// This method associates the NativeProcessDarwin instance with - /// the host process that was just launched. It peforms actions - /// like attaching a listener to the inferior exception port, - /// ptracing the process, and the like. + /// This method associates the NativeProcessDarwin instance with the host + /// process that was just launched. It peforms actions like attaching a + /// listener to the inferior exception port, ptracing the process, and the + /// like. /// /// @param[in] launch_flavor /// The launch flavor that was used to launch the process. @@ -263,8 +263,8 @@ private: task_t TaskPortForProcessID(Status &error, bool force = false) const; - /// Attaches to an existing process. Forms the - /// implementation of Process::DoAttach. + /// Attaches to an existing process. Forms the implementation of + /// Process::DoAttach. void AttachToInferior(MainLoop &mainloop, lldb::pid_t pid, Status &error); ::pid_t Attach(lldb::pid_t pid, Status &error); @@ -323,8 +323,8 @@ private: Status GetSignalInfo(lldb::tid_t tid, void *siginfo); /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) - /// corresponding to the given thread ID to the memory pointed to - /// by @p message. + /// corresponding to the given thread ID to the memory pointed to by @p + /// message. Status GetEventMessage(lldb::tid_t tid, unsigned long *message); void NotifyThreadDeath(lldb::tid_t tid); diff --git a/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h b/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h index 72e84645955..c93cc4fbfd7 100644 --- a/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h +++ b/lldb/source/Plugins/Process/FreeBSD/FreeBSDThread.h @@ -24,7 +24,7 @@ class POSIXBreakpointProtocol; //------------------------------------------------------------------------------ // @class FreeBSDThread -// @brief Abstraction of a FreeBSD thread. +// Abstraction of a FreeBSD thread. class FreeBSDThread : public lldb_private::Thread { public: //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h b/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h index 96861852b38..ff369310717 100644 --- a/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h +++ b/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h @@ -17,7 +17,7 @@ //===----------------------------------------------------------------------===// /// @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: @@ -27,7 +27,7 @@ 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: @@ -46,7 +46,7 @@ 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 { diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp index a498e559915..51fdf2e5ef3 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp @@ -201,15 +201,16 @@ static bool EnsureFDFlags(int fd, int flags, Status &error) { //------------------------------------------------------------------------------ /// @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 -/// a ProcessMonitor is asked to deliver or change the state of an inferior -/// process the operation must be "funneled" to a specific thread to perform the -/// task. The Operation class provides an abstract base for all services the -/// ProcessMonitor must perform via the single virtual function Execute, thus -/// encapsulating the code that needs to run in the privileged context. +/// 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 a ProcessMonitor is asked to deliver or change the state +/// of an inferior process the operation must be "funneled" to a specific +/// thread to perform the task. The Operation class provides an abstract base +/// for all services the ProcessMonitor must perform via the single virtual +/// function Execute, thus encapsulating the code that needs to run in the +/// privileged context. class Operation { public: virtual ~Operation() {} @@ -218,7 +219,7 @@ public: //------------------------------------------------------------------------------ /// @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, @@ -244,7 +245,7 @@ void ReadOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @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, @@ -270,7 +271,7 @@ void WriteOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ReadRegOperation -/// @brief Implements ProcessMonitor::ReadRegisterValue. +/// Implements ProcessMonitor::ReadRegisterValue. class ReadRegOperation : public Operation { public: ReadRegOperation(lldb::tid_t tid, unsigned offset, unsigned size, @@ -310,7 +311,7 @@ void ReadRegOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class WriteRegOperation -/// @brief Implements ProcessMonitor::WriteRegisterValue. +/// Implements ProcessMonitor::WriteRegisterValue. class WriteRegOperation : public Operation { public: WriteRegOperation(lldb::tid_t tid, unsigned offset, @@ -343,7 +344,7 @@ void WriteRegOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ReadDebugRegOperation -/// @brief Implements ProcessMonitor::ReadDebugRegisterValue. +/// Implements ProcessMonitor::ReadDebugRegisterValue. class ReadDebugRegOperation : public Operation { public: ReadDebugRegOperation(lldb::tid_t tid, unsigned offset, unsigned size, @@ -378,7 +379,7 @@ void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class WriteDebugRegOperation -/// @brief Implements ProcessMonitor::WriteDebugRegisterValue. +/// Implements ProcessMonitor::WriteDebugRegisterValue. class WriteDebugRegOperation : public Operation { public: WriteDebugRegOperation(lldb::tid_t tid, unsigned offset, @@ -411,7 +412,7 @@ void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ReadGPROperation -/// @brief Implements ProcessMonitor::ReadGPR. +/// Implements ProcessMonitor::ReadGPR. class ReadGPROperation : public Operation { public: ReadGPROperation(lldb::tid_t tid, void *buf, bool &result) @@ -438,7 +439,7 @@ void ReadGPROperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ReadFPROperation -/// @brief Implements ProcessMonitor::ReadFPR. +/// Implements ProcessMonitor::ReadFPR. class ReadFPROperation : public Operation { public: ReadFPROperation(lldb::tid_t tid, void *buf, bool &result) @@ -461,7 +462,7 @@ void ReadFPROperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class WriteGPROperation -/// @brief Implements ProcessMonitor::WriteGPR. +/// Implements ProcessMonitor::WriteGPR. class WriteGPROperation : public Operation { public: WriteGPROperation(lldb::tid_t tid, void *buf, bool &result) @@ -484,7 +485,7 @@ void WriteGPROperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class WriteFPROperation -/// @brief Implements ProcessMonitor::WriteFPR. +/// Implements ProcessMonitor::WriteFPR. class WriteFPROperation : public Operation { public: WriteFPROperation(lldb::tid_t tid, void *buf, bool &result) @@ -507,7 +508,7 @@ void WriteFPROperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ResumeOperation -/// @brief Implements ProcessMonitor::Resume. +/// Implements ProcessMonitor::Resume. class ResumeOperation : public Operation { public: ResumeOperation(uint32_t signo, bool &result) @@ -538,7 +539,7 @@ void ResumeOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class SingleStepOperation -/// @brief Implements ProcessMonitor::SingleStep. +/// Implements ProcessMonitor::SingleStep. class SingleStepOperation : public Operation { public: SingleStepOperation(uint32_t signo, bool &result) @@ -566,7 +567,7 @@ void SingleStepOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @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) @@ -595,7 +596,7 @@ void LwpInfoOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class ThreadSuspendOperation -/// @brief Implements ProcessMonitor::ThreadSuspend. +/// Implements ProcessMonitor::ThreadSuspend. class ThreadSuspendOperation : public Operation { public: ThreadSuspendOperation(lldb::tid_t tid, bool suspend, bool &result) @@ -615,7 +616,7 @@ void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class EventMessageOperation -/// @brief Implements ProcessMonitor::GetEventMessage. +/// Implements ProcessMonitor::GetEventMessage. class EventMessageOperation : public Operation { public: EventMessageOperation(lldb::tid_t tid, unsigned long *message, bool &result) @@ -645,7 +646,7 @@ void EventMessageOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class KillOperation -/// @brief Implements ProcessMonitor::Kill. +/// Implements ProcessMonitor::Kill. class KillOperation : public Operation { public: KillOperation(bool &result) : m_result(result) {} @@ -667,7 +668,7 @@ void KillOperation::Execute(ProcessMonitor *monitor) { //------------------------------------------------------------------------------ /// @class DetachOperation -/// @brief Implements ProcessMonitor::Detach. +/// Implements ProcessMonitor::Detach. class DetachOperation : public Operation { public: DetachOperation(Status &result) : m_error(result) {} @@ -714,11 +715,10 @@ ProcessMonitor::AttachArgs::~AttachArgs() {} //------------------------------------------------------------------------------ /// The basic design of the ProcessMonitor is built around two threads. /// -/// One thread (@see SignalThread) simply blocks on a call to waitpid() looking -/// for changes in the debugee state. When a change is detected a +/// One thread (@see SignalThread) simply blocks on a call to waitpid() +/// looking for changes in the debugee state. When a change is detected a /// ProcessMessage is sent to the associated ProcessFreeBSD instance. This -/// thread -/// "drives" state changes in the debugger. +/// thread "drives" state changes in the debugger. /// /// The second thread (@see OperationThread) is responsible for two things 1) /// launching or attaching to the inferior process, and then 2) servicing diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h index c1c68f77644..1d3e2d746fa 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h @@ -32,10 +32,10 @@ class ProcessFreeBSD; 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. +/// Upon construction, this class prepares and launches an inferior process +/// for debugging. /// /// Changes in the inferior process state are propagated to the associated /// ProcessFreeBSD instance by calling ProcessFreeBSD::SendMessage with the @@ -74,8 +74,7 @@ public: /// standard error of this debugee. Even if stderr and stdout were /// redirected on launch it may still happen that data is available on this /// descriptor (if the inferior process opens /dev/tty, for example). This - /// descriptor is - /// closed after a call to StopMonitor(). + /// descriptor is closed after a call to StopMonitor(). /// /// If this monitor was attached to an existing process this method returns /// -1. @@ -95,8 +94,8 @@ public: size_t WriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, lldb_private::Status &error); - /// Reads the contents from the register identified by the given (architecture - /// dependent) offset. + /// Reads the contents from the register identified by the given + /// (architecture dependent) offset. /// /// This method is provided for use by RegisterContextFreeBSD derivatives. bool ReadRegisterValue(lldb::tid_t tid, unsigned offset, const char *reg_name, @@ -215,8 +214,8 @@ private: /// @class LauchArgs /// - /// @brief Simple structure to pass data to the thread responsible for - /// launching a child process. + /// Simple structure to pass data to the thread responsible for launching a + /// child process. struct LaunchArgs : OperationArgs { LaunchArgs(ProcessMonitor *monitor, lldb_private::Module *module, char const **argv, lldb_private::Environment env, diff --git a/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h b/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h index 4ff5121bac1..97de5885605 100644 --- a/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h +++ b/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h @@ -20,7 +20,7 @@ //------------------------------------------------------------------------------ /// @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; } diff --git a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h index f078c1ac30e..dea7e61959a 100644 --- a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h +++ b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h @@ -31,10 +31,10 @@ class Scalar; 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. +/// Upon construction, this class prepares and launches an inferior process +/// for debugging. /// /// Changes in the inferior process state are broadcasted. class NativeProcessLinux : public NativeProcessProtocol { diff --git a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h index 7090fce34fc..142f74ecf19 100644 --- a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h +++ b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h @@ -20,10 +20,10 @@ 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. +/// Upon construction, this class prepares and launches an inferior process +/// for debugging. /// /// Changes in the inferior process state are broadcasted. class NativeProcessNetBSD : public NativeProcessProtocol { diff --git a/lldb/source/Plugins/Process/Utility/HistoryThread.h b/lldb/source/Plugins/Process/Utility/HistoryThread.h index 363ba266963..7675a95246a 100644 --- a/lldb/source/Plugins/Process/Utility/HistoryThread.h +++ b/lldb/source/Plugins/Process/Utility/HistoryThread.h @@ -29,13 +29,13 @@ namespace lldb_private { //---------------------------------------------------------------------- /// @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 /// process execution. It is given a backtrace list of pc addresses and -/// optionally a stop_id of when those pc addresses were collected, and it will -/// create stack frames for them. +/// optionally a stop_id of when those pc addresses were collected, and it +/// will create stack frames for them. //---------------------------------------------------------------------- class HistoryThread : public lldb_private::Thread { diff --git a/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h b/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h index 1894b536812..5d7ad89ad39 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h +++ b/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h @@ -19,7 +19,7 @@ namespace lldb_private { ///------------------------------------------------------------------------------ /// @class RegisterInfoInterface /// -/// @brief RegisterInfo interface to patch RegisterInfo structure for archs. +/// RegisterInfo interface to patch RegisterInfo structure for archs. ///------------------------------------------------------------------------------ class RegisterInfoInterface { public: diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 760f9131c94..87d347ff594 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -1391,7 +1391,7 @@ static TemplateParameterList *CreateTemplateParameterList( 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; diff --git a/lldb/source/Utility/FastDemangle.cpp b/lldb/source/Utility/FastDemangle.cpp index cc045264c7b..d92670a9199 100644 --- a/lldb/source/Utility/FastDemangle.cpp +++ b/lldb/source/Utility/FastDemangle.cpp @@ -25,7 +25,7 @@ namespace { -/// @brief Represents the collection of qualifiers on a type +/// Represents the collection of qualifiers on a type enum Qualifiers { QualifierNone = 0, @@ -37,7 +37,7 @@ enum Qualifiers { QualifierPointer = 32 }; -/// @brief Categorizes the recognized operators +/// Categorizes the recognized operators enum class OperatorKind { Unary, @@ -50,23 +50,23 @@ enum class OperatorKind { NoMatch }; -/// @brief Represents one of the recognized two-character operator -/// abbreviations used when parsing operators as names and expressions +/// Represents one of the recognized two-character operator abbreviations used +/// when parsing operators as names and expressions struct Operator { const char *name; OperatorKind kind; }; -/// @brief Represents a range of characters in the output buffer, typically for -/// use with RewriteRange() +/// Represents a range of characters in the output buffer, typically for use +/// with RewriteRange() struct BufferRange { int offset; int length; }; -/// @brief Transient state required while parsing a name +/// Transient state required while parsing a name struct NameState { bool parse_function_params; @@ -75,12 +75,13 @@ struct NameState { 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 /// time. Where the implementation doesn't know how to demangle a symbol it -/// fails gracefully to allow the caller to fall back to the existing demangler. +/// fails gracefully to allow the caller to fall back to the existing +/// demangler. /// /// Over time the full mangling spec should be supported without compromising /// performance for the most common cases. @@ -91,7 +92,7 @@ public: // 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 @@ -107,18 +108,18 @@ public: 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 - /// other purposes between calls. The provided memory will not be freed - /// when this instance is destroyed. + /// overwritten during calls to GetDemangledCopy() but can be used for other + /// purposes between calls. The provided memory will not be freed when this + /// instance is destroyed. /// /// If demangling a symbol requires additional space it will be allocated /// and managed by the demangler instance. /// - /// @param storage_ptr Valid pointer to at least storage_size bytes of - /// space that the SymbolDemangler can use during demangling + /// @param storage_ptr Valid pointer to at least storage_size bytes of space + /// that the SymbolDemangler can use during demangling /// /// @param storage_size Number of bytes of space available scratch memory /// referenced by storage_ptr @@ -138,8 +139,8 @@ public: m_owns_buffer = false; } - /// @brief Destroys the SymbolDemangler and deallocates any scratch - /// memory that it owns + /// Destroys the SymbolDemangler and deallocates any scratch memory that it + /// owns ~SymbolDemangler() { if (m_owns_buffer) @@ -153,11 +154,11 @@ public: 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 - /// the Itanium C++ ABI mangling specification as implemented by Clang + /// @param mangled_name Valid null-terminated C++ mangled name following the + /// Itanium C++ ABI mangling specification as implemented by Clang /// /// @result Newly allocated null-terminated demangled name when demangling /// is successful, and nullptr when demangling fails. The caller is |