diff options
Diffstat (limited to 'lldb/include/lldb/Symbol')
| -rw-r--r-- | lldb/include/lldb/Symbol/Block.h | 92 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/CompileUnit.h | 98 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/CompilerDeclContext.h | 8 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/DWARFCallFrameInfo.h | 2 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/DeclVendor.h | 10 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/Declaration.h | 40 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/Function.h | 146 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/LineEntry.h | 44 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/LineTable.h | 60 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/ObjectContainer.h | 22 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/ObjectFile.h | 102 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/Symbol.h | 8 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/SymbolContext.h | 104 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/SymbolContextScope.h | 22 | ||||
| -rw-r--r-- | lldb/include/lldb/Symbol/SymbolFile.h | 2 |
15 files changed, 380 insertions, 380 deletions
diff --git a/lldb/include/lldb/Symbol/Block.h b/lldb/include/lldb/Symbol/Block.h index 2159250c503..5bf8cd82c82 100644 --- a/lldb/include/lldb/Symbol/Block.h +++ b/lldb/include/lldb/Symbol/Block.h @@ -23,7 +23,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class Block Block.h "lldb/Symbol/Block.h" +/// \class Block Block.h "lldb/Symbol/Block.h" /// A class that describes a single lexical block. /// /// A Function object owns a BlockList object which owns one or more @@ -52,7 +52,7 @@ public: /// \a block_list is used to represent the parent, sibling, and child block /// information and also allows for partial parsing at the block level. /// - /// @param[in] uid + /// \param[in] uid /// The UID for a given block. This value is given by the /// SymbolFile plug-in and can be any value that helps the /// SymbolFile plug-in to match this block back to the debug @@ -60,13 +60,13 @@ public: /// depth parsing. Common values would be the index into a /// table, or an offset into the debug information. /// - /// @param[in] depth + /// \param[in] depth /// The integer depth of this block in the block list hierarchy. /// - /// @param[in] block_list + /// \param[in] block_list /// The block list that this object belongs to. /// - /// @see BlockList + /// \see BlockList //------------------------------------------------------------------ Block(lldb::user_id_t uid); @@ -78,7 +78,7 @@ public: //------------------------------------------------------------------ /// Add a child to this object. /// - /// @param[in] child_block_sp + /// \param[in] child_block_sp /// A shared pointer to a child block that will get added to /// this block. //------------------------------------------------------------------ @@ -87,11 +87,11 @@ public: //------------------------------------------------------------------ /// Add a new offset range to this block. /// - /// @param[in] start_offset + /// \param[in] start_offset /// An offset into this Function's address range that /// describes the start address of a range for this block. /// - /// @param[in] end_offset + /// \param[in] end_offset /// An offset into this Function's address range that /// describes the end address of a range for this block. //------------------------------------------------------------------ @@ -100,9 +100,9 @@ public: void FinalizeRanges(); //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) + /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void CalculateSymbolContext(SymbolContext *sc) override; @@ -117,10 +117,10 @@ public: //------------------------------------------------------------------ /// Check if an offset is in one of the block offset ranges. /// - /// @param[in] range_offset + /// \param[in] range_offset /// An offset into the Function's address range. /// - /// @return + /// \return /// Returns \b true if \a range_offset falls in one of this /// block's ranges, \b false otherwise. //------------------------------------------------------------------ @@ -129,10 +129,10 @@ public: //------------------------------------------------------------------ /// Check if a offset range is in one of the block offset ranges. /// - /// @param[in] range + /// \param[in] range /// An offset range into the Function's address range. /// - /// @return + /// \return /// Returns \b true if \a range falls in one of this /// block's ranges, \b false otherwise. //------------------------------------------------------------------ @@ -141,10 +141,10 @@ public: //------------------------------------------------------------------ /// Check if this object contains "block" as a child block at any depth. /// - /// @param[in] block + /// \param[in] block /// A potential child block. /// - /// @return + /// \return /// Returns \b true if \a block is a child of this block, \b /// false otherwise. //------------------------------------------------------------------ @@ -153,29 +153,29 @@ public: //------------------------------------------------------------------ /// Dump the block contents. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] base_addr + /// \param[in] base_addr /// The resolved start address of the Function's address /// range. This should be resolved as the file or load address /// prior to passing the value into this function for dumping. /// - /// @param[in] depth + /// \param[in] depth /// Limit the number of levels deep that this function should /// print as this block can contain child blocks. Specify /// INT_MAX to dump all child blocks. /// - /// @param[in] show_context + /// \param[in] show_context /// If \b true, variables will dump their context information. //------------------------------------------------------------------ void Dump(Stream *s, lldb::addr_t base_addr, int32_t depth, bool show_context) const; //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) + /// \copydoc SymbolContextScope::DumpSymbolContext(Stream*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void DumpSymbolContext(Stream *s) override; @@ -187,7 +187,7 @@ public: //------------------------------------------------------------------ /// Get the parent block. /// - /// @return + /// \return /// The parent block pointer, or nullptr if this block has no /// parent. //------------------------------------------------------------------ @@ -196,7 +196,7 @@ public: //------------------------------------------------------------------ /// Get the inlined block that contains this block. /// - /// @return + /// \return /// If this block contains inlined function info, it will return /// this block, else parent blocks will be searched to see if /// any contain this block. nullptr will be returned if this block @@ -207,7 +207,7 @@ public: //------------------------------------------------------------------ /// Get the inlined parent block for this block. /// - /// @return + /// \return /// The parent block pointer, or nullptr if this block has no /// parent. //------------------------------------------------------------------ @@ -216,7 +216,7 @@ public: //------------------------------------------------------------------ /// Get the sibling block for this block. /// - /// @return + /// \return /// The sibling block pointer, or nullptr if this block has no /// sibling. //------------------------------------------------------------------ @@ -225,7 +225,7 @@ public: //------------------------------------------------------------------ /// Get the first child block. /// - /// @return + /// \return /// The first child block pointer, or nullptr if this block has no /// children. //------------------------------------------------------------------ @@ -236,12 +236,12 @@ public: //------------------------------------------------------------------ /// Get the variable list for this block only. /// - /// @param[in] can_create + /// \param[in] can_create /// If \b true, the variables can be parsed if they already /// haven't been, else the current state of the block will be /// returned. /// - /// @return + /// \return /// A variable list shared pointer that contains all variables /// for this block. //------------------------------------------------------------------ @@ -251,24 +251,24 @@ public: /// Get the variable list for this block and optionally all child blocks if /// \a get_child_variables is \b true. /// - /// @param[in] get_child_variables + /// \param[in] get_child_variables /// If \b true, all variables from all child blocks will be /// added to the variable list. /// - /// @param[in] can_create + /// \param[in] can_create /// If \b true, the variables can be parsed if they already /// haven't been, else the current state of the block will be /// returned. Passing \b true for this parameter can be used /// to see the current state of what has been parsed up to this /// point. /// - /// @param[in] add_inline_child_block_variables + /// \param[in] add_inline_child_block_variables /// If this is \b false, no child variables of child blocks /// that are inlined functions will be gotten. If \b true then /// all child variables will be added regardless of whether they /// come from inlined functions or not. /// - /// @return + /// \return /// A variable list shared pointer that contains all variables /// for this block. //------------------------------------------------------------------ @@ -281,27 +281,27 @@ public: /// Appends the variables from this block, and optionally from all parent /// blocks, to \a variable_list. /// - /// @param[in] can_create + /// \param[in] can_create /// If \b true, the variables can be parsed if they already /// haven't been, else the current state of the block will be /// returned. Passing \b true for this parameter can be used /// to see the current state of what has been parsed up to this /// point. /// - /// @param[in] get_parent_variables + /// \param[in] get_parent_variables /// If \b true, all variables from all parent blocks will be /// added to the variable list. /// - /// @param[in] stop_if_block_is_inlined_function + /// \param[in] stop_if_block_is_inlined_function /// If \b true, all variables from all parent blocks will be /// added to the variable list until there are no parent blocks /// or the parent block has inlined function info. /// - /// @param[in,out] variable_list + /// \param[in,out] variable_list /// All variables in this block, and optionally all parent /// blocks will be added to this list. /// - /// @return + /// \return /// The number of variable that were appended to \a /// variable_list. //------------------------------------------------------------------ @@ -313,7 +313,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for any inlined function information. /// - /// @return + /// \return /// A const pointer to any inlined function information, or nullptr /// if this is a regular block. //------------------------------------------------------------------ @@ -325,7 +325,7 @@ public: /// Get the symbol file which contains debug info for this block's /// symbol context module. /// - /// @return A pointer to the symbol file or nullptr. + /// \return A pointer to the symbol file or nullptr. //------------------------------------------------------------------ SymbolFile *GetSymbolFile(); @@ -337,7 +337,7 @@ public: /// Returns the cost of this object plus any owned objects from the ranges, /// variables, and inline function information. /// - /// @return + /// \return /// The number of bytes that this object occupies in memory. //------------------------------------------------------------------ size_t MemorySize() const; @@ -345,21 +345,21 @@ public: //------------------------------------------------------------------ /// Set accessor for any inlined function information. /// - /// @param[in] name + /// \param[in] name /// The method name for the inlined function. This value should /// not be nullptr. /// - /// @param[in] mangled + /// \param[in] mangled /// The mangled method name for the inlined function. This can /// be nullptr if there is no mangled name for an inlined function /// or if the name is the same as \a name. /// - /// @param[in] decl_ptr + /// \param[in] decl_ptr /// A optional pointer to declaration information for the /// inlined function information. This value can be nullptr to /// indicate that no declaration information is available. /// - /// @param[in] call_decl_ptr + /// \param[in] call_decl_ptr /// Optional calling location declaration information that /// describes from where this inlined function was called. //------------------------------------------------------------------ @@ -377,7 +377,7 @@ public: /// Called by the SymbolFile plug-ins after they have parsed the variable /// lists and are ready to hand ownership of the list over to this object. /// - /// @param[in] variable_list_sp + /// \param[in] variable_list_sp /// A shared pointer to a VariableList. //------------------------------------------------------------------ void SetVariableList(lldb::VariableListSP &variable_list_sp) { diff --git a/lldb/include/lldb/Symbol/CompileUnit.h b/lldb/include/lldb/Symbol/CompileUnit.h index 556fee0a7e8..20751ec5734 100644 --- a/lldb/include/lldb/Symbol/CompileUnit.h +++ b/lldb/include/lldb/Symbol/CompileUnit.h @@ -22,7 +22,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h" +/// \class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h" /// A class that describes a compilation unit. /// /// A representation of a compilation unit, or compiled source file. @@ -47,34 +47,34 @@ public: /// convert into a FileSpec, the SymbolFile plug-in supplied \a uid, and the /// source language type. /// - /// @param[in] module + /// \param[in] module /// The parent module that owns this compile unit. This value /// must be a valid pointer value. /// - /// @param[in] user_data + /// \param[in] user_data /// User data where the SymbolFile parser can store data. /// - /// @param[in] pathname + /// \param[in] pathname /// The path to the source file for this compile unit. /// - /// @param[in] uid + /// \param[in] uid /// The user ID of the compile unit. This value is supplied by /// the SymbolFile plug-in and should be a value that allows /// the SymbolFile plug-in to easily locate and parse additional /// information for the compile unit. /// - /// @param[in] language + /// \param[in] language /// A language enumeration type that describes the main language /// of this compile unit. /// - /// @param[in] is_optimized + /// \param[in] is_optimized /// A value that can initialized with eLazyBoolYes, eLazyBoolNo /// or eLazyBoolCalculate. If set to eLazyBoolCalculate, then /// an extra call into SymbolVendor will be made to calculate if /// the compile unit is optimized will be made when /// CompileUnit::GetIsOptimized() is called. /// - /// @see lldb::LanguageType + /// \see lldb::LanguageType //------------------------------------------------------------------ CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, const char *pathname, lldb::user_id_t uid, @@ -87,35 +87,35 @@ public: /// convert into a FileSpec, the SymbolFile plug-in supplied \a uid, and the /// source language type. /// - /// @param[in] module + /// \param[in] module /// The parent module that owns this compile unit. This value /// must be a valid pointer value. /// - /// @param[in] user_data + /// \param[in] user_data /// User data where the SymbolFile parser can store data. /// - /// @param[in] file_spec + /// \param[in] file_spec /// The file specification for the source file of this compile /// unit. /// - /// @param[in] uid + /// \param[in] uid /// The user ID of the compile unit. This value is supplied by /// the SymbolFile plug-in and should be a value that allows /// the plug-in to easily locate and parse /// additional information for the compile unit. /// - /// @param[in] language + /// \param[in] language /// A language enumeration type that describes the main language /// of this compile unit. /// - /// @param[in] is_optimized + /// \param[in] is_optimized /// A value that can initialized with eLazyBoolYes, eLazyBoolNo /// or eLazyBoolCalculate. If set to eLazyBoolCalculate, then /// an extra call into SymbolVendor will be made to calculate if /// the compile unit is optimized will be made when /// CompileUnit::GetIsOptimized() is called. /// - /// @see lldb::LanguageType + /// \see lldb::LanguageType //------------------------------------------------------------------ CompileUnit(const lldb::ModuleSP &module_sp, void *user_data, const FileSpec &file_spec, lldb::user_id_t uid, @@ -132,15 +132,15 @@ public: /// Typically called by the SymbolFile plug-ins as they partially parse the /// debug information. /// - /// @param[in] function_sp + /// \param[in] function_sp /// A shared pointer to the Function object. //------------------------------------------------------------------ void AddFunction(lldb::FunctionSP &function_sp); //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) + /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void CalculateSymbolContext(SymbolContext *sc) override; @@ -149,9 +149,9 @@ public: CompileUnit *CalculateSymbolContextCompileUnit() override; //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) + /// \copydoc SymbolContextScope::DumpSymbolContext(Stream*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void DumpSymbolContext(Stream *s) override; @@ -170,9 +170,9 @@ public: /// This provides raw access to the function shared pointer list and will not /// cause the SymbolFile plug-in to parse any unparsed functions. /// - /// @note Prefer using FindFunctionByUID over this if possible. + /// \note Prefer using FindFunctionByUID over this if possible. /// - /// @param[in] lambda + /// \param[in] lambda /// The lambda that should be applied to every function. The lambda can /// return true if the iteration should be aborted earlier. //------------------------------------------------------------------ @@ -182,10 +182,10 @@ public: //------------------------------------------------------------------ /// Dump the compile unit contents to the stream \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] show_context + /// \param[in] show_context /// If \b true, variables will dump their symbol context /// information. //------------------------------------------------------------------ @@ -204,27 +204,27 @@ public: /// file and line by starting with \a start_idx equal to zero, and calling /// this function back with the return value + 1. /// - /// @param[in] start_idx + /// \param[in] start_idx /// The zero based index at which to start looking for matches. /// - /// @param[in] line + /// \param[in] line /// The line number to search for. /// - /// @param[in] file_spec_ptr + /// \param[in] file_spec_ptr /// If non-NULL search for entries that match this file spec, /// else if NULL, search for line entries that match the compile /// unit file. /// - /// @param[in] exact + /// \param[in] exact /// If \btrue match only if there is a line table entry for this line /// number. /// If \bfalse, find the line table entry equal to or after this line /// number. /// - /// @param[out] line_entry + /// \param[out] line_entry /// If non-NULL, a copy of the line entry that was found. /// - /// @return + /// \return /// The zero based index of a matching line entry, or UINT32_MAX /// if no matching line entry is found. //------------------------------------------------------------------ @@ -239,7 +239,7 @@ public: /// use this function to determine if the line table has be parsed yet. /// Clients use this function to get the line table from a compile unit. /// - /// @return + /// \return /// The line table object pointer, or NULL if this line table /// hasn't been parsed yet. //------------------------------------------------------------------ @@ -253,7 +253,7 @@ public: /// The support file list is used by the line table, and any objects that /// have valid Declaration objects. /// - /// @return + /// \return /// A support file list object. //------------------------------------------------------------------ FileSpecList &GetSupportFiles(); @@ -264,7 +264,7 @@ public: /// This reports all the imports that the compile unit made, including the /// current module. /// - /// @return + /// \return /// A list of imported module names. //------------------------------------------------------------------ const std::vector<SourceModule> &GetImportedModules(); @@ -275,7 +275,7 @@ public: /// SymbolFile plug-ins can store user data to internal state or objects to /// quickly allow them to parse more information for a given object. /// - /// @return + /// \return /// The user data stored with the CompileUnit when it was /// constructed. //------------------------------------------------------------------ @@ -288,14 +288,14 @@ public: /// variable list will contain all global and static variables that were /// defined at the compile unit level. /// - /// @param[in] can_create + /// \param[in] can_create /// If \b true, the variable list will be parsed on demand. If /// \b false, the current variable list will be returned even /// if it contains a NULL VariableList object (typically /// called by dumping routines that want to display only what /// has currently been parsed). /// - /// @return + /// \return /// A shared pointer to a variable list, that can contain NULL /// VariableList pointer if there are no global or static /// variables. @@ -308,13 +308,13 @@ public: /// Typically used by SymbolFile plug-ins when partially parsing the debug /// information to see if the function has been parsed yet. /// - /// @param[in] uid + /// \param[in] uid /// The user ID of the function to find. This value is supplied /// by the SymbolFile plug-in and should be a value that /// allows the plug-in to easily locate and parse additional /// information in the function. /// - /// @return + /// \return /// A shared pointer to the function object that might contain /// a NULL Function pointer. //------------------------------------------------------------------ @@ -327,7 +327,7 @@ public: /// hands ownership of the line table to this object. The compile unit owns /// the line table object and will delete the object when it is deleted. /// - /// @param[in] line_table + /// \param[in] line_table /// A line table object pointer that this object now owns. //------------------------------------------------------------------ void SetLineTable(LineTable *line_table); @@ -340,7 +340,7 @@ public: /// Called by the SymbolFile plug-ins after they have parsed the variable /// lists and are ready to hand ownership of the list over to this object. /// - /// @param[in] variable_list_sp + /// \param[in] variable_list_sp /// A shared pointer to a VariableList. //------------------------------------------------------------------ void SetVariableList(lldb::VariableListSP &variable_list_sp); @@ -351,28 +351,28 @@ public: /// Given a file in \a file_spec, and a line number, find all instances and /// append them to the supplied symbol context list \a sc_list. /// - /// @param[in] file_spec + /// \param[in] file_spec /// A file specification. If \a file_spec contains no directory /// information, only the basename will be used when matching /// contexts. If the directory in \a file_spec is valid, a /// complete file specification match will be performed. /// - /// @param[in] line + /// \param[in] line /// The line number to match against the compile unit's line /// tables. /// - /// @param[in] check_inlines + /// \param[in] check_inlines /// If \b true this function will also match any inline /// file and line matches. If \b false, the compile unit's /// file specification must match \a file_spec for any matches /// to be returned. /// - /// @param[in] exact + /// \param[in] exact /// If true, only resolve the context if \a line exists in the line table. /// If false, resolve the context to the closest line greater than \a line /// in the line table. /// - /// @param[in] resolve_scope + /// \param[in] resolve_scope /// For each matching line entry, this bitfield indicates what /// values within each SymbolContext that gets added to \a /// sc_list will be resolved. See the SymbolContext::Scope @@ -380,14 +380,14 @@ public: /// resolved. Only SymbolContext entries that can be resolved /// using a LineEntry base address will be able to be resolved. /// - /// @param[out] sc_list + /// \param[out] sc_list /// A SymbolContext list class that will get any matching /// entries appended to. /// - /// @return + /// \return /// The number of new matches that were added to \a sc_list. /// - /// @see enum SymbolContext::Scope + /// \see enum SymbolContext::Scope //------------------------------------------------------------------ uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line, bool check_inlines, bool exact, @@ -402,7 +402,7 @@ public: /// would expect them, stepping through the source lines in the function may /// appear strange, etc. /// - /// @return + /// \return /// Returns 'true' if this compile unit was compiled with /// optimization. 'false' indicates that either the optimization /// is unknown, or this compile unit was built without optimization. diff --git a/lldb/include/lldb/Symbol/CompilerDeclContext.h b/lldb/include/lldb/Symbol/CompilerDeclContext.h index 15747c8be0b..92c5d3ce127 100644 --- a/lldb/include/lldb/Symbol/CompilerDeclContext.h +++ b/lldb/include/lldb/Symbol/CompilerDeclContext.h @@ -52,22 +52,22 @@ public: //---------------------------------------------------------------------- /// Checks if this decl context represents a method of a class. /// - /// @param[out] language_ptr + /// \param[out] language_ptr /// If non NULL and \b true is returned from this function, /// this will indicate if the language that respresents the method. /// - /// @param[out] is_instance_method_ptr + /// \param[out] is_instance_method_ptr /// If non NULL and \b true is returned from this function, /// this will indicate if the method is an instance function (true) /// or a class method (false indicating the function is static, or /// doesn't require an instance of the class to be called). /// - /// @param[out] language_object_name_ptr + /// \param[out] language_object_name_ptr /// If non NULL and \b true is returned from this function, /// this will indicate if implicit object name for the language /// like "this" for C++, and "self" for Objective C. /// - /// @return + /// \return /// Returns true if this is a decl context that represents a method /// in a struct, union or class. //---------------------------------------------------------------------- diff --git a/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h b/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h index 80302e115f2..73306b01355 100644 --- a/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h +++ b/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h @@ -59,7 +59,7 @@ public: // functions in the Module. But the eh_frame can help to give the addresses // of these stripped symbols, at least. // - // @param[out] function_info + // \param[out] function_info // A vector provided by the caller is filled out. May be empty if no // FDEs/no eh_frame // is present in this Module. diff --git a/lldb/include/lldb/Symbol/DeclVendor.h b/lldb/include/lldb/Symbol/DeclVendor.h index 3082f22257d..5ab6bf1d6bd 100644 --- a/lldb/include/lldb/Symbol/DeclVendor.h +++ b/lldb/include/lldb/Symbol/DeclVendor.h @@ -35,17 +35,17 @@ public: /// Look up the set of Decls that the DeclVendor currently knows about /// matching a given name. /// - /// @param[in] name + /// \param[in] name /// The name to look for. /// - /// @param[in] append + /// \param[in] append /// If true, FindDecls will clear "decls" when it starts. /// - /// @param[in] max_matches + /// \param[in] max_matches /// The maximum number of Decls to return. UINT32_MAX means "as /// many as possible." /// - /// @return + /// \return /// The number of Decls added to decls; will not exceed /// max_matches. //------------------------------------------------------------------ @@ -57,7 +57,7 @@ public: /// Interface for ExternalASTMerger. Returns an ImporterSource /// allowing type completion. /// - /// @return + /// \return /// An ImporterSource for this DeclVendor. //------------------------------------------------------------------ virtual clang::ExternalASTMerger::ImporterSource GetImporterSource() = 0; diff --git a/lldb/include/lldb/Symbol/Declaration.h b/lldb/include/lldb/Symbol/Declaration.h index 61e75d60f4c..bfbbce5a898 100644 --- a/lldb/include/lldb/Symbol/Declaration.h +++ b/lldb/include/lldb/Symbol/Declaration.h @@ -15,7 +15,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class Declaration Declaration.h "lldb/Symbol/Declaration.h" +/// \class Declaration Declaration.h "lldb/Symbol/Declaration.h" /// A class that describes the declaration location of a /// lldb object. /// @@ -40,15 +40,15 @@ public: //------------------------------------------------------------------ /// Construct with file specification, and optional line and column. /// - /// @param[in] file_spec + /// \param[in] file_spec /// The file specification that describes where this was /// declared. /// - /// @param[in] line + /// \param[in] line /// The line number that describes where this was declared. Set /// to zero if there is no line number information. /// - /// @param[in] column + /// \param[in] column /// The column number that describes where this was declared. /// Set to zero if there is no column number information. //------------------------------------------------------------------ @@ -108,16 +108,16 @@ public: /// specifications are equal, then continue to compare the line number and /// column numbers respectively. /// - /// @param[in] lhs + /// \param[in] lhs /// The Left Hand Side const Declaration object reference. /// - /// @param[in] rhs + /// \param[in] rhs /// The Right Hand Side const Declaration object reference. /// - /// @return - /// @li -1 if lhs < rhs - /// @li 0 if lhs == rhs - /// @li 1 if lhs > rhs + /// \return + /// \li -1 if lhs < rhs + /// \li 0 if lhs == rhs + /// \li 1 if lhs > rhs //------------------------------------------------------------------ static int Compare(const Declaration &lhs, const Declaration &rhs); @@ -127,7 +127,7 @@ public: /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ void Dump(Stream *s, bool show_fullpaths) const; @@ -136,7 +136,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the declaration column number. /// - /// @return + /// \return /// Non-zero indicates a valid column number, zero indicates no /// column information is available. //------------------------------------------------------------------ @@ -151,7 +151,7 @@ public: //------------------------------------------------------------------ /// Get accessor for file specification. /// - /// @return + /// \return /// A reference to the file specification object. //------------------------------------------------------------------ FileSpec &GetFile() { return m_file; } @@ -159,7 +159,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for file specification. /// - /// @return + /// \return /// A const reference to the file specification object. //------------------------------------------------------------------ const FileSpec &GetFile() const { return m_file; } @@ -167,7 +167,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the declaration line number. /// - /// @return + /// \return /// Non-zero indicates a valid line number, zero indicates no /// line information is available. //------------------------------------------------------------------ @@ -178,19 +178,19 @@ public: //------------------------------------------------------------------ /// Get the memory cost of this object. /// - /// @return + /// \return /// The number of bytes that this object occupies in memory. /// The returned value does not include the bytes for any /// shared string values. /// - /// @see ConstString::StaticMemorySize () + /// \see ConstString::StaticMemorySize () //------------------------------------------------------------------ size_t MemorySize() const; //------------------------------------------------------------------ /// Set accessor for the declaration column number. /// - /// @param[in] column + /// \param[in] column /// Non-zero indicates a valid column number, zero indicates no /// column information is available. //------------------------------------------------------------------ @@ -203,7 +203,7 @@ public: //------------------------------------------------------------------ /// Set accessor for the declaration file specification. /// - /// @param[in] file_spec + /// \param[in] file_spec /// The new declaration file specification. //------------------------------------------------------------------ void SetFile(const FileSpec &file_spec) { m_file = file_spec; } @@ -211,7 +211,7 @@ public: //------------------------------------------------------------------ /// Set accessor for the declaration line number. /// - /// @param[in] line + /// \param[in] line /// Non-zero indicates a valid line number, zero indicates no /// line information is available. //------------------------------------------------------------------ diff --git a/lldb/include/lldb/Symbol/Function.h b/lldb/include/lldb/Symbol/Function.h index cf4e80ade0e..744db0f6fda 100644 --- a/lldb/include/lldb/Symbol/Function.h +++ b/lldb/include/lldb/Symbol/Function.h @@ -20,7 +20,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class FunctionInfo Function.h "lldb/Symbol/Function.h" +/// \class FunctionInfo Function.h "lldb/Symbol/Function.h" /// A class that contains generic function information. /// /// This provides generic function information that gets reused between inline @@ -32,12 +32,12 @@ public: /// Construct with the function method name and optional declaration /// information. /// - /// @param[in] name + /// \param[in] name /// A C string name for the method name for this function. This /// value should not be the mangled named, but the simple method /// name. /// - /// @param[in] decl_ptr + /// \param[in] decl_ptr /// Optional declaration information that describes where the /// function was declared. This can be NULL. //------------------------------------------------------------------ @@ -47,11 +47,11 @@ public: /// Construct with the function method name and optional declaration /// information. /// - /// @param[in] name + /// \param[in] name /// A name for the method name for this function. This value /// should not be the mangled named, but the simple method name. /// - /// @param[in] decl_ptr + /// \param[in] decl_ptr /// Optional declaration information that describes where the /// function was declared. This can be NULL. //------------------------------------------------------------------ @@ -70,16 +70,16 @@ public: /// First compares the method names, and if equal, then compares the /// declaration information. /// - /// @param[in] lhs + /// \param[in] lhs /// The Left Hand Side const FunctionInfo object reference. /// - /// @param[in] rhs + /// \param[in] rhs /// The Right Hand Side const FunctionInfo object reference. /// - /// @return - /// @li -1 if lhs < rhs - /// @li 0 if lhs == rhs - /// @li 1 if lhs > rhs + /// \return + /// \li -1 if lhs < rhs + /// \li 0 if lhs == rhs + /// \li 1 if lhs > rhs //------------------------------------------------------------------ static int Compare(const FunctionInfo &lhs, const FunctionInfo &rhs); @@ -89,7 +89,7 @@ public: /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ void Dump(Stream *s, bool show_fullpaths) const; @@ -97,7 +97,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the declaration information. /// - /// @return + /// \return /// A reference to the declaration object. //------------------------------------------------------------------ Declaration &GetDeclaration(); @@ -105,7 +105,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for the declaration information. /// - /// @return + /// \return /// A const reference to the declaration object. //------------------------------------------------------------------ const Declaration &GetDeclaration() const; @@ -113,7 +113,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the method name. /// - /// @return + /// \return /// A const reference to the method name object. //------------------------------------------------------------------ ConstString GetName() const; @@ -121,12 +121,12 @@ public: //------------------------------------------------------------------ /// Get the memory cost of this object. /// - /// @return + /// \return /// The number of bytes that this object occupies in memory. /// The returned value does not include the bytes for any /// shared string values. /// - /// @see ConstString::StaticMemorySize () + /// \see ConstString::StaticMemorySize () //------------------------------------------------------------------ virtual size_t MemorySize() const; @@ -140,7 +140,7 @@ protected: }; //---------------------------------------------------------------------- -/// @class InlineFunctionInfo Function.h "lldb/Symbol/Function.h" +/// \class InlineFunctionInfo Function.h "lldb/Symbol/Function.h" /// A class that describes information for an inlined function. //---------------------------------------------------------------------- class InlineFunctionInfo : public FunctionInfo { @@ -149,20 +149,20 @@ public: /// Construct with the function method name, mangled name, and optional /// declaration information. /// - /// @param[in] name + /// \param[in] name /// A C string name for the method name for this function. This /// value should not be the mangled named, but the simple method /// name. /// - /// @param[in] mangled + /// \param[in] mangled /// A C string name for the mangled name for this function. This /// value can be NULL if there is no mangled information. /// - /// @param[in] decl_ptr + /// \param[in] decl_ptr /// Optional declaration information that describes where the /// function was declared. This can be NULL. /// - /// @param[in] call_decl_ptr + /// \param[in] call_decl_ptr /// Optional calling location declaration information that /// describes from where this inlined function was called. //------------------------------------------------------------------ @@ -174,19 +174,19 @@ public: /// Construct with the function method name, mangled name, and optional /// declaration information. /// - /// @param[in] name + /// \param[in] name /// A name for the method name for this function. This value /// should not be the mangled named, but the simple method name. /// - /// @param[in] mangled + /// \param[in] mangled /// A name for the mangled name for this function. This value /// can be empty if there is no mangled information. /// - /// @param[in] decl_ptr + /// \param[in] decl_ptr /// Optional declaration information that describes where the /// function was declared. This can be NULL. /// - /// @param[in] call_decl_ptr + /// \param[in] call_decl_ptr /// Optional calling location declaration information that /// describes from where this inlined function was called. //------------------------------------------------------------------ @@ -205,18 +205,18 @@ public: /// First compares the FunctionInfo objects, and if equal, compares the /// mangled names. /// - /// @param[in] lhs + /// \param[in] lhs /// The Left Hand Side const InlineFunctionInfo object /// reference. /// - /// @param[in] rhs + /// \param[in] rhs /// The Right Hand Side const InlineFunctionInfo object /// reference. /// - /// @return - /// @li -1 if lhs < rhs - /// @li 0 if lhs == rhs - /// @li 1 if lhs > rhs + /// \return + /// \li -1 if lhs < rhs + /// \li 0 if lhs == rhs + /// \li 1 if lhs > rhs //------------------------------------------------------------------ int Compare(const InlineFunctionInfo &lhs, const InlineFunctionInfo &rhs); @@ -226,7 +226,7 @@ public: /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ void Dump(Stream *s, bool show_fullpaths) const; @@ -240,7 +240,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the call site declaration information. /// - /// @return + /// \return /// A reference to the declaration object. //------------------------------------------------------------------ Declaration &GetCallSite(); @@ -248,7 +248,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for the call site declaration information. /// - /// @return + /// \return /// A const reference to the declaration object. //------------------------------------------------------------------ const Declaration &GetCallSite() const; @@ -256,7 +256,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the mangled name object. /// - /// @return + /// \return /// A reference to the mangled name object. //------------------------------------------------------------------ Mangled &GetMangled(); @@ -264,7 +264,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for the mangled name object. /// - /// @return + /// \return /// A const reference to the mangled name object. //------------------------------------------------------------------ const Mangled &GetMangled() const; @@ -272,12 +272,12 @@ public: //------------------------------------------------------------------ /// Get the memory cost of this object. /// - /// @return + /// \return /// The number of bytes that this object occupies in memory. /// The returned value does not include the bytes for any /// shared string values. /// - /// @see ConstString::StaticMemorySize () + /// \see ConstString::StaticMemorySize () //------------------------------------------------------------------ size_t MemorySize() const override; @@ -293,7 +293,7 @@ private: class Function; //---------------------------------------------------------------------- -/// @class CallEdge Function.h "lldb/Symbol/Function.h" +/// \class CallEdge Function.h "lldb/Symbol/Function.h" /// /// Represent a call made within a Function. This can be used to find a path /// in the call graph between two functions. @@ -349,7 +349,7 @@ private: }; //---------------------------------------------------------------------- -/// @class Function Function.h "lldb/Symbol/Function.h" +/// \class Function Function.h "lldb/Symbol/Function.h" /// A class that describes a function. /// /// Functions belong to CompileUnit objects (Function::m_comp_unit), have @@ -361,8 +361,8 @@ private: /// (Function::m_type), and contains lexical blocks (Function::m_blocks). /// /// The function information is split into a few pieces: -/// @li The concrete instance information -/// @li The abstract information +/// \li The concrete instance information +/// \li The abstract information /// /// The abstract information is found in the function type (Type) that /// describes a function information, return type and parameter types. @@ -376,30 +376,30 @@ public: /// Construct with a compile unit, function UID, function type UID, optional /// mangled name, function type, and a section offset based address range. /// - /// @param[in] comp_unit + /// \param[in] comp_unit /// The compile unit to which this function belongs. /// - /// @param[in] func_uid + /// \param[in] func_uid /// The UID for this function. This value is provided by the /// SymbolFile plug-in and can be any value that allows /// the plug-in to quickly find and parse more detailed /// information when and if more information is needed. /// - /// @param[in] func_type_uid + /// \param[in] func_type_uid /// The type UID for the function Type to allow for lazy type /// parsing from the debug information. /// - /// @param[in] mangled + /// \param[in] mangled /// The optional mangled name for this function. If empty, there /// is no mangled information. /// - /// @param[in] func_type + /// \param[in] func_type /// The optional function type. If NULL, the function type will /// be parsed on demand when accessed using the /// Function::GetType() function by asking the SymbolFile /// plug-in to get the type for \a func_type_uid. /// - /// @param[in] range + /// \param[in] range /// The section offset based address for this function. //------------------------------------------------------------------ Function(CompileUnit *comp_unit, lldb::user_id_t func_uid, @@ -412,9 +412,9 @@ public: ~Function() override; //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) + /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void CalculateSymbolContext(SymbolContext *sc) override; @@ -433,10 +433,10 @@ public: /// line table if that fails. So there may NOT be a line table entry for /// this source file/line combo. /// - /// @param[out] source_file + /// \param[out] source_file /// The source file. /// - /// @param[out] line_no + /// \param[out] line_no /// The line number. //------------------------------------------------------------------ void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no); @@ -446,10 +446,10 @@ public: /// function. /// /// - /// @param[out] source_file + /// \param[out] source_file /// The source file. /// - /// @param[out] line_no + /// \param[out] line_no /// The line number. //------------------------------------------------------------------ void GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no); @@ -469,18 +469,18 @@ public: //------------------------------------------------------------------ /// Get accessor for the block list. /// - /// @return + /// \return /// The block list object that describes all lexical blocks /// in the function. /// - /// @see BlockList + /// \see BlockList //------------------------------------------------------------------ Block &GetBlock(bool can_create); //------------------------------------------------------------------ /// Get accessor for the compile unit that owns this function. /// - /// @return + /// \return /// A compile unit object pointer. //------------------------------------------------------------------ CompileUnit *GetCompileUnit(); @@ -488,7 +488,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for the compile unit that owns this function. /// - /// @return + /// \return /// A const compile unit object pointer. //------------------------------------------------------------------ const CompileUnit *GetCompileUnit() const; @@ -498,7 +498,7 @@ public: //------------------------------------------------------------------ /// Get accessor for the frame base location. /// - /// @return + /// \return /// A location expression that describes the function frame /// base. //------------------------------------------------------------------ @@ -507,7 +507,7 @@ public: //------------------------------------------------------------------ /// Get const accessor for the frame base location. /// - /// @return + /// \return /// A const compile unit object pointer. //------------------------------------------------------------------ const DWARFExpression &GetFrameBaseExpression() const { return m_frame_base; } @@ -523,7 +523,7 @@ public: //------------------------------------------------------------------ /// Get the DeclContext for this function, if available. /// - /// @return + /// \return /// The DeclContext, or NULL if none exists. //------------------------------------------------------------------ CompilerDeclContext GetDeclContext(); @@ -532,7 +532,7 @@ public: /// Get accessor for the type that describes the function return value type, /// and parameter types. /// - /// @return + /// \return /// A type object pointer. //------------------------------------------------------------------ Type *GetType(); @@ -541,7 +541,7 @@ public: /// Get const accessor for the type that describes the function return value /// type, and parameter types. /// - /// @return + /// \return /// A const type object pointer. //------------------------------------------------------------------ const Type *GetType() const; @@ -553,7 +553,7 @@ public: /// "prologue" instructions include any instructions given line number 0 /// immediately following the prologue end. /// - /// @return + /// \return /// The size of the prologue. //------------------------------------------------------------------ uint32_t GetPrologueByteSize(); @@ -564,31 +564,31 @@ public: /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] show_context + /// \param[in] show_context /// If \b true, variables will dump their symbol context /// information. //------------------------------------------------------------------ void Dump(Stream *s, bool show_context) const; //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) + /// \copydoc SymbolContextScope::DumpSymbolContext(Stream*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void DumpSymbolContext(Stream *s) override; //------------------------------------------------------------------ /// Get the memory cost of this object. /// - /// @return + /// \return /// The number of bytes that this object occupies in memory. /// The returned value does not include the bytes for any /// shared string values. /// - /// @see ConstString::StaticMemorySize () + /// \see ConstString::StaticMemorySize () //------------------------------------------------------------------ size_t MemorySize() const; @@ -602,7 +602,7 @@ public: /// would expect them, stepping through the source lines in the function may /// appear strange, etc. /// - /// @return + /// \return /// Returns 'true' if this function was compiled with /// optimization. 'false' indicates that either the optimization /// is unknown, or this function was built without optimization. @@ -620,7 +620,7 @@ public: /// If stopped in a top-level function, LLDB will expose global variables /// as-if locals in the 'frame variable' command /// - /// @return + /// \return /// Returns 'true' if this function is a top-level function, /// 'false' otherwise. //------------------------------------------------------------------ diff --git a/lldb/include/lldb/Symbol/LineEntry.h b/lldb/include/lldb/Symbol/LineEntry.h index 5dd7b076118..591ed5e609f 100644 --- a/lldb/include/lldb/Symbol/LineEntry.h +++ b/lldb/include/lldb/Symbol/LineEntry.h @@ -16,7 +16,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h" +/// \class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h" /// A line table entry class. //---------------------------------------------------------------------- struct LineEntry { @@ -46,30 +46,30 @@ struct LineEntry { /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] comp_unit + /// \param[in] comp_unit /// The compile unit object that contains the support file /// list so the line entry can dump the file name (since this /// object contains a file index into the support file list). /// - /// @param[in] show_file + /// \param[in] show_file /// If \b true, display the filename with the line entry which /// requires that the compile unit object \a comp_unit be a /// valid pointer. /// - /// @param[in] style + /// \param[in] style /// The display style for the section offset address. /// - /// @return + /// \return /// Returns \b true if the address was able to be displayed /// using \a style. File and load addresses may be unresolved /// and it may not be possible to display a valid address value. /// Returns \b false if the address was not able to be properly /// dumped. /// - /// @see Address::DumpStyle + /// \see Address::DumpStyle //------------------------------------------------------------------ bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_range) const; @@ -81,15 +81,15 @@ struct LineEntry { /// Dumps information specific to a process that stops at this line entry to /// the supplied stream \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] comp_unit + /// \param[in] comp_unit /// The compile unit object that contains the support file /// list so the line entry can dump the file name (since this /// object contains a file index into the support file list). /// - /// @return + /// \return /// Returns \b true if the file and line were properly dumped, /// \b false otherwise. //------------------------------------------------------------------ @@ -98,7 +98,7 @@ struct LineEntry { //------------------------------------------------------------------ /// Check if a line entry object is valid. /// - /// @return + /// \return /// Returns \b true if the line entry contains a valid section /// offset address, file index, and line number, \b false /// otherwise. @@ -108,16 +108,16 @@ struct LineEntry { //------------------------------------------------------------------ /// Compare two LineEntry objects. /// - /// @param[in] lhs + /// \param[in] lhs /// The Left Hand Side const LineEntry object reference. /// - /// @param[in] rhs + /// \param[in] rhs /// The Right Hand Side const LineEntry object reference. /// - /// @return - /// @li -1 if lhs < rhs - /// @li 0 if lhs == rhs - /// @li 1 if lhs > rhs + /// \return + /// \li -1 if lhs < rhs + /// \li 0 if lhs == rhs + /// \li 1 if lhs > rhs //------------------------------------------------------------------ static int Compare(const LineEntry &lhs, const LineEntry &rhs); @@ -142,7 +142,7 @@ struct LineEntry { /// range of contiuous LineEntries with line #0 will be included in the /// complete range. /// - /// @return + /// \return /// The contiguous AddressRange for this source line. //------------------------------------------------------------------ AddressRange GetSameLineContiguousAddressRange() const; @@ -150,7 +150,7 @@ struct LineEntry { //------------------------------------------------------------------ /// Apply file mappings from target.source-map to the LineEntry's file. /// - /// @param[in] target_sp + /// \param[in] target_sp /// Shared pointer to the target this LineEntry belongs to. //------------------------------------------------------------------ @@ -185,13 +185,13 @@ struct LineEntry { //------------------------------------------------------------------ /// Less than operator. /// -/// @param[in] lhs +/// \param[in] lhs /// The Left Hand Side const LineEntry object reference. /// -/// @param[in] rhs +/// \param[in] rhs /// The Right Hand Side const LineEntry object reference. /// -/// @return +/// \return /// Returns \b true if lhs < rhs, false otherwise. //------------------------------------------------------------------ bool operator<(const LineEntry &lhs, const LineEntry &rhs); diff --git a/lldb/include/lldb/Symbol/LineTable.h b/lldb/include/lldb/Symbol/LineTable.h index 2b803c172d5..e799e5bd7f6 100644 --- a/lldb/include/lldb/Symbol/LineTable.h +++ b/lldb/include/lldb/Symbol/LineTable.h @@ -19,7 +19,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base +/// \class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base /// class used during symbol table creation. //---------------------------------------------------------------------- class LineSequence { @@ -35,7 +35,7 @@ private: }; //---------------------------------------------------------------------- -/// @class LineTable LineTable.h "lldb/Symbol/LineTable.h" +/// \class LineTable LineTable.h "lldb/Symbol/LineTable.h" /// A line table class. //---------------------------------------------------------------------- class LineTable { @@ -43,7 +43,7 @@ public: //------------------------------------------------------------------ /// Construct with compile unit. /// - /// @param[in] comp_unit + /// \param[in] comp_unit /// The compile unit to which this line table belongs. //------------------------------------------------------------------ LineTable(CompileUnit *comp_unit); @@ -58,11 +58,11 @@ public: /// /// All line entries are maintained in file address order. /// - /// @param[in] line_entry + /// \param[in] line_entry /// A const reference to a new line_entry to add to this line /// table. /// - /// @see Address::DumpStyle + /// \see Address::DumpStyle //------------------------------------------------------------------ // void // AddLineEntry (const LineEntry& line_entry); @@ -91,13 +91,13 @@ public: //------------------------------------------------------------------ /// Dump all line entries in this line table to the stream \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] style + /// \param[in] style /// The display style for the address. /// - /// @see Address::DumpStyle + /// \see Address::DumpStyle //------------------------------------------------------------------ void Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_line_ranges); @@ -107,19 +107,19 @@ public: //------------------------------------------------------------------ /// Find a line entry that contains the section offset address \a so_addr. /// - /// @param[in] so_addr + /// \param[in] so_addr /// A section offset address object containing the address we /// are searching for. /// - /// @param[out] line_entry + /// \param[out] line_entry /// A copy of the line entry that was found if \b true is /// returned, otherwise \a entry is left unmodified. /// - /// @param[out] index_ptr + /// \param[out] index_ptr /// A pointer to a 32 bit integer that will get the actual line /// entry index if it is not nullptr. /// - /// @return + /// \return /// Returns \b true if \a so_addr is contained in a line entry /// in this line table, \b false otherwise. //------------------------------------------------------------------ @@ -134,33 +134,33 @@ public: /// line number \a line starting at the \a start_idx entries into the line /// entry collection. /// - /// @param[in] start_idx + /// \param[in] start_idx /// The number of entries to skip when starting the search. /// - /// @param[out] file_idx + /// \param[out] file_idx /// The file index to search for that should be found prior /// to calling this function using the following functions: /// CompileUnit::GetSupportFiles() /// FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const /// - /// @param[in] line + /// \param[in] line /// The source line to match. /// - /// @param[in] exact + /// \param[in] exact /// If true, match only if you find a line entry exactly matching \a line. /// If false, return the closest line entry greater than \a line. /// - /// @param[out] line_entry + /// \param[out] line_entry /// A reference to a line entry object that will get a copy of /// the line entry if \b true is returned, otherwise \a /// line_entry is left untouched. /// - /// @return + /// \return /// Returns \b true if a matching line entry is found in this /// line table, \b false otherwise. /// - /// @see CompileUnit::GetSupportFiles() - /// @see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const + /// \see CompileUnit::GetSupportFiles() + /// \see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const //------------------------------------------------------------------ uint32_t FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx, uint32_t line, bool exact, @@ -176,22 +176,22 @@ public: //------------------------------------------------------------------ /// Get the line entry from the line table at index \a idx. /// - /// @param[in] idx + /// \param[in] idx /// An index into the line table entry collection. /// - /// @return + /// \return /// A valid line entry if \a idx is a valid index, or an invalid /// line entry if \a idx is not valid. /// - /// @see LineTable::GetSize() - /// @see LineEntry::IsValid() const + /// \see LineTable::GetSize() + /// \see LineEntry::IsValid() const //------------------------------------------------------------------ bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry); //------------------------------------------------------------------ /// Gets the size of the line table in number of line table entries. /// - /// @return + /// \return /// The number of line table entries in this line table. //------------------------------------------------------------------ uint32_t GetSize() const; @@ -202,15 +202,15 @@ public: //------------------------------------------------------------------ /// Gets all contiguous file address ranges for the entire line table. /// - /// @param[out] file_ranges + /// \param[out] file_ranges /// A collection of file address ranges that will be filled in /// by this function. /// - /// @param[out] append + /// \param[out] append /// If \b true, then append to \a file_ranges, otherwise clear /// \a file_ranges prior to adding any ranges. /// - /// @return + /// \return /// The number of address ranges added to \a file_ranges //------------------------------------------------------------------ size_t GetContiguousFileAddressRanges(FileAddressRanges &file_ranges, @@ -220,11 +220,11 @@ public: /// Given a file range link map, relink the current line table and return a /// fixed up line table. /// - /// @param[out] file_range_map + /// \param[out] file_range_map /// A collection of file ranges that maps to new file ranges /// that will be used when linking the line table. /// - /// @return + /// \return /// A new line table if at least one line table entry was able /// to be mapped. //------------------------------------------------------------------ diff --git a/lldb/include/lldb/Symbol/ObjectContainer.h b/lldb/include/lldb/Symbol/ObjectContainer.h index 10215bbe9d6..b85ac4e6dcb 100644 --- a/lldb/include/lldb/Symbol/ObjectContainer.h +++ b/lldb/include/lldb/Symbol/ObjectContainer.h @@ -19,7 +19,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h" +/// \class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h" /// A plug-in interface definition class for object containers. /// /// Object containers contain object files from one or more architectures, and @@ -65,7 +65,7 @@ public: /// supplied stream \a s. The dumping should include the section list if it /// has been parsed, and the symbol table if it has been parsed. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ virtual void Dump(Stream *s) const = 0; @@ -75,18 +75,18 @@ public: /// /// Copies the architecture specification for index \a idx. /// - /// @param[in] idx + /// \param[in] idx /// The architecture index to extract. /// - /// @param[out] arch + /// \param[out] arch /// A architecture object that will be filled in if \a idx is a /// architecture valid index. /// - /// @return + /// \return /// Returns \b true if \a idx is valid and \a arch has been /// filled in, \b false otherwise. /// - /// @see ObjectContainer::GetNumArchitectures() const + /// \see ObjectContainer::GetNumArchitectures() const //------------------------------------------------------------------ virtual bool GetArchitectureAtIndex(uint32_t idx, ArchSpec &arch) const { return false; @@ -98,7 +98,7 @@ public: /// Some files contain many object files, and this function allows access to /// an object's offset within the file. /// - /// @return + /// \return /// The offset in bytes into the file. Defaults to zero for /// simple object files that a represented by an entire file. //------------------------------------------------------------------ @@ -109,7 +109,7 @@ public: //------------------------------------------------------------------ /// Get the number of objects within this object file (archives). /// - /// @return + /// \return /// Zero for object files that are not archives, or the number /// of objects contained in the archive. //------------------------------------------------------------------ @@ -123,7 +123,7 @@ public: /// one architecture should override this function and return an appropriate /// value. /// - /// @return + /// \return /// The number of architectures contained in this object file. //------------------------------------------------------------------ virtual size_t GetNumArchitectures() const { return 0; } @@ -137,7 +137,7 @@ public: /// false should be returned and the next plug-in can attempt to parse an /// object file. /// - /// @return + /// \return /// Returns \b true if the header was parsed successfully, \b /// false otherwise. //------------------------------------------------------------------ @@ -155,7 +155,7 @@ public: /// state from any previously selected architecture and prepare to return /// information for the new architecture. /// - /// @return + /// \return /// Returns a pointer to the object file of the requested \a /// arch and optional \a name. Returns nullptr of no such object /// file exists in the container. diff --git a/lldb/include/lldb/Symbol/ObjectFile.h b/lldb/include/lldb/Symbol/ObjectFile.h index 10feae761f4..8a29e87aaa6 100644 --- a/lldb/include/lldb/Symbol/ObjectFile.h +++ b/lldb/include/lldb/Symbol/ObjectFile.h @@ -43,7 +43,7 @@ public: }; //---------------------------------------------------------------------- -/// @class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h" +/// \class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h" /// A plug-in interface definition class for object file parsers. /// /// Object files belong to Module objects and know how to extract information @@ -121,7 +121,7 @@ public: /// supplied stream \a s. The dumping should include the section list if it /// has been parsed, and the symbol table if it has been parsed. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ virtual void Dump(Stream *s) = 0; @@ -133,23 +133,23 @@ public: /// ObjectFile plug-in interface and returns the first instance that can /// parse the file. /// - /// @param[in] module + /// \param[in] module /// The parent module that owns this object file. /// - /// @param[in] file_spec + /// \param[in] file_spec /// A file specification that indicates which file to use as the /// object file. /// - /// @param[in] file_offset + /// \param[in] file_offset /// The offset into the file at which to start parsing the /// object. This is for files that contain multiple /// architectures or objects. /// - /// @param[in] file_size + /// \param[in] file_size /// The size of the current object file if it can be determined /// or if it is known. This can be zero. /// - /// @see ObjectFile::ParseHeader() + /// \see ObjectFile::ParseHeader() //------------------------------------------------------------------ static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file_spec, @@ -163,14 +163,14 @@ public: /// ObjectFile plug-in interface and returns the first instance that can /// parse the file. /// - /// @param[in] module + /// \param[in] module /// The parent module that owns this object file. /// - /// @param[in] process_sp + /// \param[in] process_sp /// A shared pointer to the process whose memory space contains /// an object file. This will be stored as a std::weak_ptr. /// - /// @param[in] header_addr + /// \param[in] header_addr /// The address of the header for the object file in memory. //------------------------------------------------------------------ static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp, @@ -196,19 +196,19 @@ public: /// the actual path name and into the object name so we can make a valid /// object file from it. /// - /// @param[in] path_with_object + /// \param[in] path_with_object /// A path that might contain an archive path with a .o file /// specified in parens in the basename of the path. /// - /// @param[out] archive_file + /// \param[out] archive_file /// If \b true is returned, \a file_spec will be filled in with /// the path to the archive. /// - /// @param[out] archive_object + /// \param[out] archive_object /// If \b true is returned, \a object will be filled in with /// the name of the object inside the archive. /// - /// @return + /// \return /// \b true if the path matches the pattern of archive + object /// and \a archive_file and \a archive_object are modified, /// \b false otherwise and \a archive_file and \a archive_object @@ -221,7 +221,7 @@ public: //------------------------------------------------------------------ /// Gets the address size in bytes for the current object file. /// - /// @return + /// \return /// The size of an address in bytes for the currently selected /// architecture (and object for archives). Returns zero if no /// architecture or object has been selected. @@ -235,7 +235,7 @@ public: /// binaries, though it can be applied to any executable file format that /// supports different opcode types within the same binary. ARM binaries /// support having both ARM and Thumb within the same executable container. - /// We need to be able to get @return + /// We need to be able to get \return /// The size of an address in bytes for the currently selected /// architecture (and object for archives). Returns zero if no /// architecture or object has been selected. @@ -251,14 +251,14 @@ public: /// FileSpecList::AppendIfUnique(const FileSpec &) should be used to make /// sure any files that are added are not already in the list. /// - /// @param[out] file_list + /// \param[out] file_list /// A list of file specification objects that gets dependent /// files appended to. /// - /// @return + /// \return /// The number of new files that were appended to \a file_list. /// - /// @see FileSpecList::AppendIfUnique(const FileSpec &) + /// \see FileSpecList::AppendIfUnique(const FileSpec &) //------------------------------------------------------------------ virtual uint32_t GetDependentModules(FileSpecList &file_list) = 0; @@ -266,7 +266,7 @@ public: /// Tells whether this object file is capable of being the main executable /// for a process. /// - /// @return + /// \return /// \b true if it is, \b false otherwise. //------------------------------------------------------------------ virtual bool IsExecutable() const = 0; @@ -277,7 +277,7 @@ public: /// Some files contain many object files, and this function allows access to /// an object's offset within the file. /// - /// @return + /// \return /// The offset in bytes into the file. Defaults to zero for /// simple object files that a represented by an entire file. //------------------------------------------------------------------ @@ -288,7 +288,7 @@ public: //------------------------------------------------------------------ /// Get accessor to the object file specification. /// - /// @return + /// \return /// The file specification object pointer if there is one, or /// NULL if this object is only from memory. //------------------------------------------------------------------ @@ -297,7 +297,7 @@ public: //------------------------------------------------------------------ /// Get const accessor to the object file specification. /// - /// @return + /// \return /// The const file specification object pointer if there is one, /// or NULL if this object is only from memory. //------------------------------------------------------------------ @@ -306,7 +306,7 @@ public: //------------------------------------------------------------------ /// Get the ArchSpec for this object file. /// - /// @return + /// \return /// The ArchSpec of this object file. In case of error, an invalid /// ArchSpec object is returned. //------------------------------------------------------------------ @@ -319,7 +319,7 @@ public: /// Section list parsing can be deferred by ObjectFile instances until this /// accessor is called the first time. /// - /// @return + /// \return /// The list of sections contained in this object file. //------------------------------------------------------------------ virtual SectionList *GetSectionList(bool update_module_section_list = true); @@ -339,7 +339,7 @@ public: /// Symbol table parsing can be deferred by ObjectFile instances until this /// accessor is called the first time. /// - /// @return + /// \return /// The symbol table for this object file. //------------------------------------------------------------------ virtual Symtab *GetSymtab() = 0; @@ -359,7 +359,7 @@ public: /// the first match in the SymbolTable and appends a Symbol only if /// required/found. /// - /// @return + /// \return /// The resolved symbol or nullptr. Returns nullptr if a /// a Symbol could not be found for the specified so_addr. //------------------------------------------------------------------ @@ -380,7 +380,7 @@ public: //------------------------------------------------------------------ /// Detect if this object file has been stripped of local symbols. /// - /// @return + /// \return /// Return \b true if the object file has been stripped of local /// symbols. //------------------------------------------------------------------ @@ -391,11 +391,11 @@ public: /// /// This function should only be used when an object file is /// - /// @param[in] flags + /// \param[in] flags /// eSymtabFromUnifiedSectionList: Whether to clear symbol table /// for unified module section list, or object file. /// - /// @return + /// \return /// The symbol table for this object file. //------------------------------------------------------------------ virtual void ClearSymtab(); @@ -407,7 +407,7 @@ public: /// Else ObjectFile instances should return the MD5 checksum of all of the /// bytes for the object file (or memory for memory based object files). /// - /// @return + /// \return /// The object file's UUID. In case of an error, an empty UUID is /// returned. //------------------------------------------------------------------ @@ -419,7 +419,7 @@ public: /// If the object file format contains a debug symbol file link, the values /// will be returned in the FileSpecList. /// - /// @return + /// \return /// Returns filespeclist. //------------------------------------------------------------------ virtual lldb_private::FileSpecList GetDebugSymbolFilePaths() { @@ -433,7 +433,7 @@ public: /// symbols from another, the re-exported libraries will be returned in the /// FileSpecList. /// - /// @return + /// \return /// Returns filespeclist. //------------------------------------------------------------------ virtual lldb_private::FileSpecList GetReExportedLibraries() { @@ -444,7 +444,7 @@ public: /// Sets the load address for an entire module, assuming a rigid slide of /// sections, if possible in the implementation. /// - /// @return + /// \return /// Returns true iff any section's load address changed. //------------------------------------------------------------------ virtual bool SetLoadAddress(Target &target, lldb::addr_t value, @@ -456,7 +456,7 @@ public: /// Gets whether endian swapping should occur when extracting data from this /// object file. /// - /// @return + /// \return /// Returns \b true if endian swapping is needed, \b false /// otherwise. //------------------------------------------------------------------ @@ -471,7 +471,7 @@ public: /// false should be returned and the next plug-in can attempt to parse an /// object file. /// - /// @return + /// \return /// Returns \b true if the header was parsed successfully, \b /// false otherwise. //------------------------------------------------------------------ @@ -494,7 +494,7 @@ public: /// that symbol start addresses are unavailable before false is returned. /// If it is unclear, this should return true. /// - /// @return + /// \return /// Returns true if assembly emulation should be used for this /// module. /// Only returns false if the ObjectFile is sure that symbol @@ -512,7 +512,7 @@ public: /// runtime linker so that a debugger may monitor the loading and unloading /// of shared libraries. /// - /// @return + /// \return /// The address of any auxiliary tables, or an invalid address if this /// object file format does not support or contain such information. virtual lldb_private::Address GetImageInfoAddress(Target *target) { @@ -524,7 +524,7 @@ public: /// object file doesn't have an entry point (because it is not an executable /// file) then an invalid address is returned. /// - /// @return + /// \return /// Returns the entry address for this module. //------------------------------------------------------------------ virtual lldb_private::Address GetEntryPointAddress() { return Address(); } @@ -550,7 +550,7 @@ public: /// in a Mach-O core file using the LC_IDENT load command (which is /// obsolete, but can still be found in some old files) /// - /// @return + /// \return /// Returns the identifier string if one exists, else an empty /// string. //------------------------------------------------------------------ @@ -565,17 +565,17 @@ public: /// binary is exactly which removes ambiguity when there are multiple /// binaries present in the captured memory pages. /// - /// @param[out] address + /// \param[out] address /// If the address of the binary is specified, this will be set. /// This is an address is the virtual address space of the core file /// memory segments; it is not an offset into the object file. /// If no address is available, will be set to LLDB_INVALID_ADDRESS. /// - /// @param[out] uuid + /// \param[out] uuid /// If the uuid of the binary is specified, this will be set. /// If no UUID is available, will be cleared. /// - /// @return + /// \return /// Returns true if either address or uuid has been set. //------------------------------------------------------------------ virtual bool GetCorefileMainBinaryInfo (lldb::addr_t &address, UUID &uuid) { @@ -597,7 +597,7 @@ public: /// eTypeXXX definitions do not match up with the type of file you are /// loading, please feel free to add a new enumeration value. /// - /// @return + /// \return /// The calculated file type for the current object file. //------------------------------------------------------------------ virtual Type CalculateType() = 0; @@ -617,7 +617,7 @@ public: /// out, it will help with debugger plug-in selection when it comes time to /// debug. /// - /// @return + /// \return /// The calculated object file strata for the current object /// file. //------------------------------------------------------------------ @@ -631,7 +631,7 @@ public: /// minor and build, but there may be more. This function will extract the /// versions from object files if they are available. /// - /// @return + /// \return /// This function returns extracted version numbers as a /// llvm::VersionTuple. In case of error an empty VersionTuple is /// returned. @@ -644,7 +644,7 @@ public: /// Some object files have information that specifies the minimum OS version /// that they can be used on. /// - /// @return + /// \return /// This function returns extracted version numbers as a /// llvm::VersionTuple. In case of error an empty VersionTuple is /// returned. @@ -739,10 +739,10 @@ public: /// useful with bare-metal targets where target does not have the ability to /// start a process itself. /// - /// @param[in] target + /// \param[in] target /// Target where to load. /// - /// @return + /// \return //------------------------------------------------------------------ virtual std::vector<LoadableData> GetLoadableData(Target &target); @@ -771,10 +771,10 @@ protected: /// only be set if it is invalid. It is not allowed to switch from one /// concrete architecture to another. /// - /// @param[in] new_arch + /// \param[in] new_arch /// The architecture this module will be set to. /// - /// @return + /// \return /// Returns \b true if the architecture was changed, \b /// false otherwise. //------------------------------------------------------------------ diff --git a/lldb/include/lldb/Symbol/Symbol.h b/lldb/include/lldb/Symbol/Symbol.h index 11a9a1eb004..1efbc35ad2b 100644 --- a/lldb/include/lldb/Symbol/Symbol.h +++ b/lldb/include/lldb/Symbol/Symbol.h @@ -204,9 +204,9 @@ public: m_contains_linker_annotations = b; } //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) + /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void CalculateSymbolContext(SymbolContext *sc) override; @@ -215,9 +215,9 @@ public: Symbol *CalculateSymbolContextSymbol() override; //------------------------------------------------------------------ - /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*) + /// \copydoc SymbolContextScope::DumpSymbolContext(Stream*) /// - /// @see SymbolContextScope + /// \see SymbolContextScope //------------------------------------------------------------------ void DumpSymbolContext(Stream *s) override; diff --git a/lldb/include/lldb/Symbol/SymbolContext.h b/lldb/include/lldb/Symbol/SymbolContext.h index a8fa9df79bd..5298f5e104c 100644 --- a/lldb/include/lldb/Symbol/SymbolContext.h +++ b/lldb/include/lldb/Symbol/SymbolContext.h @@ -24,13 +24,13 @@ namespace lldb_private { class SymbolContextScope; //---------------------------------------------------------------------- -/// @class SymbolContext SymbolContext.h "lldb/Symbol/SymbolContext.h" Defines +/// \class SymbolContext SymbolContext.h "lldb/Symbol/SymbolContext.h" Defines /// a symbol context baton that can be handed other debug core functions. /// /// Many debugger functions require a context when doing lookups. This class /// provides a common structure that can be used as the result of a query that /// can contain a single result. Examples of such queries include -/// @li Looking up a load address. +/// \li Looking up a load address. //---------------------------------------------------------------------- class SymbolContext { public: @@ -46,7 +46,7 @@ public: /// Construct with an object that knows how to reconstruct its symbol /// context. /// - /// @param[in] sc_scope + /// \param[in] sc_scope /// A symbol context scope object that knows how to reconstruct /// it's context. //------------------------------------------------------------------ @@ -58,22 +58,22 @@ public: /// /// Initialize all pointer to the specified values. /// - /// @param[in] module + /// \param[in] module /// A Module pointer to the module for this context. /// - /// @param[in] comp_unit + /// \param[in] comp_unit /// A CompileUnit pointer to the compile unit for this context. /// - /// @param[in] function + /// \param[in] function /// A Function pointer to the function for this context. /// - /// @param[in] block + /// \param[in] block /// A Block pointer to the deepest block for this context. /// - /// @param[in] line_entry + /// \param[in] line_entry /// A LineEntry pointer to the line entry for this context. /// - /// @param[in] symbol + /// \param[in] symbol /// A Symbol pointer to the symbol for this context. //------------------------------------------------------------------ explicit SymbolContext(const lldb::TargetSP &target_sp, @@ -95,7 +95,7 @@ public: /// /// Makes a copy of the another SymbolContext object \a rhs. /// - /// @param[in] rhs + /// \param[in] rhs /// A const SymbolContext object reference to copy. //------------------------------------------------------------------ SymbolContext(const SymbolContext &rhs); @@ -108,10 +108,10 @@ public: /// Copies the address value from another SymbolContext object \a rhs into /// \a this object. /// - /// @param[in] rhs + /// \param[in] rhs /// A const SymbolContext object reference to copy. /// - /// @return + /// \return /// A const SymbolContext object reference to \a this. //------------------------------------------------------------------ const SymbolContext &operator=(const SymbolContext &rhs); @@ -130,7 +130,7 @@ public: /// Dump a description of the contents of this object to the supplied stream /// \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ void Dump(Stream *s, Target *target) const; @@ -145,33 +145,33 @@ public: /// is available, that will be output. Else just the address at which the /// target was stopped will be displayed. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. /// - /// @param[in] so_addr + /// \param[in] so_addr /// The resolved section offset address. /// - /// @param[in] show_fullpaths + /// \param[in] show_fullpaths /// When printing file paths (with the Module), whether the /// base name of the Module should be printed or the full path. /// - /// @param[in] show_module + /// \param[in] show_module /// Whether the module name should be printed followed by a /// grave accent "`" character. /// - /// @param[in] show_inlined_frames + /// \param[in] show_inlined_frames /// If a given pc is in inlined function(s), whether the inlined /// functions should be printed on separate lines in addition to /// the concrete function containing the pc. /// - /// @param[in] show_function_arguments + /// \param[in] show_function_arguments /// If false, this method will try to elide the function argument /// types when printing the function name. This may be ambiguous /// for languages that have function overloading - but it may /// make the "function name" too long to include all the argument /// types. /// - /// @param[in] show_function_name + /// \param[in] show_function_name /// Normally this should be true - the function/symbol name should /// be printed. In disassembly formatting, where we want a format /// like "<*+36>", this should be false and "*" will be printed @@ -196,17 +196,17 @@ public: /// - symbol address range if symbol is not nullptr and /// eSymbolContextSymbol is set in \a scope /// - /// @param[in] scope + /// \param[in] scope /// A mask of symbol context bits telling this function which /// address ranges it can use when trying to extract one from /// the valid (non-nullptr) symbol context classes. /// - /// @param[in] range_idx + /// \param[in] range_idx /// The address range index to grab. Since many functions and /// blocks are not always contiguous, they may have more than /// one address range. /// - /// @param[in] use_inline_block_range + /// \param[in] use_inline_block_range /// If \a scope has the eSymbolContextBlock bit set, and there /// is a valid block in the symbol context, return the block /// address range for the containing inline function block, not @@ -214,11 +214,11 @@ public: /// for the address range of the inlined function block, not /// the deepest lexical block. /// - /// @param[out] range + /// \param[out] range /// An address range object that will be filled in if \b true /// is returned. /// - /// @return + /// \return /// \b True if this symbol context contains items that describe /// an address range, \b false otherwise. //------------------------------------------------------------------ @@ -238,15 +238,15 @@ public: /// - non-extern symbol in the target /// It is an error if the highest-priority result is ambiguous. /// - /// @param[in] name + /// \param[in] name /// The name of the symbol to search for. /// - /// @param[out] error + /// \param[out] error /// An error that will be populated with a message if there was an /// ambiguous result. The error will not be populated if no result /// was found. /// - /// @return + /// \return /// The symbol that was found, or \b nullptr if none was found. //------------------------------------------------------------------ const Symbol *FindBestGlobalDataSymbol(ConstString name, Status &error); @@ -275,7 +275,7 @@ public: /// represented by this symbol context (whether the function is an inline /// function or not). /// - /// @return + /// \return /// The block object pointer that defines the function that is /// represented by this symbol context object, nullptr otherwise. //------------------------------------------------------------------ @@ -285,18 +285,18 @@ public: /// If this symbol context represents a function that is a method, return /// true and provide information about the method. /// - /// @param[out] language + /// \param[out] language /// If \b true is returned, the language for the method. /// - /// @param[out] is_instance_method + /// \param[out] is_instance_method /// If \b true is returned, \b true if this is a instance method, /// \b false if this is a static/class function. /// - /// @param[out] language_object_name + /// \param[out] language_object_name /// If \b true is returned, the name of the artificial variable /// for the language ("this" for C++, "self" for ObjC). /// - /// @return + /// \return /// \b True if this symbol context represents a function that /// is a method of a class, \b false otherwise. //------------------------------------------------------------------ @@ -316,12 +316,12 @@ public: /// For instance, if the symbol context contains an inlined block, it will /// return the inlined function name. /// - /// @param[in] prefer_mangled + /// \param[in] prefer_mangled /// if \btrue, then the mangled name will be returned if there /// is one. Otherwise the unmangled name will be returned if it /// is available. /// - /// @return + /// \return /// The name of the function represented by this symbol context. //------------------------------------------------------------------ ConstString GetFunctionName( @@ -338,12 +338,12 @@ public: /// table information for the symbol context. it will return the inlined /// function name. /// - /// @param[in] prefer_mangled + /// \param[in] prefer_mangled /// if \btrue, then the mangled name will be returned if there /// is one. Otherwise the unmangled name will be returned if it /// is available. /// - /// @return + /// \return /// The name of the function represented by this symbol context. //------------------------------------------------------------------ LineEntry GetFunctionStartLineEntry() const; @@ -354,16 +354,16 @@ public: /// For instance, if the symbol context contains an inlined block, it will /// return the inlined function name. /// - /// @param[in] curr_frame_pc + /// \param[in] curr_frame_pc /// The address within the block of this object. /// - /// @param[out] next_frame_sc + /// \param[out] next_frame_sc /// A new symbol context that does what the title says it does. /// - /// @param[out] next_frame_addr + /// \param[out] next_frame_addr /// This is what you should report as the PC in \a next_frame_sc. /// - /// @return + /// \return /// \b true if this SymbolContext specifies a block contained in an /// inlined block. If this returns \b true, \a next_frame_sc and /// \a next_frame_addr will be filled in correctly. @@ -429,14 +429,14 @@ private: }; //---------------------------------------------------------------------- -/// @class SymbolContextList SymbolContext.h "lldb/Symbol/SymbolContext.h" +/// \class SymbolContextList SymbolContext.h "lldb/Symbol/SymbolContext.h" /// 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 of such /// queries include: -/// @li Looking up a function by name. -/// @li Finding all addresses for a specified file and line number. +/// \li Looking up a function by name. +/// \li Finding all addresses for a specified file and line number. //---------------------------------------------------------------------- class SymbolContextList { public: @@ -455,7 +455,7 @@ public: //------------------------------------------------------------------ /// Append a new symbol context to the list. /// - /// @param[in] sc + /// \param[in] sc /// A symbol context to append to the list. //------------------------------------------------------------------ void Append(const SymbolContext &sc); @@ -480,7 +480,7 @@ public: /// Dump a description of the contents of each symbol context in the list to /// the supplied stream \a s. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object description. //------------------------------------------------------------------ void Dump(Stream *s, Target *target) const; @@ -491,13 +491,13 @@ public: /// Dump a description of the contents of each symbol context in the list to /// the supplied stream \a s. /// - /// @param[in] idx + /// \param[in] idx /// The zero based index into the symbol context list. /// - /// @param[out] sc + /// \param[out] sc /// A reference to the symbol context to fill in. /// - /// @return + /// \return /// Returns \b true if \a idx was a valid index into this /// symbol context list and \a sc was filled in, \b false /// otherwise. @@ -510,10 +510,10 @@ public: /// The index \a idx must be a valid index, no error checking will be done /// to ensure that it is valid. /// - /// @param[in] idx + /// \param[in] idx /// The zero based index into the symbol context list. /// - /// @return + /// \return /// A const reference to the symbol context to fill in. //------------------------------------------------------------------ SymbolContext &operator[](size_t idx) { return m_symbol_contexts[idx]; } @@ -527,7 +527,7 @@ public: //------------------------------------------------------------------ /// Get accessor for a symbol context list size. /// - /// @return + /// \return /// Returns the number of symbol context objects in the list. //------------------------------------------------------------------ uint32_t GetSize() const; diff --git a/lldb/include/lldb/Symbol/SymbolContextScope.h b/lldb/include/lldb/Symbol/SymbolContextScope.h index bb36339025a..afb2174de6c 100644 --- a/lldb/include/lldb/Symbol/SymbolContextScope.h +++ b/lldb/include/lldb/Symbol/SymbolContextScope.h @@ -14,7 +14,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class SymbolContextScope SymbolContextScope.h +/// \class SymbolContextScope SymbolContextScope.h /// "lldb/Symbol/SymbolContextScope.h" Inherit from this if your object is /// part of a symbol context /// and can reconstruct its symbol context. @@ -26,11 +26,11 @@ namespace lldb_private { /// complete SymbolContext object in the object. /// /// Examples of these objects include: -/// @li Module -/// @li CompileUnit -/// @li Function -/// @li Block -/// @li Symbol +/// \li Module +/// \li CompileUnit +/// \li Function +/// \li Block +/// \li Symbol /// /// Other objects can store a "SymbolContextScope *" using any pointers to one /// of the above objects. This allows clients to hold onto a pointer that @@ -40,7 +40,7 @@ namespace lldb_private { /// /// Example objects include that currently use "SymbolContextScope *" objects /// include: -/// @li Variable objects that can reconstruct where they are scoped +/// \li Variable objects that can reconstruct where they are scoped /// by making sure the SymbolContextScope * comes from the scope /// in which the variable was declared. If a variable is a global, /// the appropriate CompileUnit * will be used when creating the @@ -48,9 +48,9 @@ namespace lldb_private { /// in which the variable is defined. Function arguments can use /// the Function object as their scope. The SymbolFile parsers /// will set these correctly as the variables are parsed. -/// @li Type objects that know exactly in which scope they +/// \li Type objects that know exactly in which scope they /// originated much like the variables above. -/// @li StackID objects that are able to know that if the CFA +/// \li StackID objects that are able to know that if the CFA /// (stack pointer at the beginning of a function) and the /// start PC for the function/symbol and the SymbolContextScope /// pointer (a unique pointer that identifies a symbol context @@ -74,7 +74,7 @@ public: /// function calls that require a symbol context can be made for the given /// object. /// - /// @param[out] sc + /// \param[out] sc /// A symbol context object pointer that gets filled in. //------------------------------------------------------------------ virtual void CalculateSymbolContext(SymbolContext *sc) = 0; @@ -98,7 +98,7 @@ public: /// function is widely used in the DumpDebug and verbose output for lldb /// objects. /// - /// @param[in] s + /// \param[in] s /// The stream to which to dump the object's symbol context. //------------------------------------------------------------------ virtual void DumpSymbolContext(Stream *s) = 0; diff --git a/lldb/include/lldb/Symbol/SymbolFile.h b/lldb/include/lldb/Symbol/SymbolFile.h index 01943bea7b1..04d95e20ca3 100644 --- a/lldb/include/lldb/Symbol/SymbolFile.h +++ b/lldb/include/lldb/Symbol/SymbolFile.h @@ -85,7 +85,7 @@ public: /// for "void SymbolFile::InitializeObject()" which will get called /// on the SymbolFile object with the best set of abilities. /// - /// @return + /// \return /// A uint32_t mask containing bits from the SymbolFile::Abilities /// enumeration. Any bits that are set represent an ability that /// this symbol plug-in can parse from the object file. |
