diff options
Diffstat (limited to 'lldb/source')
59 files changed, 591 insertions, 591 deletions
diff --git a/lldb/source/Expression/IRDynamicChecks.cpp b/lldb/source/Expression/IRDynamicChecks.cpp index 854aca335d2..354df5af829 100644 --- a/lldb/source/Expression/IRDynamicChecks.cpp +++ b/lldb/source/Expression/IRDynamicChecks.cpp @@ -103,7 +103,7 @@ static std::string PrintValue(llvm::Value *V, bool truncate = false) { } //---------------------------------------------------------------------- -/// @class Instrumenter IRDynamicChecks.cpp +/// \class Instrumenter IRDynamicChecks.cpp /// Finds and instruments individual LLVM IR instructions /// /// When instrumenting LLVM IR, it is frequently desirable to first search for @@ -135,7 +135,7 @@ public: //------------------------------------------------------------------ /// Constructor /// - /// @param[in] module + /// \param[in] module /// The module being instrumented. //------------------------------------------------------------------ Instrumenter(llvm::Module &module, DynamicCheckerFunctions &checker_functions) @@ -147,10 +147,10 @@ public: //------------------------------------------------------------------ /// Inspect a function to find instructions to instrument /// - /// @param[in] function + /// \param[in] function /// The function to inspect. /// - /// @return + /// \return /// True on success; false on error. //------------------------------------------------------------------ bool Inspect(llvm::Function &function) { return InspectFunction(function); } @@ -158,7 +158,7 @@ public: //------------------------------------------------------------------ /// Instrument all the instructions found by Inspect() /// - /// @return + /// \return /// True on success; false on error. //------------------------------------------------------------------ bool Instrument() { @@ -176,10 +176,10 @@ protected: //------------------------------------------------------------------ /// Add instrumentation to a single instruction /// - /// @param[in] inst + /// \param[in] inst /// The instruction to be instrumented. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ virtual bool InstrumentInstruction(llvm::Instruction *inst) = 0; @@ -187,7 +187,7 @@ protected: //------------------------------------------------------------------ /// Register a single instruction to be instrumented /// - /// @param[in] inst + /// \param[in] inst /// The instruction to be instrumented. //------------------------------------------------------------------ void RegisterInstruction(llvm::Instruction &i) { @@ -198,10 +198,10 @@ protected: /// Determine whether a single instruction is interesting to instrument, /// and, if so, call RegisterInstruction /// - /// @param[in] i + /// \param[in] i /// The instruction to be inspected. /// - /// @return + /// \return /// False if there was an error scanning; true otherwise. //------------------------------------------------------------------ virtual bool InspectInstruction(llvm::Instruction &i) { return true; } @@ -209,10 +209,10 @@ protected: //------------------------------------------------------------------ /// Scan a basic block to see if any instructions are interesting /// - /// @param[in] bb + /// \param[in] bb /// The basic block to be inspected. /// - /// @return + /// \return /// False if there was an error scanning; true otherwise. //------------------------------------------------------------------ virtual bool InspectBasicBlock(llvm::BasicBlock &bb) { @@ -228,10 +228,10 @@ protected: //------------------------------------------------------------------ /// Scan a function to see if any instructions are interesting /// - /// @param[in] f + /// \param[in] f /// The function to be inspected. /// - /// @return + /// \return /// False if there was an error scanning; true otherwise. //------------------------------------------------------------------ virtual bool InspectFunction(llvm::Function &f) { @@ -248,10 +248,10 @@ protected: /// Build a function pointer for a function with signature void /// (*)(uint8_t*) with a given address /// - /// @param[in] start_address + /// \param[in] start_address /// The address of the function. /// - /// @return + /// \return /// The function pointer, for use in a CallInst. //------------------------------------------------------------------ llvm::FunctionCallee BuildPointerValidatorFunc(lldb::addr_t start_address) { @@ -273,10 +273,10 @@ protected: /// Build a function pointer for a function with signature void /// (*)(uint8_t*, uint8_t*) with a given address /// - /// @param[in] start_address + /// \param[in] start_address /// The address of the function. /// - /// @return + /// \return /// The function pointer, for use in a CallInst. //------------------------------------------------------------------ llvm::FunctionCallee BuildObjectCheckerFunc(lldb::addr_t start_address) { diff --git a/lldb/source/Expression/UtilityFunction.cpp b/lldb/source/Expression/UtilityFunction.cpp index 8cf9de966c4..550697e4850 100644 --- a/lldb/source/Expression/UtilityFunction.cpp +++ b/lldb/source/Expression/UtilityFunction.cpp @@ -32,10 +32,10 @@ using namespace lldb; //------------------------------------------------------------------ /// Constructor /// -/// @param[in] text +/// \param[in] text /// The text of the function. Must be a full translation unit. /// -/// @param[in] name +/// \param[in] name /// The name of the function, as used in the text. //------------------------------------------------------------------ UtilityFunction::UtilityFunction(ExecutionContextScope &exe_scope, diff --git a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp index a96c795e450..e6deab8cd27 100644 --- a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp +++ b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp @@ -243,9 +243,9 @@ void DynamicLoaderHexagonDYLD::UpdateLoadedSections(ModuleSP module, } } -/// Removes the loaded sections from the target in @p module. +/// Removes the loaded sections from the target in \p module. /// -/// @param module The module to traverse. +/// \param module The module to traverse. void DynamicLoaderHexagonDYLD::UnloadSections(const ModuleSP module) { Target &target = m_process->GetTarget(); const SectionList *sections = GetSectionListFromModule(module); diff --git a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h index 3fa9a47ce6b..b9b0a93e495 100644 --- a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h +++ b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h @@ -86,21 +86,21 @@ protected: /// of loaded modules. void RefreshModules(); - /// Updates the load address of every allocatable section in @p module. + /// Updates the load address of every allocatable section in \p module. /// - /// @param module The module to traverse. + /// \param module The module to traverse. /// - /// @param link_map_addr The virtual address of the link map for the @p + /// \param link_map_addr The virtual address of the link map for the @p /// module. /// - /// @param base_addr The virtual base address @p module is loaded at. + /// \param base_addr The virtual base address \p module is loaded at. void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr, lldb::addr_t base_addr, bool base_addr_is_offset) override; - /// Removes the loaded sections from the target in @p module. + /// Removes the loaded sections from the target in \p module. /// - /// @param module The module to traverse. + /// \param module The module to traverse. void UnloadSections(const lldb::ModuleSP module) override; /// Callback routine invoked when we hit the breakpoint on process entry. diff --git a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h index aa1e5c10b8e..70fc12b7fab 100644 --- a/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h +++ b/lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h @@ -21,7 +21,7 @@ namespace lldb_private { class Process; } -/// @class HexagonDYLDRendezvous +/// \class HexagonDYLDRendezvous /// Interface to the runtime linker. /// /// A structure is present in a processes memory space which is updated by the @@ -65,36 +65,36 @@ public: /// This method should be called once one start up, then once each time the /// runtime linker enters the function given by GetBreakAddress(). /// - /// @returns true on success and false on failure. + /// \returns true on success and false on failure. /// - /// @see GetBreakAddress(). + /// \see GetBreakAddress(). bool Resolve(); - /// @returns true if this rendezvous has been located in the inferiors + /// \returns true if this rendezvous has been located in the inferiors /// address space and false otherwise. bool IsValid(); - /// @returns the address of the rendezvous structure in the inferiors + /// \returns the address of the rendezvous structure in the inferiors /// address space. lldb::addr_t GetRendezvousAddress() const { return m_rendezvous_addr; } /// Provide the dyld structure address void SetRendezvousAddress(lldb::addr_t); - /// @returns the version of the rendezvous protocol being used. + /// \returns the version of the rendezvous protocol being used. uint64_t GetVersion() const { return m_current.version; } - /// @returns address in the inferiors address space containing the linked + /// \returns address in the inferiors address space containing the linked /// list of shared object descriptors. lldb::addr_t GetLinkMapAddress() const { return m_current.map_addr; } /// A breakpoint should be set at this address and Resolve called on each /// hit. /// - /// @returns the address of a function called by the runtime linker each + /// \returns the address of a function called by the runtime linker each /// time a module is loaded/unloaded, or about to be loaded/unloaded. /// - /// @see Resolve() + /// \see Resolve() lldb::addr_t GetBreakAddress() const { return m_current.brk; } /// In hexagon it is possible that we can know the dyld breakpoint without @@ -105,18 +105,18 @@ public: /// Returns the current state of the rendezvous structure. uint64_t GetState() const { return m_current.state; } - /// @returns the base address of the runtime linker in the inferiors address + /// \returns the base address of the runtime linker in the inferiors address /// space. lldb::addr_t GetLDBase() const { return m_current.ldbase; } - /// @returns the thread layout metadata from the inferiors thread library. + /// \returns the thread layout metadata from the inferiors thread library. const ThreadInfo &GetThreadInfo(); - /// @returns true if modules have been loaded into the inferior since the + /// \returns true if modules have been loaded into the inferior since the /// last call to Resolve(). bool ModulesDidLoad() const { return !m_added_soentries.empty(); } - /// @returns true if modules have been unloaded from the inferior since the + /// \returns true if modules have been unloaded from the inferior since the /// last call to Resolve(). bool ModulesDidUnload() const { return !m_removed_soentries.empty(); } @@ -124,7 +124,7 @@ public: /// Constants describing the state of the rendezvous. /// - /// @see GetState(). + /// \see GetState(). enum RendezvousState { eConsistent = 0, eAdd, @@ -207,15 +207,15 @@ protected: /// Threading metadata read from the inferior. ThreadInfo m_thread_info; - /// Reads an unsigned integer of @p size bytes from the inferior's address - /// space starting at @p addr. + /// Reads an unsigned integer of \p size bytes from the inferior's address + /// space starting at \p addr. /// - /// @returns addr + size if the read was successful and false otherwise. + /// \returns addr + size if the read was successful and false otherwise. lldb::addr_t ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size); - /// Reads an address from the inferior's address space starting at @p addr. + /// Reads an address from the inferior's address space starting at \p addr. /// - /// @returns addr + target address size if the read was successful and + /// \returns addr + target address size if the read was successful and /// 0 otherwise. lldb::addr_t ReadPointer(lldb::addr_t addr, lldb::addr_t *dst); @@ -223,7 +223,7 @@ protected: /// addr. std::string ReadStringFromMemory(lldb::addr_t addr); - /// Reads an SOEntry starting at @p addr. + /// Reads an SOEntry starting at \p addr. bool ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry); /// Updates the current set of SOEntries, the set of added entries, and the diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h index af61958efb8..cf32d9cd30f 100644 --- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h +++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h @@ -17,7 +17,7 @@ namespace lldb_private { class DataExtractor; } -/// @class AuxVector +/// \class AuxVector /// Represents a processes auxiliary vector. /// /// When a process is loaded on Linux a vector of values is placed onto the diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h index 8c761e781c3..993e62f5e9f 100644 --- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h +++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h @@ -24,7 +24,7 @@ namespace lldb_private { class Process; } -/// @class DYLDRendezvous +/// \class DYLDRendezvous /// Interface to the runtime linker. /// /// A structure is present in a processes memory space which is updated by the @@ -66,50 +66,50 @@ public: /// This method should be called once one start up, then once each time the /// runtime linker enters the function given by GetBreakAddress(). /// - /// @returns true on success and false on failure. + /// \returns true on success and false on failure. /// - /// @see GetBreakAddress(). + /// \see GetBreakAddress(). bool Resolve(); - /// @returns true if this rendezvous has been located in the inferiors + /// \returns true if this rendezvous has been located in the inferiors /// address space and false otherwise. bool IsValid(); - /// @returns the address of the rendezvous structure in the inferiors + /// \returns the address of the rendezvous structure in the inferiors /// address space. lldb::addr_t GetRendezvousAddress() const { return m_rendezvous_addr; } - /// @returns the version of the rendezvous protocol being used. + /// \returns the version of the rendezvous protocol being used. uint64_t GetVersion() const { return m_current.version; } - /// @returns address in the inferiors address space containing the linked + /// \returns address in the inferiors address space containing the linked /// list of shared object descriptors. lldb::addr_t GetLinkMapAddress() const { return m_current.map_addr; } /// A breakpoint should be set at this address and Resolve called on each /// hit. /// - /// @returns the address of a function called by the runtime linker each + /// \returns the address of a function called by the runtime linker each /// time a module is loaded/unloaded, or about to be loaded/unloaded. /// - /// @see Resolve() + /// \see Resolve() lldb::addr_t GetBreakAddress() const { return m_current.brk; } /// Returns the current state of the rendezvous structure. uint64_t GetState() const { return m_current.state; } - /// @returns the base address of the runtime linker in the inferiors address + /// \returns the base address of the runtime linker in the inferiors address /// space. lldb::addr_t GetLDBase() const { return m_current.ldbase; } - /// @returns the thread layout metadata from the inferiors thread library. + /// \returns the thread layout metadata from the inferiors thread library. const ThreadInfo &GetThreadInfo(); - /// @returns true if modules have been loaded into the inferior since the + /// \returns true if modules have been loaded into the inferior since the /// last call to Resolve(). bool ModulesDidLoad() const { return !m_added_soentries.empty(); } - /// @returns true if modules have been unloaded from the inferior since the + /// \returns true if modules have been unloaded from the inferior since the /// last call to Resolve(). bool ModulesDidUnload() const { return !m_removed_soentries.empty(); } @@ -117,7 +117,7 @@ public: /// Constants describing the state of the rendezvous. /// - /// @see GetState(). + /// \see GetState(). enum RendezvousState { eConsistent, eAdd, eDelete }; /// Structure representing the shared objects currently loaded into the @@ -201,15 +201,15 @@ protected: /// Threading metadata read from the inferior. ThreadInfo m_thread_info; - /// Reads an unsigned integer of @p size bytes from the inferior's address - /// space starting at @p addr. + /// Reads an unsigned integer of \p size bytes from the inferior's address + /// space starting at \p addr. /// - /// @returns addr + size if the read was successful and false otherwise. + /// \returns addr + size if the read was successful and false otherwise. lldb::addr_t ReadWord(lldb::addr_t addr, uint64_t *dst, size_t size); - /// Reads an address from the inferior's address space starting at @p addr. + /// Reads an address from the inferior's address space starting at \p addr. /// - /// @returns addr + target address size if the read was successful and + /// \returns addr + target address size if the read was successful and /// 0 otherwise. lldb::addr_t ReadPointer(lldb::addr_t addr, lldb::addr_t *dst); @@ -217,7 +217,7 @@ protected: /// addr. std::string ReadStringFromMemory(lldb::addr_t addr); - /// Reads an SOEntry starting at @p addr. + /// Reads an SOEntry starting at \p addr. bool ReadSOEntryFromMemory(lldb::addr_t addr, SOEntry &entry); /// Updates the current set of SOEntries, the set of added entries, and the diff --git a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h index 9141138f5f0..1a2d40042c1 100644 --- a/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h +++ b/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h @@ -102,21 +102,21 @@ protected: /// of loaded modules. void RefreshModules(); - /// Updates the load address of every allocatable section in @p module. + /// Updates the load address of every allocatable section in \p module. /// - /// @param module The module to traverse. + /// \param module The module to traverse. /// - /// @param link_map_addr The virtual address of the link map for the @p + /// \param link_map_addr The virtual address of the link map for the @p /// module. /// - /// @param base_addr The virtual base address @p module is loaded at. + /// \param base_addr The virtual base address \p module is loaded at. void UpdateLoadedSections(lldb::ModuleSP module, lldb::addr_t link_map_addr, lldb::addr_t base_addr, bool base_addr_is_offset) override; - /// Removes the loaded sections from the target in @p module. + /// Removes the loaded sections from the target in \p module. /// - /// @param module The module to traverse. + /// \param module The module to traverse. void UnloadSections(const lldb::ModuleSP module) override; /// Resolves the entry point for the current inferior process and sets a diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h index bd09650ebc8..b5242afcfbd 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.h @@ -16,7 +16,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ASTResultSynthesizer ASTResultSynthesizer.h +/// \class ASTResultSynthesizer ASTResultSynthesizer.h /// "lldb/Expression/ASTResultSynthesizer.h" Adds a result variable /// declaration to the ASTs for an expression. /// @@ -34,17 +34,17 @@ public: //---------------------------------------------------------------------- /// Constructor /// - /// @param[in] passthrough + /// \param[in] passthrough /// Since the ASTs must typically go through to the Clang code generator /// in order to produce LLVM IR, this SemaConsumer must allow them to /// pass to the next step in the chain after processing. Passthrough is /// the next ASTConsumer, or NULL if none is required. /// - /// @param[in] top_level + /// \param[in] top_level /// If true, register all top-level Decls and don't try to handle the /// main function. /// - /// @param[in] target + /// \param[in] target /// The target, which contains the persistent variable store and the /// AST importer. //---------------------------------------------------------------------- @@ -59,7 +59,7 @@ public: //---------------------------------------------------------------------- /// Link this consumer with a particular AST context /// - /// @param[in] Context + /// \param[in] Context /// This AST context will be used for types and identifiers, and also /// forwarded to the passthrough consumer, if one exists. //---------------------------------------------------------------------- @@ -69,7 +69,7 @@ public: /// Examine a list of Decls to find the function $__lldb_expr and transform /// its code /// - /// @param[in] D + /// \param[in] D /// The list of Decls to search. These may contain LinkageSpecDecls, /// which need to be searched recursively. That job falls to /// TransformTopLevelDecl. @@ -104,7 +104,7 @@ public: //---------------------------------------------------------------------- /// Set the Sema object to use when performing transforms, and pass it on /// - /// @param[in] S + /// \param[in] S /// The Sema to use. Because Sema isn't externally visible, this class /// casts it to an Action for actual use. //---------------------------------------------------------------------- @@ -126,7 +126,7 @@ private: /// necessary through LinkageSpecDecls, and calling SynthesizeResult on /// anything that was found /// - /// @param[in] D + /// \param[in] D /// The Decl to hunt. //---------------------------------------------------------------------- void TransformTopLevelDecl(clang::Decl *D); @@ -135,7 +135,7 @@ private: /// Process an Objective-C method and produce the result variable and /// initialization /// - /// @param[in] MethodDecl + /// \param[in] MethodDecl /// The method to process. //---------------------------------------------------------------------- bool SynthesizeObjCMethodResult(clang::ObjCMethodDecl *MethodDecl); @@ -143,7 +143,7 @@ private: //---------------------------------------------------------------------- /// Process a function and produce the result variable and initialization /// - /// @param[in] FunDecl + /// \param[in] FunDecl /// The function to process. //---------------------------------------------------------------------- bool SynthesizeFunctionResult(clang::FunctionDecl *FunDecl); @@ -152,10 +152,10 @@ private: /// Process a function body and produce the result variable and /// initialization /// - /// @param[in] Body + /// \param[in] Body /// The body of the function. /// - /// @param[in] DC + /// \param[in] DC /// The DeclContext of the function, into which the result variable /// is inserted. //---------------------------------------------------------------------- @@ -165,7 +165,7 @@ private: /// Given a DeclContext for a function or method, find all types declared in /// the context and record any persistent types found. /// - /// @param[in] FunDeclCtx + /// \param[in] FunDeclCtx /// The context for the function to process. //---------------------------------------------------------------------- void RecordPersistentTypes(clang::DeclContext *FunDeclCtx); @@ -175,7 +175,7 @@ private: /// sign, register it as a pointer type in the target's scratch /// AST context. /// - /// @param[in] Body + /// \param[in] Body /// The body of the function. //---------------------------------------------------------------------- void MaybeRecordPersistentType(clang::TypeDecl *D); @@ -184,7 +184,7 @@ private: /// Given a NamedDecl, register it as a pointer type in the target's scratch /// AST context. /// - /// @param[in] Body + /// \param[in] Body /// The body of the function. //---------------------------------------------------------------------- void RecordPersistentDecl(clang::NamedDecl *D); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h index 0eef6ea0f9d..33c06701539 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.h @@ -18,7 +18,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ASTStructExtractor ASTStructExtractor.h +/// \class ASTStructExtractor ASTStructExtractor.h /// "lldb/Expression/ASTStructExtractor.h" Extracts and describes the argument /// structure for a wrapped function. /// @@ -38,16 +38,16 @@ public: //---------------------------------------------------------------------- /// Constructor /// - /// @param[in] passthrough + /// \param[in] passthrough /// Since the ASTs must typically go through to the Clang code generator /// in order to produce LLVM IR, this SemaConsumer must allow them to /// pass to the next step in the chain after processing. Passthrough is /// the next ASTConsumer, or NULL if none is required. /// - /// @param[in] struct_name + /// \param[in] struct_name /// The name of the structure to extract from the wrapper function. /// - /// @param[in] function + /// \param[in] function /// The caller object whose members should be populated with information /// about the argument struct. ClangFunctionCaller friends /// ASTStructExtractor @@ -64,7 +64,7 @@ public: //---------------------------------------------------------------------- /// Link this consumer with a particular AST context /// - /// @param[in] Context + /// \param[in] Context /// This AST context will be used for types and identifiers, and also /// forwarded to the passthrough consumer, if one exists. //---------------------------------------------------------------------- @@ -74,7 +74,7 @@ public: /// Examine a list of Decls to find the function $__lldb_expr and transform /// its code /// - /// @param[in] D + /// \param[in] D /// The list of Decls to search. These may contain LinkageSpecDecls, /// which need to be searched recursively. That job falls to /// TransformTopLevelDecl. @@ -109,7 +109,7 @@ public: //---------------------------------------------------------------------- /// Set the Sema object to use when performing transforms, and pass it on /// - /// @param[in] S + /// \param[in] S /// The Sema to use. Because Sema isn't externally visible, this class /// casts it to an Action for actual use. //---------------------------------------------------------------------- @@ -125,7 +125,7 @@ private: /// Hunt the given FunctionDecl for the argument struct and place /// information about it into m_function /// - /// @param[in] F + /// \param[in] F /// The FunctionDecl to hunt. //---------------------------------------------------------------------- void ExtractFromFunctionDecl(clang::FunctionDecl *F); @@ -135,7 +135,7 @@ private: /// function name, recursing as necessary through LinkageSpecDecls, and /// calling ExtractFromFunctionDecl on anything that was found /// - /// @param[in] D + /// \param[in] D /// The Decl to hunt. //---------------------------------------------------------------------- void ExtractFromTopLevelDecl(clang::Decl *D); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h index 063d82e1c9e..e12f1c5c770 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h @@ -23,7 +23,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ClangASTSource ClangASTSource.h "lldb/Expression/ClangASTSource.h" +/// \class ClangASTSource ClangASTSource.h "lldb/Expression/ClangASTSource.h" /// Provider for named objects defined in the debug info for Clang /// /// As Clang parses an expression, it may encounter names that are not defined @@ -40,7 +40,7 @@ public: /// /// Initializes class variables. /// - /// @param[in] target + /// \param[in] target /// A reference to the target containing debug information to use. //------------------------------------------------------------------ ClangASTSource(const lldb::TargetSP &target); @@ -82,13 +82,13 @@ public: /// The work for this function is done by /// void FindExternalVisibleDecls (NameSearchContext &); /// - /// @param[in] DC + /// \param[in] DC /// The DeclContext to register the found Decls in. /// - /// @param[in] Name + /// \param[in] Name /// The name to find entries for. /// - /// @return + /// \return /// Whatever SetExternalVisibleDeclsForName returns. //------------------------------------------------------------------ bool FindExternalVisibleDeclsByName(const clang::DeclContext *DC, @@ -97,14 +97,14 @@ public: //------------------------------------------------------------------ /// Enumerate all Decls in a given lexical context. /// - /// @param[in] DC + /// \param[in] DC /// The DeclContext being searched. /// - /// @param[in] isKindWeWant + /// \param[in] isKindWeWant /// A callback function that returns true given the /// DeclKinds of desired Decls, and false otherwise. /// - /// @param[in] Decls + /// \param[in] Decls /// A vector that is filled in with matching Decls. //------------------------------------------------------------------ void FindExternalLexicalDecls( @@ -115,34 +115,34 @@ public: //------------------------------------------------------------------ /// Specify the layout of the contents of a RecordDecl. /// - /// @param[in] Record + /// \param[in] Record /// The record (in the parser's AST context) that needs to be /// laid out. /// - /// @param[out] Size + /// \param[out] Size /// The total size of the record in bits. /// - /// @param[out] Alignment + /// \param[out] Alignment /// The alignment of the record in bits. /// - /// @param[in] FieldOffsets + /// \param[in] FieldOffsets /// A map that must be populated with pairs of the record's /// fields (in the parser's AST context) and their offsets /// (measured in bits). /// - /// @param[in] BaseOffsets + /// \param[in] BaseOffsets /// A map that must be populated with pairs of the record's /// C++ concrete base classes (in the parser's AST context, /// and only if the record is a CXXRecordDecl and has base /// classes) and their offsets (measured in bytes). /// - /// @param[in] VirtualBaseOffsets + /// \param[in] VirtualBaseOffsets /// A map that must be populated with pairs of the record's /// C++ virtual base classes (in the parser's AST context, /// and only if the record is a CXXRecordDecl and has base /// classes) and their offsets (measured in bytes). /// - /// @return + /// \return /// True <=> the layout is valid. //----------------------------------------------------------------- bool layoutRecordType( @@ -156,7 +156,7 @@ public: //------------------------------------------------------------------ /// Complete a TagDecl. /// - /// @param[in] Tag + /// \param[in] Tag /// The Decl to be completed in place. //------------------------------------------------------------------ void CompleteType(clang::TagDecl *Tag) override; @@ -164,7 +164,7 @@ public: //------------------------------------------------------------------ /// Complete an ObjCInterfaceDecl. /// - /// @param[in] Class + /// \param[in] Class /// The Decl to be completed in place. //------------------------------------------------------------------ void CompleteType(clang::ObjCInterfaceDecl *Class) override; @@ -174,7 +174,7 @@ public: /// setHasExternalVisibleStorage() and setHasExternalLexicalStorage() that /// this object has something to say about undefined names. /// - /// @param[in] ASTConsumer + /// \param[in] ASTConsumer /// Unused. //------------------------------------------------------------------ void StartTranslationUnit(clang::ASTConsumer *Consumer) override; @@ -187,13 +187,13 @@ public: /// Look up the modules containing a given namespace and put the appropriate /// entries in the namespace map. /// - /// @param[in] namespace_map + /// \param[in] namespace_map /// The map to be completed. /// - /// @param[in] name + /// \param[in] name /// The name of the namespace to be found. /// - /// @param[in] parent_map + /// \param[in] parent_map /// The map for the namespace's parent namespace, if there is /// one. //------------------------------------------------------------------ @@ -212,7 +212,7 @@ public: //------------------------------------------------------------------ /// The worker function for FindExternalVisibleDeclsByName. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when filing results. //------------------------------------------------------------------ virtual void FindExternalVisibleDecls(NameSearchContext &context); @@ -228,7 +228,7 @@ public: bool GetLookupsEnabled() { return m_lookups_enabled; } //---------------------------------------------------------------------- - /// @class ClangASTSourceProxy ClangASTSource.h + /// \class ClangASTSourceProxy ClangASTSource.h /// "lldb/Expression/ClangASTSource.h" Proxy for ClangASTSource /// /// Clang AST contexts like to own their AST sources, so this is a state- @@ -298,10 +298,10 @@ protected: /// Look for the complete version of an Objective-C interface, and return it /// if found. /// - /// @param[in] interface_decl + /// \param[in] interface_decl /// An ObjCInterfaceDecl that may not be the complete one. /// - /// @return + /// \return /// NULL if the complete interface couldn't be found; /// the complete interface otherwise. //------------------------------------------------------------------ @@ -312,16 +312,16 @@ protected: /// Find all entities matching a given name in a given module, using a /// NameSearchContext to make Decls for them. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext that can construct Decls for this name. /// - /// @param[in] module + /// \param[in] module /// If non-NULL, the module to query. /// - /// @param[in] namespace_decl + /// \param[in] namespace_decl /// If valid and module is non-NULL, the parent namespace. /// - /// @param[in] current_id + /// \param[in] current_id /// The ID for the current FindExternalVisibleDecls invocation, /// for logging purposes. //------------------------------------------------------------------ @@ -333,7 +333,7 @@ protected: //------------------------------------------------------------------ /// Find all Objective-C methods matching a given selector. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext that can construct Decls for this name. /// Its m_decl_name contains the selector and its m_decl_context /// is the containing object. @@ -343,7 +343,7 @@ protected: //------------------------------------------------------------------ /// Find all Objective-C properties and ivars with a given name. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext that can construct Decls for this name. /// Its m_decl_name contains the name and its m_decl_context /// is the containing object. @@ -354,17 +354,17 @@ protected: /// A wrapper for ClangASTContext::CopyType that sets a flag that /// indicates that we should not respond to queries during import. /// - /// @param[in] dest_context + /// \param[in] dest_context /// The target AST context, typically the parser's AST context. /// - /// @param[in] source_context + /// \param[in] source_context /// The source AST context, typically the AST context of whatever /// symbol file the type was found in. /// - /// @param[in] src_type + /// \param[in] src_type /// The source type. /// - /// @return + /// \return /// The imported type. //------------------------------------------------------------------ CompilerType GuardedCopyType(const CompilerType &src_type); @@ -373,13 +373,13 @@ public: //------------------------------------------------------------------ /// Returns true if a name should be ignored by name lookup. /// - /// @param[in] name + /// \param[in] name /// The name to be considered. /// - /// @param[in] ignore_all_dollar_nmmes + /// \param[in] ignore_all_dollar_nmmes /// True if $-names of all sorts should be ignored. /// - /// @return + /// \return /// True if the name is one of a class of names that are ignored by /// global lookup for performance reasons. //------------------------------------------------------------------ @@ -389,10 +389,10 @@ public: //------------------------------------------------------------------ /// Copies a single Decl into the parser's AST context. /// - /// @param[in] src_decl + /// \param[in] src_decl /// The Decl to copy. /// - /// @return + /// \return /// A copy of the Decl in m_ast_context, or NULL if the copy failed. //------------------------------------------------------------------ clang::Decl *CopyDecl(clang::Decl *src_decl); @@ -400,17 +400,17 @@ public: //------------------------------------------------------------------ /// Copies a single Type to the target of the given ExternalASTMerger. /// - /// @param[in] src_context + /// \param[in] src_context /// The ASTContext containing the type. /// - /// @param[in] merger + /// \param[in] merger /// The merger to use. This isn't just *m_merger_up because it might be /// the persistent AST context's merger. /// - /// @param[in] type + /// \param[in] type /// The type to copy. /// - /// @return + /// \return /// A copy of the Type in the merger's target context. //------------------------------------------------------------------ clang::QualType CopyTypeWithMerger(clang::ASTContext &src_context, @@ -420,16 +420,16 @@ public: //------------------------------------------------------------------ /// Determined the origin of a single Decl, if it can be found. /// - /// @param[in] decl + /// \param[in] decl /// The Decl whose origin is to be found. /// - /// @param[out] original_decl + /// \param[out] original_decl /// A pointer whose target is filled in with the original Decl. /// - /// @param[in] original_ctx + /// \param[in] original_ctx /// A pointer whose target is filled in with the original's ASTContext. /// - /// @return + /// \return /// True if lookup succeeded; false otherwise. //------------------------------------------------------------------ bool ResolveDeclOrigin(const clang::Decl *decl, clang::Decl **original_decl, @@ -471,7 +471,7 @@ protected: }; //---------------------------------------------------------------------- -/// @class NameSearchContext ClangASTSource.h +/// \class NameSearchContext ClangASTSource.h /// "lldb/Expression/ClangASTSource.h" Container for all objects relevant to a /// single name lookup /// @@ -508,17 +508,17 @@ struct NameSearchContext { /// /// Initializes class variables. /// - /// @param[in] astSource + /// \param[in] astSource /// A reference to the AST source making a request. /// - /// @param[in] decls + /// \param[in] decls /// A reference to a list into which new Decls will be placed. This /// list is typically empty when the function is called. /// - /// @param[in] name + /// \param[in] name /// The name being searched for (always an Identifier). /// - /// @param[in] dc + /// \param[in] dc /// The DeclContext to register Decls in. //------------------------------------------------------------------ NameSearchContext(ClangASTSource &astSource, @@ -533,7 +533,7 @@ struct NameSearchContext { /// Create a VarDecl with the name being searched for and the provided type /// and register it in the right places. /// - /// @param[in] type + /// \param[in] type /// The opaque QualType for the VarDecl being registered. //------------------------------------------------------------------ clang::NamedDecl *AddVarDecl(const CompilerType &type); @@ -542,10 +542,10 @@ struct NameSearchContext { /// Create a FunDecl with the name being searched for and the provided type /// and register it in the right places. /// - /// @param[in] type + /// \param[in] type /// The opaque QualType for the FunDecl being registered. /// - /// @param[in] extern_c + /// \param[in] extern_c /// If true, build an extern "C" linkage specification for this. //------------------------------------------------------------------ clang::NamedDecl *AddFunDecl(const CompilerType &type, bool extern_c = false); @@ -560,7 +560,7 @@ struct NameSearchContext { /// Create a TypeDecl with the name being searched for and the provided type /// and register it in the right places. /// - /// @param[in] compiler_type + /// \param[in] compiler_type /// The opaque QualType for the TypeDecl being registered. //------------------------------------------------------------------ clang::NamedDecl *AddTypeDecl(const CompilerType &compiler_type); @@ -569,7 +569,7 @@ struct NameSearchContext { /// Add Decls from the provided DeclContextLookupResult to the list of /// results. /// - /// @param[in] result + /// \param[in] result /// The DeclContextLookupResult, usually returned as the result /// of querying a DeclContext. //------------------------------------------------------------------ @@ -578,7 +578,7 @@ struct NameSearchContext { //------------------------------------------------------------------ /// Add a NamedDecl to the list of results. /// - /// @param[in] decl + /// \param[in] decl /// The NamedDecl, usually returned as the result /// of querying a DeclContext. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h index dd866c37ddb..9d2dd225ae7 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h @@ -30,7 +30,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ClangExpressionDeclMap ClangExpressionDeclMap.h +/// \class ClangExpressionDeclMap ClangExpressionDeclMap.h /// "lldb/Expression/ClangExpressionDeclMap.h" Manages named entities that are /// defined in LLDB's debug information. /// @@ -61,19 +61,19 @@ public: /// /// Initializes class variables. /// - /// @param[in] keep_result_in_memory + /// \param[in] keep_result_in_memory /// If true, inhibits the normal deallocation of the memory for /// the result persistent variable, and instead marks the variable /// as persisting. /// - /// @param[in] delegate + /// \param[in] delegate /// If non-NULL, use this delegate to report result values. This /// allows the client ClangUserExpression to report a result. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to use when parsing. /// - /// @param[in] ctx_obj + /// \param[in] ctx_obj /// If not empty, then expression is evaluated in context of this object. /// See the comment to `UserExpression::Evaluate` for details. //------------------------------------------------------------------ @@ -91,15 +91,15 @@ public: //------------------------------------------------------------------ /// Enable the state needed for parsing and IR transformation. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to use when finding types for variables. /// Also used to find a "scratch" AST context to store result types. /// - /// @param[in] materializer + /// \param[in] materializer /// If non-NULL, the materializer to populate with information about /// the variables to use /// - /// @return + /// \return /// True if parsing is possible; false if it is unsafe to continue. //------------------------------------------------------------------ bool WillParse(ExecutionContext &exe_ctx, Materializer *materializer); @@ -110,7 +110,7 @@ public: /// [Used by ClangExpressionParser] For each variable that had an unknown /// type at the beginning of parsing, determine its final type now. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool ResolveUnknownTypes(); @@ -124,17 +124,17 @@ public: /// [Used by IRForTarget] Add a variable to the list of persistent /// variables for the process. /// - /// @param[in] decl + /// \param[in] decl /// The Clang declaration for the persistent variable, used for /// lookup during parsing. /// - /// @param[in] name + /// \param[in] name /// The name of the persistent variable, usually $something. /// - /// @param[in] type + /// \param[in] type /// The type of the variable, in the Clang parser's context. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool AddPersistentVariable(const clang::NamedDecl *decl, @@ -145,22 +145,22 @@ public: /// [Used by IRForTarget] Add a variable to the struct that needs to /// be materialized each time the expression runs. /// - /// @param[in] decl + /// \param[in] decl /// The Clang declaration for the variable. /// - /// @param[in] name + /// \param[in] name /// The name of the variable. /// - /// @param[in] value + /// \param[in] value /// The LLVM IR value for this variable. /// - /// @param[in] size + /// \param[in] size /// The size of the variable in bytes. /// - /// @param[in] alignment + /// \param[in] alignment /// The required alignment of the variable in bytes. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name, @@ -171,7 +171,7 @@ public: /// [Used by IRForTarget] Finalize the struct, laying out the position of /// each object in it. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool DoStructLayout(); @@ -180,16 +180,16 @@ public: /// [Used by IRForTarget] Get general information about the laid-out struct /// after DoStructLayout() has been called. /// - /// @param[out] num_elements + /// \param[out] num_elements /// The number of elements in the struct. /// - /// @param[out] size + /// \param[out] size /// The size of the struct, in bytes. /// - /// @param[out] alignment + /// \param[out] alignment /// The alignment of the struct, in bytes. /// - /// @return + /// \return /// True if the information could be retrieved; false otherwise. //------------------------------------------------------------------ bool GetStructInfo(uint32_t &num_elements, size_t &size, @@ -199,31 +199,31 @@ public: /// [Used by IRForTarget] Get specific information about one field of the /// laid-out struct after DoStructLayout() has been called. /// - /// @param[out] decl + /// \param[out] decl /// The parsed Decl for the field, as generated by ClangASTSource /// on ClangExpressionDeclMap's behalf. In the case of the result /// value, this will have the name $__lldb_result even if the /// result value ends up having the name $1. This is an /// implementation detail of IRForTarget. /// - /// @param[out] value + /// \param[out] value /// The IR value for the field (usually a GlobalVariable). In /// the case of the result value, this will have the correct /// name ($1, for instance). This is an implementation detail /// of IRForTarget. /// - /// @param[out] offset + /// \param[out] offset /// The offset of the field from the beginning of the struct. /// As long as the struct is aligned according to its required /// alignment, this offset will align the field correctly. /// - /// @param[out] name + /// \param[out] name /// The name of the field as used in materialization. /// - /// @param[in] index + /// \param[in] index /// The index of the field about which information is requested. /// - /// @return + /// \return /// True if the information could be retrieved; false otherwise. //------------------------------------------------------------------ bool GetStructElement(const clang::NamedDecl *&decl, llvm::Value *&value, @@ -233,14 +233,14 @@ public: //------------------------------------------------------------------ /// [Used by IRForTarget] Get information about a function given its Decl. /// - /// @param[in] decl + /// \param[in] decl /// The parsed Decl for the Function, as generated by ClangASTSource /// on ClangExpressionDeclMap's behalf. /// - /// @param[out] ptr + /// \param[out] ptr /// The absolute address of the function in the target. /// - /// @return + /// \return /// True if the information could be retrieved; false otherwise. //------------------------------------------------------------------ bool GetFunctionInfo(const clang::NamedDecl *decl, uint64_t &ptr); @@ -249,22 +249,22 @@ public: /// [Used by IRForTarget] Get the address of a symbol given nothing but its /// name. /// - /// @param[in] target + /// \param[in] target /// The target to find the symbol in. If not provided, /// then the current parsing context's Target. /// - /// @param[in] process + /// \param[in] process /// The process to use. For Objective-C symbols, the process's /// Objective-C language runtime may be queried if the process /// is non-NULL. /// - /// @param[in] name + /// \param[in] name /// The name of the symbol. /// - /// @param[in] module + /// \param[in] module /// The module to limit the search to. This can be NULL /// - /// @return + /// \return /// Valid load address for the symbol //------------------------------------------------------------------ lldb::addr_t GetSymbolAddress(Target &target, Process *process, @@ -278,13 +278,13 @@ public: //------------------------------------------------------------------ /// [Used by IRInterpreter] Get basic target information. /// - /// @param[out] byte_order + /// \param[out] byte_order /// The byte order of the target. /// - /// @param[out] address_byte_size + /// \param[out] address_byte_size /// The size of a pointer in bytes. /// - /// @return + /// \return /// True if the information could be determined; false /// otherwise. //------------------------------------------------------------------ @@ -304,10 +304,10 @@ public: /// [Used by ClangASTSource] Find all entities matching a given name, using /// a NameSearchContext to make Decls for them. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext that can construct Decls for this name. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ void FindExternalVisibleDecls(NameSearchContext &context) override; @@ -316,20 +316,20 @@ public: /// Find all entities matching a given name in a given module/namespace, /// using a NameSearchContext to make Decls for them. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext that can construct Decls for this name. /// - /// @param[in] module + /// \param[in] module /// If non-NULL, the module to query. /// - /// @param[in] namespace_decl + /// \param[in] namespace_decl /// If valid and module is non-NULL, the parent namespace. /// - /// @param[in] current_id + /// \param[in] current_id /// The ID for the current FindExternalVisibleDecls invocation, /// for logging purposes. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ void FindExternalVisibleDecls(NameSearchContext &context, @@ -446,24 +446,24 @@ private: //------------------------------------------------------------------ /// Given a target, find a variable that matches the given name and type. /// - /// @param[in] target + /// \param[in] target /// The target to use as a basis for finding the variable. /// - /// @param[in] module + /// \param[in] module /// If non-NULL, the module to search. /// - /// @param[in] name + /// \param[in] name /// The name as a plain C string. /// - /// @param[in] namespace_decl + /// \param[in] namespace_decl /// If non-NULL and module is non-NULL, the parent namespace. /// - /// @param[in] type + /// \param[in] type /// The required type for the variable. This function may be called /// during parsing, in which case we don't know its type; hence the /// default. /// - /// @return + /// \return /// The LLDB Variable found, or NULL if none was found. //------------------------------------------------------------------ lldb::VariableSP FindGlobalVariable(Target &target, lldb::ModuleSP &module, @@ -475,26 +475,26 @@ private: /// Get the value of a variable in a given execution context and return the /// associated Types if needed. /// - /// @param[in] var + /// \param[in] var /// The variable to evaluate. /// - /// @param[out] var_location + /// \param[out] var_location /// The variable location value to fill in /// - /// @param[out] found_type + /// \param[out] found_type /// The type of the found value, as it was found in the user process. /// This is only useful when the variable is being inspected on behalf /// of the parser, hence the default. /// - /// @param[out] parser_type + /// \param[out] parser_type /// The type of the found value, as it was copied into the parser's /// AST context. This is only useful when the variable is being /// inspected on behalf of the parser, hence the default. /// - /// @param[in] decl + /// \param[in] decl /// The Decl to be looked up. /// - /// @return + /// \return /// Return true if the value was successfully filled in. //------------------------------------------------------------------ bool GetVariableValue(lldb::VariableSP &var, @@ -506,13 +506,13 @@ private: /// Use the NameSearchContext to generate a Decl for the given LLDB /// Variable, and put it in the Tuple list. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] var + /// \param[in] var /// The LLDB Variable that needs a Decl. /// - /// @param[in] valobj + /// \param[in] valobj /// The LLDB ValueObject for that variable. //------------------------------------------------------------------ void AddOneVariable(NameSearchContext &context, lldb::VariableSP var, @@ -522,13 +522,13 @@ private: /// Use the NameSearchContext to generate a Decl for the given persistent /// variable, and put it in the list of found entities. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] pvar + /// \param[in] pvar /// The persistent variable that needs a Decl. /// - /// @param[in] current_id + /// \param[in] current_id /// The ID of the current invocation of FindExternalVisibleDecls /// for logging purposes. //------------------------------------------------------------------ @@ -540,10 +540,10 @@ private: /// Use the NameSearchContext to generate a Decl for the given LLDB symbol /// (treated as a variable), and put it in the list of found entities. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] var + /// \param[in] var /// The LLDB Variable that needs a Decl. //------------------------------------------------------------------ void AddOneGenericVariable(NameSearchContext &context, const Symbol &symbol, @@ -554,14 +554,14 @@ private: /// (Functions are not placed in the Tuple list.) Can handle both fully /// typed functions and generic functions. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] fun + /// \param[in] fun /// The Function that needs to be created. If non-NULL, this is /// a fully-typed function. /// - /// @param[in] sym + /// \param[in] sym /// The Symbol that corresponds to a function that needs to be /// created with generic type (unitptr_t foo(...)). //------------------------------------------------------------------ @@ -571,10 +571,10 @@ private: //------------------------------------------------------------------ /// Use the NameSearchContext to generate a Decl for the given register. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] reg_info + /// \param[in] reg_info /// The information corresponding to that register. //------------------------------------------------------------------ void AddOneRegister(NameSearchContext &context, const RegisterInfo *reg_info, @@ -584,10 +584,10 @@ private: /// Use the NameSearchContext to generate a Decl for the given type. (Types /// are not placed in the Tuple list.) /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] type + /// \param[in] type /// The type that needs to be created. //------------------------------------------------------------------ void AddOneType(NameSearchContext &context, const TypeFromUser &type, @@ -597,10 +597,10 @@ private: /// Generate a Decl for "*this" and add a member function declaration to it /// for the expression, then report it. /// - /// @param[in] context + /// \param[in] context /// The NameSearchContext to use when constructing the Decl. /// - /// @param[in] type + /// \param[in] type /// The type for *this. //------------------------------------------------------------------ void AddThisType(NameSearchContext &context, const TypeFromUser &type, @@ -610,14 +610,14 @@ private: /// Move a type out of the current ASTContext into another, but make sure to /// export all components of the type also. /// - /// @param[in] target + /// \param[in] target /// The ClangASTContext to move to. - /// @param[in] source + /// \param[in] source /// The ClangASTContext to move from. This is assumed to be going away. - /// @param[in] parser_type + /// \param[in] parser_type /// The type as it appears in the source context. /// - /// @return + /// \return /// Returns the moved type, or an empty type if there was a problem. //------------------------------------------------------------------ TypeFromUser DeportType(ClangASTContext &target, ClangASTContext &source, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h index 7a77c4581fb..40e56637cfe 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionHelper.h @@ -51,7 +51,7 @@ public: /// Return the object that the parser should allow to access ASTs. /// May be NULL if the ASTs do not need to be transformed. /// - /// @param[in] passthrough + /// \param[in] passthrough /// The ASTConsumer that the returned transformer should send /// the ASTs to after transformation. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp index e3597d6c4b9..6c9169852d4 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp @@ -551,7 +551,7 @@ ClangExpressionParser::~ClangExpressionParser() {} namespace { //---------------------------------------------------------------------- -/// @class CodeComplete +/// \class CodeComplete /// /// A code completion consumer for the clang Sema that is responsible for /// creating the completion suggestions when a user requests completion @@ -629,15 +629,15 @@ class CodeComplete : public CodeCompleteConsumer { public: /// Constructs a CodeComplete consumer that can be attached to a Sema. - /// @param[out] matches + /// \param[out] matches /// The list of matches that the lldb completion API expects as a result. /// This may already contain matches, so it's only allowed to append /// to this variable. - /// @param[out] expr + /// \param[out] expr /// The whole expression string that we are currently parsing. This /// string needs to be equal to the input the user typed, and NOT the /// final code that Clang is parsing. - /// @param[out] position + /// \param[out] position /// The character position of the user cursor in the `expr` parameter. /// CodeComplete(CompletionRequest &request, clang::LangOptions ops, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h index e950a694306..1183b169f6b 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.h @@ -28,7 +28,7 @@ namespace lldb_private { class IRExecutionUnit; //---------------------------------------------------------------------- -/// @class ClangExpressionParser ClangExpressionParser.h +/// \class ClangExpressionParser ClangExpressionParser.h /// "lldb/Expression/ClangExpressionParser.h" Encapsulates an instance of /// Clang that can parse expressions. /// @@ -45,12 +45,12 @@ public: /// /// Initializes class variables. /// - /// @param[in] exe_scope, + /// \param[in] exe_scope, /// If non-NULL, an execution context scope that can help to /// correctly create an expression with a valid process for /// optional tuning Objective-C runtime support. Can be NULL. /// - /// @param[in] expr + /// \param[in] expr /// The expression to be parsed. //------------------------------------------------------------------ ClangExpressionParser(ExecutionContextScope *exe_scope, Expression &expr, @@ -68,10 +68,10 @@ public: /// Parse a single expression and convert it to IR using Clang. Don't wrap /// the expression in anything at all. /// - /// @param[in] diagnostic_manager + /// \param[in] diagnostic_manager /// The diagnostic manager to report errors to. /// - /// @return + /// \return /// The number of errors encountered during parsing. 0 means /// success. //------------------------------------------------------------------ @@ -83,36 +83,36 @@ public: /// Ready an already-parsed expression for execution, possibly evaluating it /// statically. /// - /// @param[out] func_addr + /// \param[out] func_addr /// The address to which the function has been written. /// - /// @param[out] func_end + /// \param[out] func_end /// The end of the function's allocated memory region. (func_addr /// and func_end do not delimit an allocated region; the allocated /// region may begin before func_addr.) /// - /// @param[in] execution_unit_sp + /// \param[in] execution_unit_sp /// After parsing, ownership of the execution unit for /// for the expression is handed to this shared pointer. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to write the function into. /// - /// @param[out] evaluated_statically + /// \param[out] evaluated_statically /// Set to true if the expression could be interpreted statically; /// untouched otherwise. /// - /// @param[out] const_result + /// \param[out] const_result /// If the result of the expression is constant, and the /// expression has no side effects, this is set to the result of the /// expression. /// - /// @param[in] execution_policy + /// \param[in] execution_policy /// Determines whether the expression must be JIT-compiled, must be /// evaluated statically, or whether this decision may be made /// opportunistically. /// - /// @return + /// \return /// An error code indicating the success or failure of the operation. /// Test with Success(). //------------------------------------------------------------------ @@ -125,13 +125,13 @@ public: //------------------------------------------------------------------ /// Run all static initializers for an execution unit. /// - /// @param[in] execution_unit_sp + /// \param[in] execution_unit_sp /// The execution unit. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to use when running them. Thread can't be null. /// - /// @return + /// \return /// The error code indicating the //------------------------------------------------------------------ Status RunStaticInitializers(lldb::IRExecutionUnitSP &execution_unit_sp, @@ -140,10 +140,10 @@ public: //------------------------------------------------------------------ /// Returns a string representing current ABI. /// - /// @param[in] target_arch + /// \param[in] target_arch /// The target architecture. /// - /// @return + /// \return /// A string representing target ABI for the current architecture. //------------------------------------------------------------------- std::string GetClangTargetABI(const ArchSpec &target_arch); @@ -152,23 +152,23 @@ private: //------------------------------------------------------------------ /// Parses the expression. /// - /// @param[in] diagnostic_manager + /// \param[in] diagnostic_manager /// The diagnostic manager that should receive the diagnostics /// from the parsing process. /// - /// @param[in] completion + /// \param[in] completion /// The completion consumer that should be used during parsing /// (or a nullptr if no consumer should be attached). /// - /// @param[in] completion_line + /// \param[in] completion_line /// The line in which the completion marker should be placed. /// The first line is represented by the value 0. /// - /// @param[in] completion_column + /// \param[in] completion_column /// The column in which the completion marker should be placed. /// The first column is represented by the value 0. /// - /// @return + /// \return /// The number of parsing errors. //------------------------------------------------------------------- unsigned ParseInternal(DiagnosticManager &diagnostic_manager, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h index b9767e22cd2..a81f42dff61 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h @@ -35,7 +35,7 @@ namespace lldb_private { class ValueObjectConstResult; //---------------------------------------------------------------------- -/// @class ClangExpressionVariable ClangExpressionVariable.h +/// \class ClangExpressionVariable ClangExpressionVariable.h /// "lldb/Expression/ClangExpressionVariable.h" Encapsulates one variable for /// the expression parser. /// @@ -79,10 +79,10 @@ public: //---------------------------------------------------------------------- /// Finds a variable by NamedDecl in the list. /// - /// @param[in] name + /// \param[in] name /// The name of the requested variable. /// - /// @return + /// \return /// The variable requested, or NULL if that variable is not in the list. //---------------------------------------------------------------------- static ClangExpressionVariable * @@ -109,13 +109,13 @@ public: /// exe_ctx in not NULL, the value will be resolved in with that execution /// context. /// - /// @param[in] value + /// \param[in] value /// The value to point at the data. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to use to resolve \a value. /// - /// @return + /// \return /// True on success; false otherwise (in particular, if this variable /// does not contain its own data). //---------------------------------------------------------------------- diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h index d730acdf784..1aa13095898 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangFunctionCaller.h @@ -25,7 +25,7 @@ class ASTStructExtractor; class ClangExpressionParser; //---------------------------------------------------------------------- -/// @class ClangFunctionCaller ClangFunctionCaller.h +/// \class ClangFunctionCaller ClangFunctionCaller.h /// "lldb/Expression/ClangFunctionCaller.h" Encapsulates a function that can /// be called. /// @@ -77,7 +77,7 @@ class ClangFunctionCaller : public FunctionCaller { /// Return the object that the parser should allow to access ASTs. May be /// NULL if the ASTs do not need to be transformed. /// - /// @param[in] passthrough + /// \param[in] passthrough /// The ASTConsumer that the returned transformer should send /// the ASTs to after transformation. //------------------------------------------------------------------ @@ -96,21 +96,21 @@ public: //------------------------------------------------------------------ /// Constructor /// - /// @param[in] exe_scope + /// \param[in] exe_scope /// An execution context scope that gets us at least a target and /// process. /// - /// @param[in] ast_context + /// \param[in] ast_context /// The AST context to evaluate argument types in. /// - /// @param[in] return_qualtype + /// \param[in] return_qualtype /// An opaque Clang QualType for the function result. Should be /// defined in ast_context. /// - /// @param[in] function_address + /// \param[in] function_address /// The address of the function to call. /// - /// @param[in] arg_value_list + /// \param[in] arg_value_list /// The default values to use when calling this function. Can /// be overridden using WriteFunctionArguments(). //------------------------------------------------------------------ @@ -124,15 +124,15 @@ public: //------------------------------------------------------------------ /// Compile the wrapper function /// - /// @param[in] thread_to_use_sp + /// \param[in] thread_to_use_sp /// Compilation might end up calling functions. Pass in the thread you /// want the compilation to use. If you pass in an empty ThreadSP it will /// use the currently selected thread. /// - /// @param[in] diagnostic_manager + /// \param[in] diagnostic_manager /// The diagnostic manager to report parser errors to. /// - /// @return + /// \return /// The number of errors. //------------------------------------------------------------------ unsigned CompileFunction(lldb::ThreadSP thread_to_use_sp, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h index a386b5f20b3..18850870eaf 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h @@ -37,19 +37,19 @@ public: //------------------------------------------------------------------ /// Add a module to the list of modules to search. /// - /// @param[in] module + /// \param[in] module /// The path to the exact module to be loaded. E.g., if the desired /// module is std.io, then this should be { "std", "io" }. /// - /// @param[in] exported_modules + /// \param[in] exported_modules /// If non-NULL, a pointer to a vector to populate with the ID of every /// module that is re-exported by the specified module. /// - /// @param[in] error_stream + /// \param[in] error_stream /// A stream to populate with the output of the Clang parser when /// it tries to load the module. /// - /// @return + /// \return /// True if the module could be loaded; false if not. If the /// compiler encountered a fatal error during a previous module /// load, then this will always return false for this ModuleImporter. @@ -62,18 +62,18 @@ public: /// Add all modules referred to in a given compilation unit to the list /// of modules to search. /// - /// @param[in] cu + /// \param[in] cu /// The compilation unit to scan for imported modules. /// - /// @param[in] exported_modules + /// \param[in] exported_modules /// A vector to populate with the ID of each module loaded (directly /// and via re-exports) in this way. /// - /// @param[in] error_stream + /// \param[in] error_stream /// A stream to populate with the output of the Clang parser when /// it tries to load the modules. /// - /// @return + /// \return /// True if all modules referred to by the compilation unit could be /// loaded; false if one could not be loaded. If the compiler /// encountered a fatal error during a previous module @@ -87,12 +87,12 @@ public: /// Enumerate all the macros that are defined by a given set of modules /// that are already imported. /// - /// @param[in] modules + /// \param[in] modules /// The unique IDs for all modules to query. Later modules have higher /// priority, just as if you @imported them in that order. This matters /// if module A #defines a macro and module B #undefs it. /// - /// @param[in] handler + /// \param[in] handler /// A function to call with the text of each #define (including the /// #define directive). #undef directives are not included; we simply /// elide any corresponding #define. If this function returns true, @@ -107,10 +107,10 @@ public: /// LLDB uses this to decide whether to try to find the modules loaded /// by a given compile unit. /// - /// @param[in] language + /// \param[in] language /// The language to query for. /// - /// @return + /// \return /// True if Clang has modules for the given language. //------------------------------------------------------------------ static bool LanguageSupportsClangModules(lldb::LanguageType language); diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h index 2b5e6de3da7..77ecbe71d2e 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h @@ -19,7 +19,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ClangPersistentVariables ClangPersistentVariables.h +/// \class ClangPersistentVariables ClangPersistentVariables.h /// "lldb/Expression/ClangPersistentVariables.h" Manages persistent values /// that need to be preserved between expression invocations. /// diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp index 10d76d5a23a..fc71c4a9337 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.cpp @@ -622,18 +622,18 @@ bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager, /// Converts an absolute position inside a given code string into /// a column/line pair. /// -/// @param[in] abs_pos +/// \param[in] abs_pos /// A absolute position in the code string that we want to convert /// to a column/line pair. /// -/// @param[in] code +/// \param[in] code /// A multi-line string usually representing source code. /// -/// @param[out] line +/// \param[out] line /// The line in the code that contains the given absolute position. /// The first line in the string is indexed as 1. /// -/// @param[out] column +/// \param[out] column /// The column in the line that contains the absolute position. /// The first character in a line is indexed as 0. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h index 2f9a7238b4c..dd50b83b20c 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h @@ -29,7 +29,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ClangUserExpression ClangUserExpression.h +/// \class ClangUserExpression ClangUserExpression.h /// "lldb/Expression/ClangUserExpression.h" Encapsulates a single expression /// for use with Clang /// @@ -68,7 +68,7 @@ public: /// Return the object that the parser should allow to access ASTs. May be /// NULL if the ASTs do not need to be transformed. /// - /// @param[in] passthrough + /// \param[in] passthrough /// The ASTConsumer that the returned transformer should send /// the ASTs to after transformation. //------------------------------------------------------------------ @@ -91,23 +91,23 @@ public: //------------------------------------------------------------------ /// Constructor /// - /// @param[in] expr + /// \param[in] expr /// The expression to parse. /// - /// @param[in] expr_prefix + /// \param[in] expr_prefix /// If non-NULL, a C string containing translation-unit level /// definitions to be included when the expression is parsed. /// - /// @param[in] language + /// \param[in] language /// If not eLanguageTypeUnknown, a language to use when parsing /// the expression. Currently restricted to those languages /// supported by Clang. /// - /// @param[in] desired_type + /// \param[in] desired_type /// If not eResultTypeAny, the type to use for the expression /// result. /// - /// @param[in] ctx_obj + /// \param[in] ctx_obj /// The object (if any) in which context the expression /// must be evaluated. For details see the comment to /// `UserExpression::Evaluate`. @@ -123,22 +123,22 @@ public: //------------------------------------------------------------------ /// Parse the expression /// - /// @param[in] diagnostic_manager + /// \param[in] diagnostic_manager /// A diagnostic manager to report parse errors and warnings to. /// - /// @param[in] exe_ctx + /// \param[in] exe_ctx /// The execution context to use when looking up entities that /// are needed for parsing (locations of functions, types of /// variables, persistent variables, etc.) /// - /// @param[in] execution_policy + /// \param[in] execution_policy /// Determines whether interpretation is possible or mandatory. /// - /// @param[in] keep_result_in_memory + /// \param[in] keep_result_in_memory /// True if the resulting persistent variable should reside in /// target memory, if applicable. /// - /// @return + /// \return /// True on success (no errors); false otherwise. //------------------------------------------------------------------ bool Parse(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp index e1d1fdd757a..b53db7afa4b 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.cpp @@ -32,10 +32,10 @@ using namespace lldb_private; //------------------------------------------------------------------ /// Constructor /// -/// @param[in] text +/// \param[in] text /// The text of the function. Must be a full translation unit. /// -/// @param[in] name +/// \param[in] name /// The name of the function, as used in the text. //------------------------------------------------------------------ ClangUtilityFunction::ClangUtilityFunction(ExecutionContextScope &exe_scope, @@ -51,13 +51,13 @@ ClangUtilityFunction::~ClangUtilityFunction() {} //------------------------------------------------------------------ /// Install the utility function into a process /// -/// @param[in] diagnostic_manager +/// \param[in] diagnostic_manager /// A diagnostic manager to report errors and warnings to. /// -/// @param[in] exe_ctx +/// \param[in] exe_ctx /// The execution context to install the utility function to. /// -/// @return +/// \return /// True on success (no errors); false otherwise. //------------------------------------------------------------------ bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h index 48e13503417..aa5cb95e6e5 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h @@ -23,7 +23,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class ClangUtilityFunction ClangUtilityFunction.h +/// \class ClangUtilityFunction ClangUtilityFunction.h /// "lldb/Expression/ClangUtilityFunction.h" Encapsulates a single expression /// for use with Clang /// @@ -58,7 +58,7 @@ public: /// Return the object that the parser should allow to access ASTs. May be /// NULL if the ASTs do not need to be transformed. /// - /// @param[in] passthrough + /// \param[in] passthrough /// The ASTConsumer that the returned transformer should send /// the ASTs to after transformation. //------------------------------------------------------------------ @@ -73,10 +73,10 @@ public: //------------------------------------------------------------------ /// Constructor /// - /// @param[in] text + /// \param[in] text /// The text of the function. Must be a full translation unit. /// - /// @param[in] name + /// \param[in] name /// The name of the function, as used in the text. //------------------------------------------------------------------ ClangUtilityFunction(ExecutionContextScope &exe_scope, const char *text, diff --git a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h index 137a14edbbc..de3e1457703 100644 --- a/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h +++ b/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h @@ -44,7 +44,7 @@ class IRMemoryMap; } //---------------------------------------------------------------------- -/// @class IRForTarget IRForTarget.h "lldb/Expression/IRForTarget.h" +/// \class IRForTarget IRForTarget.h "lldb/Expression/IRForTarget.h" /// Transforms the IR for a function to run in the target /// /// Once an expression has been parsed and converted to IR, it can run in two @@ -63,32 +63,32 @@ public: //------------------------------------------------------------------ /// Constructor /// - /// @param[in] decl_map + /// \param[in] decl_map /// The list of externally-referenced variables for the expression, /// for use in looking up globals and allocating the argument /// struct. See the documentation for ClangExpressionDeclMap. /// - /// @param[in] resolve_vars + /// \param[in] resolve_vars /// True if the external variable references (including persistent /// variables) should be resolved. If not, only external functions /// are resolved. /// - /// @param[in] execution_policy + /// \param[in] execution_policy /// Determines whether an IR interpreter can be used to statically /// evaluate the expression. /// - /// @param[in] const_result + /// \param[in] const_result /// This variable is populated with the statically-computed result /// of the function, if it has no side-effects and the result can /// be computed statically. /// - /// @param[in] execution_unit + /// \param[in] execution_unit /// The holder for raw data associated with the expression. /// - /// @param[in] error_stream + /// \param[in] error_stream /// If non-NULL, a stream on which errors can be printed. /// - /// @param[in] func_name + /// \param[in] func_name /// The name of the function to prepare for execution in the target. //------------------------------------------------------------------ IRForTarget(lldb_private::ClangExpressionDeclMap *decl_map, bool resolve_vars, @@ -106,16 +106,16 @@ public: /// /// Implementation of the llvm::ModulePass::runOnModule() function. /// - /// @param[in] llvm_module + /// \param[in] llvm_module /// The module to run on. This module is searched for the function /// $__lldb_expr, and that function is passed to the passes one by /// one. /// - /// @param[in] interpreter_error + /// \param[in] interpreter_error /// An error. If the expression fails to be interpreted, this error /// is set to a reason why. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool runOnModule(llvm::Module &llvm_module) override; @@ -142,10 +142,10 @@ private: /// Ensures that the current function's linkage is set to external. /// Otherwise the JIT may not return an address for it. /// - /// @param[in] llvm_function + /// \param[in] llvm_function /// The function whose linkage is to be fixed. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool FixFunctionLinkage(llvm::Function &llvm_function); @@ -158,13 +158,13 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] llvm_module + /// \param[in] llvm_module /// The module currently being processed. /// - /// @param[in] llvm_function + /// \param[in] llvm_function /// The function currently being processed. /// - /// @return + /// \return /// True on success; false otherwise. //------------------------------------------------------------------ bool HasSideEffects(llvm::Function &llvm_function); @@ -178,20 +178,20 @@ private: /// Get the address of a function, and a location to put the complete Value /// of the function if one is available. /// - /// @param[in] function + /// \param[in] function /// The function to find the location of. /// - /// @param[out] ptr + /// \param[out] ptr /// The location of the function in the target. /// - /// @param[out] name + /// \param[out] name /// The resolved name of the function (matters for intrinsics). /// - /// @param[out] value_ptr + /// \param[out] value_ptr /// A variable to put the function's completed Value* in, or NULL /// if the Value* shouldn't be stored anywhere. /// - /// @return + /// \return /// The pointer. //------------------------------------------------------------------ LookupResult GetFunctionAddress(llvm::Function *function, uint64_t &ptr, @@ -208,13 +208,13 @@ private: /// Find the NamedDecl corresponding to a Value. This interface is exposed /// for the IR interpreter. /// - /// @param[in] module + /// \param[in] module /// The module containing metadata to search /// - /// @param[in] global + /// \param[in] global /// The global entity to search for /// - /// @return + /// \return /// The corresponding variable declaration //------------------------------------------------------------------ public: @@ -229,13 +229,13 @@ private: /// constant, assuming it can be evaluated. The result variable will be /// reset to NULL later if the expression has side effects. /// - /// @param[in] initializer + /// \param[in] initializer /// The constant initializer for the variable. /// - /// @param[in] name + /// \param[in] name /// The name of the result variable. /// - /// @param[in] type + /// \param[in] type /// The Clang type of the result variable. //------------------------------------------------------------------ void MaybeSetConstantResult(llvm::Constant *initializer, @@ -247,7 +247,7 @@ private: /// result of the cast. The result variable will be reset to /// NULL latger if the expression has side effects. /// - /// @param[in] type + /// \param[in] type /// The Clang type of the result variable. //------------------------------------------------------------------ void MaybeSetCastResult(lldb_private::TypeFromParser type); @@ -255,10 +255,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] llvm_function + /// \param[in] llvm_function /// The function currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool CreateResultVariable(llvm::Function &llvm_function); @@ -271,14 +271,14 @@ private: //------------------------------------------------------------------ /// Rewrite a single Objective-C constant string. /// - /// @param[in] NSStr + /// \param[in] NSStr /// The constant NSString to be transformed /// - /// @param[in] CStr + /// \param[in] CStr /// The constant C string inside the NSString. This will be /// passed as the bytes argument to CFStringCreateWithBytes. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCConstString(llvm::GlobalVariable *NSStr, @@ -287,7 +287,7 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCConstStrings(); @@ -305,10 +305,10 @@ private: //------------------------------------------------------------------ /// Replace a single selector reference /// - /// @param[in] selector_load + /// \param[in] selector_load /// The load of the statically-allocated selector. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCSelector(llvm::Instruction *selector_load); @@ -316,10 +316,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] basic_block + /// \param[in] basic_block /// The basic block currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCSelectors(llvm::BasicBlock &basic_block); @@ -333,10 +333,10 @@ private: //------------------------------------------------------------------ /// Replace a single old-style class reference /// - /// @param[in] selector_load + /// \param[in] selector_load /// The load of the statically-allocated selector. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCClassReference(llvm::Instruction *class_load); @@ -344,10 +344,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] basic_block + /// \param[in] basic_block /// The basic block currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewriteObjCClassReferences(llvm::BasicBlock &basic_block); @@ -365,10 +365,10 @@ private: //------------------------------------------------------------------ /// Handle a single allocation of a persistent variable /// - /// @param[in] persistent_alloc + /// \param[in] persistent_alloc /// The allocation of the persistent variable. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RewritePersistentAlloc(llvm::Instruction *persistent_alloc); @@ -376,7 +376,7 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] basic_block + /// \param[in] basic_block /// The basic block currently being processed. //------------------------------------------------------------------ bool RewritePersistentAllocs(llvm::BasicBlock &basic_block); @@ -392,13 +392,13 @@ private: //------------------------------------------------------------------ /// Write an initializer to a memory array of assumed sufficient size. /// - /// @param[in] data + /// \param[in] data /// A pointer to the data to write to. /// - /// @param[in] initializer + /// \param[in] initializer /// The initializer itself. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool MaterializeInitializer(uint8_t *data, llvm::Constant *initializer); @@ -406,10 +406,10 @@ private: //------------------------------------------------------------------ /// Move an internal variable into the static allocation section. /// - /// @param[in] global_variable + /// \param[in] global_variable /// The variable. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool MaterializeInternalVariable(llvm::GlobalVariable *global_variable); @@ -417,10 +417,10 @@ private: //------------------------------------------------------------------ /// Handle a single externally-defined variable /// - /// @param[in] value + /// \param[in] value /// The variable. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool MaybeHandleVariable(llvm::Value *value); @@ -428,10 +428,10 @@ private: //------------------------------------------------------------------ /// Handle a single externally-defined symbol /// - /// @param[in] symbol + /// \param[in] symbol /// The symbol. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool HandleSymbol(llvm::Value *symbol); @@ -439,11 +439,11 @@ private: //------------------------------------------------------------------ /// Handle a single externally-defined Objective-C class /// - /// @param[in] classlist_reference + /// \param[in] classlist_reference /// The reference, usually "01L_OBJC_CLASSLIST_REFERENCES_$_n" /// where n (if present) is an index. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool HandleObjCClass(llvm::Value *classlist_reference); @@ -451,10 +451,10 @@ private: //------------------------------------------------------------------ /// Handle all the arguments to a function call /// - /// @param[in] C + /// \param[in] C /// The call instruction. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool MaybeHandleCallArguments(llvm::CallInst *call_inst); @@ -462,10 +462,10 @@ private: //------------------------------------------------------------------ /// Resolve variable references in calls to external functions /// - /// @param[in] basic_block + /// \param[in] basic_block /// The basic block currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool ResolveCalls(llvm::BasicBlock &basic_block); @@ -474,10 +474,10 @@ private: /// Remove calls to __cxa_atexit, which should never be generated by /// expressions. /// - /// @param[in] call_inst + /// \param[in] call_inst /// The call instruction. /// - /// @return + /// \return /// True if the scan was successful; false if some operation /// failed //------------------------------------------------------------------ @@ -486,10 +486,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] basic_block + /// \param[in] basic_block /// The function currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool ResolveExternals(llvm::Function &llvm_function); @@ -504,7 +504,7 @@ private: //------------------------------------------------------------------ /// Rewrite a load to a guard variable to return constant 0. /// - /// @param[in] guard_load + /// \param[in] guard_load /// The load instruction to zero out. //------------------------------------------------------------------ void TurnGuardLoadIntoZero(llvm::Instruction *guard_load); @@ -512,10 +512,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] basic_block + /// \param[in] basic_block /// The basic block currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool RemoveGuards(llvm::BasicBlock &basic_block); @@ -530,10 +530,10 @@ private: //------------------------------------------------------------------ /// The top-level pass implementation /// - /// @param[in] llvm_function + /// \param[in] llvm_function /// The function currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool ReplaceVariables(llvm::Function &llvm_function); @@ -598,10 +598,10 @@ private: /// instructions replace the constant uses, so UnfoldConstant calls itself /// recursively for those. /// - /// @param[in] llvm_function + /// \param[in] llvm_function /// The function currently being processed. /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ @@ -632,13 +632,13 @@ private: /// offset. This typically happens after inserting data into /// m_data_allocator. /// - /// @param[in] type + /// \param[in] type /// The type of the value being loaded. /// - /// @param[in] offset + /// \param[in] offset /// The offset of the value from the base of m_data_allocator. /// - /// @return + /// \return /// The Constant for the reference, usually a ConstantExpr. //------------------------------------------------------------------ llvm::Constant *BuildRelocation(llvm::Type *type, uint64_t offset); @@ -647,10 +647,10 @@ private: /// Commit the allocation in m_data_allocator and use its final location to /// replace m_reloc_placeholder. /// - /// @param[in] module + /// \param[in] module /// The module that m_data_allocator resides in /// - /// @return + /// \return /// True on success; false otherwise //------------------------------------------------------------------ bool CompleteDataAllocation(); diff --git a/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h b/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h index 49378530799..2a2b13243fe 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h +++ b/lldb/source/Plugins/ObjectFile/ELF/ELFHeader.h @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// // -/// @file +/// \file /// Generic structures and typedefs for ELF files. /// /// This file provides definitions for the various entities comprising an ELF @@ -32,7 +32,7 @@ class DataExtractor; namespace elf { //------------------------------------------------------------------------------ -/// @name ELF type definitions. +/// \name ELF type definitions. /// /// Types used to represent the various components of ELF structures. All /// types are signed or unsigned integral types wide enough to hold values @@ -50,7 +50,7 @@ typedef int64_t elf_sxword; //@} //------------------------------------------------------------------------------ -/// @class ELFHeader +/// \class ELFHeader /// Generic representation of an ELF file header. /// /// This object is used to identify the general attributes on an ELF file and @@ -83,7 +83,7 @@ struct ELFHeader { //-------------------------------------------------------------------------- /// Returns true if this is a 32 bit ELF file header. /// - /// @return + /// \return /// True if this is a 32 bit ELF file header. bool Is32Bit() const { return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS32; @@ -92,7 +92,7 @@ struct ELFHeader { //-------------------------------------------------------------------------- /// Returns true if this is a 64 bit ELF file header. /// - /// @return + /// \return /// True if this is a 64 bit ELF file header. bool Is64Bit() const { return e_ident[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS64; @@ -101,7 +101,7 @@ struct ELFHeader { //-------------------------------------------------------------------------- /// The byte order of this ELF file header. /// - /// @return + /// \return /// The byte order of this ELF file as described by the header. lldb::ByteOrder GetByteOrder() const; @@ -112,7 +112,7 @@ struct ELFHeader { //-------------------------------------------------------------------------- /// Check if there should be header extension in section header #0 /// - /// @return + /// \return /// True if parsing the ELFHeader requires reading header extension /// and false otherwise. bool HasHeaderExtension() const; @@ -122,15 +122,15 @@ struct ELFHeader { /// data extractor with the address size and byte order attributes as /// defined by the header. /// - /// @param[in,out] data + /// \param[in,out] data /// The DataExtractor to read from. Updated with the address size and /// byte order attributes appropriate to this header. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFHeader was successfully read and false /// otherwise. bool Parse(lldb_private::DataExtractor &data, lldb::offset_t *offset); @@ -139,7 +139,7 @@ struct ELFHeader { /// Examines at most EI_NIDENT bytes starting from the given pointer and /// determines if the magic ELF identification exists. /// - /// @return + /// \return /// True if the given sequence of bytes identifies an ELF file. static bool MagicBytesMatch(const uint8_t *magic); @@ -149,7 +149,7 @@ struct ELFHeader { /// should only be called on an pointer for which MagicBytesMatch returns /// true. /// - /// @return + /// \return /// The number of bytes forming an address in the ELF file (either 4 or /// 8), else zero if the address size could not be determined. static unsigned AddressSizeInBytes(const uint8_t *magic); @@ -160,13 +160,13 @@ private: /// Parse an ELFHeader header extension entry. This method is called by /// Parse(). /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. void ParseHeaderExtension(lldb_private::DataExtractor &data); }; //------------------------------------------------------------------------------ -/// @class ELFSectionHeader +/// \class ELFSectionHeader /// Generic representation of an ELF section header. struct ELFSectionHeader { elf_word sh_name; ///< Section name string index. @@ -186,22 +186,22 @@ struct ELFSectionHeader { /// Parse an ELFSectionHeader entry from the given DataExtracter starting at /// position \p offset. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFSectionHeader was successfully read and false /// otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); }; //------------------------------------------------------------------------------ -/// @class ELFProgramHeader +/// \class ELFProgramHeader /// Generic representation of an ELF program header. struct ELFProgramHeader { elf_word p_type; ///< Type of program segment. @@ -219,22 +219,22 @@ struct ELFProgramHeader { /// position \p offset. The address size of the DataExtractor determines if /// a 32 or 64 bit object is to be parsed. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFProgramHeader was successfully read and false /// otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); }; //------------------------------------------------------------------------------ -/// @class ELFSymbol +/// \class ELFSymbol /// Represents a symbol within an ELF symbol table. struct ELFSymbol { elf_addr st_value; ///< Absolute or relocatable address. @@ -269,15 +269,15 @@ struct ELFSymbol { /// position \p offset. The address size of the DataExtractor determines if /// a 32 or 64 bit object is to be parsed. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFSymbol was successfully read and false otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); @@ -287,7 +287,7 @@ struct ELFSymbol { }; //------------------------------------------------------------------------------ -/// @class ELFDynamic +/// \class ELFDynamic /// Represents an entry in an ELF dynamic table. struct ELFDynamic { elf_sxword d_tag; ///< Type of dynamic table entry. @@ -302,22 +302,22 @@ struct ELFDynamic { /// position \p offset. The address size of the DataExtractor determines if /// a 32 or 64 bit object is to be parsed. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFDynamic entry was successfully read and false /// otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); }; //------------------------------------------------------------------------------ -/// @class ELFRel +/// \class ELFRel /// Represents a relocation entry with an implicit addend. struct ELFRel { elf_addr r_offset; ///< Address of reference. @@ -329,15 +329,15 @@ struct ELFRel { /// \p offset. The address size of the DataExtractor determines if a 32 or /// 64 bit object is to be parsed. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFRel entry was successfully read and false otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); @@ -359,7 +359,7 @@ struct ELFRel { }; //------------------------------------------------------------------------------ -/// @class ELFRela +/// \class ELFRela /// Represents a relocation entry with an explicit addend. struct ELFRela { elf_addr r_offset; ///< Address of reference. @@ -372,15 +372,15 @@ struct ELFRela { /// \p offset. The address size of the DataExtractor determines if a 32 or /// 64 bit object is to be parsed. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. The address size of the extractor /// determines if a 32 or 64 bit object should be read. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFRela entry was successfully read and false otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp index ca2da5a72a5..53c6811cd17 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp @@ -117,7 +117,7 @@ const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02; #define NT_METAG_TLS 0x502 //===----------------------------------------------------------------------===// -/// @class ELFRelocation +/// \class ELFRelocation /// Generic wrapper for ELFRel and ELFRela. /// /// This helper class allows us to parse both ELFRel and ELFRela relocation @@ -127,7 +127,7 @@ public: /// Constructs an ELFRelocation entry with a personality as given by @p /// type. /// - /// @param type Either DT_REL or DT_RELA. Any other value is invalid. + /// \param type Either DT_REL or DT_RELA. Any other value is invalid. ELFRelocation(unsigned type); ~ELFRelocation(); diff --git a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h index 668cfa36566..b11a4bdbe17 100644 --- a/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h +++ b/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h @@ -33,14 +33,14 @@ struct ELFNote { /// Parse an ELFNote entry from the given DataExtractor starting at position /// \p offset. /// - /// @param[in] data + /// \param[in] data /// The DataExtractor to read from. /// - /// @param[in,out] offset + /// \param[in,out] offset /// Pointer to an offset in the data. On return the offset will be /// advanced by the number of bytes read. /// - /// @return + /// \return /// True if the ELFRel entry was successfully read and false otherwise. bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset); @@ -50,7 +50,7 @@ struct ELFNote { }; //------------------------------------------------------------------------------ -/// @class ObjectFileELF +/// \class ObjectFileELF /// Generic ELF object file reader. /// /// This class provides a generic ELF (32/64 bit) reader plugin implementing @@ -330,7 +330,7 @@ private: /// Returns the section header with the given id or NULL. const ELFSectionHeaderInfo *GetSectionHeaderByIndex(lldb::user_id_t id); - /// @name ELF header dump routines + /// \name ELF header dump routines //@{ static void DumpELFHeader(lldb_private::Stream *s, const elf::ELFHeader &header); @@ -342,7 +342,7 @@ private: elf::elf_half e_type); //@} - /// @name ELF program header dump routines + /// \name ELF program header dump routines //@{ void DumpELFProgramHeaders(lldb_private::Stream *s); @@ -356,7 +356,7 @@ private: elf::elf_word p_flags); //@} - /// @name ELF section header dump routines + /// \name ELF section header dump routines //@{ void DumpELFSectionHeaders(lldb_private::Stream *s); diff --git a/lldb/source/Plugins/Process/Darwin/DarwinProcessLauncher.h b/lldb/source/Plugins/Process/Darwin/DarwinProcessLauncher.h index 004ff19dd9f..0e65b56a143 100644 --- a/lldb/source/Plugins/Process/Darwin/DarwinProcessLauncher.h +++ b/lldb/source/Plugins/Process/Darwin/DarwinProcessLauncher.h @@ -27,15 +27,15 @@ namespace darwin_process_launcher { // ============================================================================= /// Launches a process for debugging. /// -/// @param[inout] launch_info +/// \param[inout] launch_info /// Specifies details about the process to launch (e.g. path, architecture, /// etc.). On output, includes the launched ProcessID (pid). /// -/// @param[out] pty_master_fd +/// \param[out] pty_master_fd /// Returns the master side of the pseudo-terminal used to communicate /// with stdin/stdout from the launched process. May be nullptr. /// -/// @param[out] launch_flavor +/// \param[out] launch_flavor /// Contains the launch flavor used when launching the process. // ============================================================================= Status diff --git a/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h index b55c1728c6a..1b50a8c5cf8 100644 --- a/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h +++ b/lldb/source/Plugins/Process/Darwin/NativeProcessDarwin.h @@ -40,7 +40,7 @@ class Scalar; namespace process_darwin { -/// @class NativeProcessDarwin +/// \class NativeProcessDarwin /// Manages communication with the inferior (debugee) process. /// /// Upon construction, this class prepares and launches an inferior process @@ -208,15 +208,15 @@ private: /// listener to the inferior exception port, ptracing the process, and the /// like. /// - /// @param[in] launch_flavor + /// \param[in] launch_flavor /// The launch flavor that was used to launch the process. /// - /// @param[in] main_loop + /// \param[in] main_loop /// The main loop that will run the process monitor. Work /// that needs to be done (e.g. reading files) gets registered /// here along with callbacks to process the work. /// - /// @return + /// \return /// Any error that occurred during the aforementioned /// operations. Failure here will force termination of the /// launched process and debugging session. @@ -317,7 +317,7 @@ private: Status FixupBreakpointPCAsNeeded(NativeThreadDarwin &thread); /// Writes a siginfo_t structure corresponding to the given thread - /// ID to the memory region pointed to by @p siginfo. + /// ID to the memory region pointed to by \p siginfo. Status GetSignalInfo(lldb::tid_t tid, void *siginfo); /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) diff --git a/lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.h b/lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.h index 160e18d3589..9f53643ff71 100644 --- a/lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.h +++ b/lldb/source/Plugins/Process/Darwin/NativeThreadDarwin.h @@ -72,11 +72,11 @@ private: // Interface for friend classes // ----------------------------------------------------------------- - /// Resumes the thread. If @p signo is anything but + /// Resumes the thread. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. Status Resume(uint32_t signo); - /// Single steps the thread. If @p signo is anything but + /// Single steps the thread. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. Status SingleStep(uint32_t signo); @@ -121,7 +121,7 @@ private: // ------------------------------------------------------------------------- /// Return the mach thread port number for this thread. /// - /// @return + /// \return /// The mach port number for this thread. Returns NULL_THREAD /// when the thread is invalid. // ------------------------------------------------------------------------- diff --git a/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h b/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h index a2fe76714ba..88fb7f31fe0 100644 --- a/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h +++ b/lldb/source/Plugins/Process/FreeBSD/POSIXStopInfo.h @@ -15,7 +15,7 @@ #include <string> //===----------------------------------------------------------------------===// -/// @class POSIXStopInfo +/// \class POSIXStopInfo /// Simple base class for all POSIX-specific StopInfo objects. /// class POSIXStopInfo : public lldb_private::StopInfo { @@ -25,7 +25,7 @@ public: }; //===----------------------------------------------------------------------===// -/// @class POSIXLimboStopInfo +/// \class POSIXLimboStopInfo /// Represents the stop state of a process ready to exit. /// class POSIXLimboStopInfo : public POSIXStopInfo { @@ -44,7 +44,7 @@ public: }; //===----------------------------------------------------------------------===// -/// @class POSIXNewThreadStopInfo +/// \class POSIXNewThreadStopInfo /// Represents the stop state of process when a new thread is spawned. /// diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp index dfebbcca283..440b1274e89 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp @@ -196,7 +196,7 @@ static bool EnsureFDFlags(int fd, int flags, Status &error) { } //------------------------------------------------------------------------------ -/// @class Operation +/// \class Operation /// Represents a ProcessMonitor operation. /// /// Under FreeBSD, it is not possible to ptrace() from any other thread but @@ -214,7 +214,7 @@ public: }; //------------------------------------------------------------------------------ -/// @class ReadOperation +/// \class ReadOperation /// Implements ProcessMonitor::ReadMemory. class ReadOperation : public Operation { public: @@ -240,7 +240,7 @@ void ReadOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class WriteOperation +/// \class WriteOperation /// Implements ProcessMonitor::WriteMemory. class WriteOperation : public Operation { public: @@ -266,7 +266,7 @@ void WriteOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ReadRegOperation +/// \class ReadRegOperation /// Implements ProcessMonitor::ReadRegisterValue. class ReadRegOperation : public Operation { public: @@ -306,7 +306,7 @@ void ReadRegOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class WriteRegOperation +/// \class WriteRegOperation /// Implements ProcessMonitor::WriteRegisterValue. class WriteRegOperation : public Operation { public: @@ -339,7 +339,7 @@ void WriteRegOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ReadDebugRegOperation +/// \class ReadDebugRegOperation /// Implements ProcessMonitor::ReadDebugRegisterValue. class ReadDebugRegOperation : public Operation { public: @@ -374,7 +374,7 @@ void ReadDebugRegOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class WriteDebugRegOperation +/// \class WriteDebugRegOperation /// Implements ProcessMonitor::WriteDebugRegisterValue. class WriteDebugRegOperation : public Operation { public: @@ -407,7 +407,7 @@ void WriteDebugRegOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ReadGPROperation +/// \class ReadGPROperation /// Implements ProcessMonitor::ReadGPR. class ReadGPROperation : public Operation { public: @@ -434,7 +434,7 @@ void ReadGPROperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ReadFPROperation +/// \class ReadFPROperation /// Implements ProcessMonitor::ReadFPR. class ReadFPROperation : public Operation { public: @@ -457,7 +457,7 @@ void ReadFPROperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class WriteGPROperation +/// \class WriteGPROperation /// Implements ProcessMonitor::WriteGPR. class WriteGPROperation : public Operation { public: @@ -480,7 +480,7 @@ void WriteGPROperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class WriteFPROperation +/// \class WriteFPROperation /// Implements ProcessMonitor::WriteFPR. class WriteFPROperation : public Operation { public: @@ -503,7 +503,7 @@ void WriteFPROperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ResumeOperation +/// \class ResumeOperation /// Implements ProcessMonitor::Resume. class ResumeOperation : public Operation { public: @@ -534,7 +534,7 @@ void ResumeOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class SingleStepOperation +/// \class SingleStepOperation /// Implements ProcessMonitor::SingleStep. class SingleStepOperation : public Operation { public: @@ -562,7 +562,7 @@ void SingleStepOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class LwpInfoOperation +/// \class LwpInfoOperation /// Implements ProcessMonitor::GetLwpInfo. class LwpInfoOperation : public Operation { public: @@ -591,7 +591,7 @@ void LwpInfoOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class ThreadSuspendOperation +/// \class ThreadSuspendOperation /// Implements ProcessMonitor::ThreadSuspend. class ThreadSuspendOperation : public Operation { public: @@ -611,7 +611,7 @@ void ThreadSuspendOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class EventMessageOperation +/// \class EventMessageOperation /// Implements ProcessMonitor::GetEventMessage. class EventMessageOperation : public Operation { public: @@ -641,7 +641,7 @@ void EventMessageOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class KillOperation +/// \class KillOperation /// Implements ProcessMonitor::Kill. class KillOperation : public Operation { public: @@ -663,7 +663,7 @@ void KillOperation::Execute(ProcessMonitor *monitor) { } //------------------------------------------------------------------------------ -/// @class DetachOperation +/// \class DetachOperation /// Implements ProcessMonitor::Detach. class DetachOperation : public Operation { public: diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h index 597f741c8a3..cc9c006c506 100644 --- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h +++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h @@ -27,7 +27,7 @@ class Scalar; class ProcessFreeBSD; class Operation; -/// @class ProcessMonitor +/// \class ProcessMonitor /// Manages communication with the inferior (debugee) process. /// /// Upon construction, this class prepares and launches an inferior process @@ -76,14 +76,14 @@ public: /// -1. int GetTerminalFD() const { return m_terminal_fd; } - /// Reads @p size bytes from address @vm_adder in the inferior process + /// Reads \p size bytes from address @vm_adder in the inferior process /// address space. /// /// This method is provided to implement Process::DoReadMemory. size_t ReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, lldb_private::Status &error); - /// Writes @p size bytes from address @p vm_adder in the inferior process + /// Writes \p size bytes from address \p vm_adder in the inferior process /// address space. /// /// This method is provided to implement Process::DoWriteMemory. @@ -151,7 +151,7 @@ public: size_t GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids); /// Writes a ptrace_lwpinfo structure corresponding to the given thread ID - /// to the memory region pointed to by @p lwpinfo. + /// to the memory region pointed to by \p lwpinfo. bool GetLwpInfo(lldb::tid_t tid, void *lwpinfo, int &error_no); /// Suspends or unsuspends a thread prior to process resume or step. @@ -162,11 +162,11 @@ public: /// message. bool GetEventMessage(lldb::tid_t tid, unsigned long *message); - /// Resumes the process. If @p signo is anything but + /// Resumes the process. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process. bool Resume(lldb::tid_t unused, uint32_t signo); - /// Single steps the process. If @p signo is anything but + /// Single steps the process. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the process. bool SingleStep(lldb::tid_t unused, uint32_t signo); @@ -208,7 +208,7 @@ private: lldb_private::Status m_error; // Set if process operation failed. }; - /// @class LauchArgs + /// \class LauchArgs /// /// Simple structure to pass data to the thread responsible for launching a /// child process. diff --git a/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h b/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h index 085c169b45a..c9bfe0948e9 100644 --- a/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h +++ b/lldb/source/Plugins/Process/FreeBSD/RegisterContextPOSIX.h @@ -14,7 +14,7 @@ #include "lldb/Utility/ArchSpec.h" //------------------------------------------------------------------------------ -/// @class POSIXBreakpointProtocol +/// \class POSIXBreakpointProtocol /// /// Extends RegisterClass with a few virtual operations useful on POSIX. class POSIXBreakpointProtocol { @@ -27,7 +27,7 @@ public: /// implementation simply returns true for architectures which do not /// require any update. /// - /// @return + /// \return /// True if the operation succeeded and false otherwise. virtual bool UpdateAfterBreakpoint() = 0; diff --git a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h index 184d051fd98..044f16754ff 100644 --- a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h +++ b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h @@ -29,7 +29,7 @@ class Status; class Scalar; namespace process_linux { -/// @class NativeProcessLinux +/// \class NativeProcessLinux /// Manages communication with the inferior (debugee) process. /// /// Upon construction, this class prepares and launches an inferior process @@ -182,7 +182,7 @@ private: NativeThreadLinux &AddThread(lldb::tid_t thread_id); /// Writes a siginfo_t structure corresponding to the given thread ID to the - /// memory region pointed to by @p siginfo. + /// memory region pointed to by \p siginfo. Status GetSignalInfo(lldb::tid_t tid, void *siginfo); /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG) diff --git a/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h b/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h index 84480d36275..e92908baeb5 100644 --- a/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h +++ b/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h @@ -58,11 +58,11 @@ private: // Interface for friend classes // --------------------------------------------------------------------- - /// Resumes the thread. If @p signo is anything but + /// Resumes the thread. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. Status Resume(uint32_t signo); - /// Single steps the thread. If @p signo is anything but + /// Single steps the thread. If \p signo is anything but /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread. Status SingleStep(uint32_t signo); diff --git a/lldb/source/Plugins/Process/Linux/ProcessorTrace.h b/lldb/source/Plugins/Process/Linux/ProcessorTrace.h index 6078141ce77..d105555705c 100644 --- a/lldb/source/Plugins/Process/Linux/ProcessorTrace.h +++ b/lldb/source/Plugins/Process/Linux/ProcessorTrace.h @@ -118,17 +118,17 @@ public: // --------------------------------------------------------------------- /// Read data from a cyclic buffer /// - /// @param[in] [out] buf + /// \param[in] [out] buf /// Destination buffer, the buffer will be truncated to written size. /// - /// @param[in] src + /// \param[in] src /// Source buffer which must be a cyclic buffer. /// - /// @param[in] src_cyc_index + /// \param[in] src_cyc_index /// The index pointer (start of the valid data in the cyclic /// buffer). /// - /// @param[in] offset + /// \param[in] offset /// The offset to begin reading the data in the cyclic buffer. // --------------------------------------------------------------------- static void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst, diff --git a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h index 50c299a74ac..2e7b62d2ae2 100644 --- a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h +++ b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h @@ -18,7 +18,7 @@ namespace lldb_private { namespace process_netbsd { -/// @class NativeProcessNetBSD +/// \class NativeProcessNetBSD /// Manages communication with the inferior (debugee) process. /// /// Upon construction, this class prepares and launches an inferior process diff --git a/lldb/source/Plugins/Process/POSIX/ProcessMessage.h b/lldb/source/Plugins/Process/POSIX/ProcessMessage.h index c3d8e95a6c4..d9c10caaa95 100644 --- a/lldb/source/Plugins/Process/POSIX/ProcessMessage.h +++ b/lldb/source/Plugins/Process/POSIX/ProcessMessage.h @@ -44,33 +44,33 @@ public: lldb::tid_t GetTID() const { return m_tid; } - /// Indicates that the process @p pid has successfully attached. + /// Indicates that the process \p pid has successfully attached. static ProcessMessage Attach(lldb::pid_t pid) { return ProcessMessage(pid, eAttachMessage); } - /// Indicates that the thread @p tid is about to exit with status @p status. + /// Indicates that the thread \p tid is about to exit with status \p status. static ProcessMessage Limbo(lldb::tid_t tid, int status) { return ProcessMessage(tid, eLimboMessage, status); } - /// Indicates that the thread @p tid had the signal @p signum delivered. + /// Indicates that the thread \p tid had the signal \p signum delivered. static ProcessMessage Signal(lldb::tid_t tid, int signum) { return ProcessMessage(tid, eSignalMessage, signum); } - /// Indicates that a signal @p signum generated by the debugging process was - /// delivered to the thread @p tid. + /// Indicates that a signal \p signum generated by the debugging process was + /// delivered to the thread \p tid. static ProcessMessage SignalDelivered(lldb::tid_t tid, int signum) { return ProcessMessage(tid, eSignalDeliveredMessage, signum); } - /// Indicates that the thread @p tid encountered a trace point. + /// Indicates that the thread \p tid encountered a trace point. static ProcessMessage Trace(lldb::tid_t tid) { return ProcessMessage(tid, eTraceMessage); } - /// Indicates that the thread @p tid encountered a break point. + /// Indicates that the thread \p tid encountered a break point. static ProcessMessage Break(lldb::tid_t tid) { return ProcessMessage(tid, eBreakpointMessage); } @@ -79,7 +79,7 @@ public: return ProcessMessage(tid, eWatchpointMessage, 0, wp_addr); } - /// Indicates that the thread @p tid crashed. + /// Indicates that the thread \p tid crashed. static ProcessMessage Crash(lldb::pid_t pid, CrashReason reason, int signo, lldb::addr_t fault_addr) { ProcessMessage message(pid, eCrashMessage, signo, fault_addr); @@ -87,18 +87,18 @@ public: return message; } - /// Indicates that the thread @p child_tid was spawned. + /// Indicates that the thread \p child_tid was spawned. static ProcessMessage NewThread(lldb::tid_t parent_tid, lldb::tid_t child_tid) { return ProcessMessage(parent_tid, eNewThreadMessage, child_tid); } - /// Indicates that the thread @p tid is about to exit with status @p status. + /// Indicates that the thread \p tid is about to exit with status \p status. static ProcessMessage Exit(lldb::tid_t tid, int status) { return ProcessMessage(tid, eExitMessage, status); } - /// Indicates that the thread @p pid has exec'd. + /// Indicates that the thread \p pid has exec'd. static ProcessMessage Exec(lldb::tid_t tid) { return ProcessMessage(tid, eExecMessage); } diff --git a/lldb/source/Plugins/Process/Utility/HistoryThread.h b/lldb/source/Plugins/Process/Utility/HistoryThread.h index b3c9a4b3d98..cbbb3fc3eef 100644 --- a/lldb/source/Plugins/Process/Utility/HistoryThread.h +++ b/lldb/source/Plugins/Process/Utility/HistoryThread.h @@ -23,7 +23,7 @@ namespace lldb_private { //---------------------------------------------------------------------- -/// @class HistoryThread HistoryThread.h "HistoryThread.h" +/// \class HistoryThread HistoryThread.h "HistoryThread.h" /// A thread object representing a backtrace from a previous point in the /// process execution /// diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h index 0b9bee667cb..06100161c73 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h +++ b/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h @@ -116,7 +116,7 @@ private: /// Given a SymbolContext, determines if this is a trap handler function /// aka asynchronous signal handler. /// - /// @return + /// \return /// Returns true if the SymbolContext is a trap handler. //------------------------------------------------------------------ bool IsTrapHandlerSymbol(lldb_private::Process *process, @@ -163,7 +163,7 @@ private: /// better. This is mostly helping to work around problems where the /// assembly language inspection fails on hand-written assembly code. /// - /// @return + /// \return /// Returns true if a fallback unwindplan was found & was installed. //------------------------------------------------------------------ bool TryFallbackUnwindPlan(); diff --git a/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h b/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h index 96ea4032996..3d8787515bf 100644 --- a/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h +++ b/lldb/source/Plugins/Process/Utility/RegisterInfoInterface.h @@ -16,7 +16,7 @@ namespace lldb_private { ///------------------------------------------------------------------------------ -/// @class RegisterInfoInterface +/// \class RegisterInfoInterface /// /// RegisterInfo interface to patch RegisterInfo structure for archs. ///------------------------------------------------------------------------------ diff --git a/lldb/source/Plugins/Process/Utility/UnwindLLDB.h b/lldb/source/Plugins/Process/Utility/UnwindLLDB.h index 4a9cdcaa4a1..808ef947b66 100644 --- a/lldb/source/Plugins/Process/Utility/UnwindLLDB.h +++ b/lldb/source/Plugins/Process/Utility/UnwindLLDB.h @@ -101,7 +101,7 @@ protected: /// into an array of ConstStrings before it can be used - we only want /// to do that once per thread so it's here in the UnwindLLDB object. /// - /// @return + /// \return /// Vector of ConstStrings of trap handler function names. May be /// empty. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h index a2f42b13713..54f69e8caac 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h @@ -27,7 +27,7 @@ public: // ========================================================================= /// Process asynchronously-received structured data. /// - /// @param[in] data + /// \param[in] data /// The complete data packet, expected to start with JSON-async. // ========================================================================= virtual void HandleAsyncStructuredDataPacket(llvm::StringRef data) = 0; diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h index 84e2c2af747..6cbb44dad99 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h @@ -88,11 +88,11 @@ public: /// Sends a GDB remote protocol 'A' packet that delivers program /// arguments to the remote server. /// - /// @param[in] argv + /// \param[in] argv /// A NULL terminated array of const C strings to use as the /// arguments. /// - /// @return + /// \return /// Zero if the response was "OK", a positive value if the /// the response was "Exx" where xx are two hex digits, or /// -1 if the call is unsupported or any other unexpected @@ -107,11 +107,11 @@ public: /// multiple times in a row in order to pass on the desired /// environment that the inferior should be launched with. /// - /// @param[in] name_equal_value + /// \param[in] name_equal_value /// A NULL terminated C string that contains a single environment /// in the format "NAME=VALUE". /// - /// @return + /// \return /// Zero if the response was "OK", a positive value if the /// the response was "Exx" where xx are two hex digits, or /// -1 if the call is unsupported or any other unexpected @@ -128,15 +128,15 @@ public: //------------------------------------------------------------------ /// Sends a "vAttach:PID" where PID is in hex. /// - /// @param[in] pid + /// \param[in] pid /// A process ID for the remote gdb server to attach to. /// - /// @param[out] response + /// \param[out] response /// The response received from the gdb server. If the return /// value is zero, \a response will contain a stop reply /// packet. /// - /// @return + /// \return /// Zero if the attach was successful, or an error indicating /// an error code. //------------------------------------------------------------------ @@ -146,13 +146,13 @@ public: /// Sends a GDB remote protocol 'I' packet that delivers stdin /// data to the remote process. /// - /// @param[in] data + /// \param[in] data /// A pointer to stdin data. /// - /// @param[in] data_len + /// \param[in] data_len /// The number of bytes available at \a data. /// - /// @return + /// \return /// Zero if the attach was successful, or an error indicating /// an error code. //------------------------------------------------------------------ @@ -162,10 +162,10 @@ public: /// Sets the path to use for stdin/out/err for a process /// that will be launched with the 'A' packet. /// - /// @param[in] path + /// \param[in] path /// The path to use for stdin/out/err /// - /// @return + /// \return /// Zero if the for success, or an error code for failure. //------------------------------------------------------------------ int SetSTDIN(const FileSpec &file_spec); @@ -176,10 +176,10 @@ public: /// Sets the disable ASLR flag to \a enable for a process that will /// be launched with the 'A' packet. /// - /// @param[in] enable + /// \param[in] enable /// A boolean value indicating whether to disable ASLR or not. /// - /// @return + /// \return /// Zero if the for success, or an error code for failure. //------------------------------------------------------------------ int SetDisableASLR(bool enable); @@ -188,10 +188,10 @@ public: /// Sets the DetachOnError flag to \a enable for the process controlled by the /// stub. /// - /// @param[in] enable + /// \param[in] enable /// A boolean value indicating whether to detach on error or not. /// - /// @return + /// \return /// Zero if the for success, or an error code for failure. //------------------------------------------------------------------ int SetDetachOnError(bool enable); @@ -203,10 +203,10 @@ public: /// implements the platform, it will change the current working /// directory for the platform process. /// - /// @param[in] working_dir + /// \param[in] working_dir /// The path to a directory to use when launching our process /// - /// @return + /// \return /// Zero if the for success, or an error code for failure. //------------------------------------------------------------------ int SetWorkingDir(const FileSpec &working_dir); @@ -215,10 +215,10 @@ public: /// Gets the current working directory of a remote platform GDB /// server. /// - /// @param[out] working_dir + /// \param[out] working_dir /// The current working directory on the remote platform. /// - /// @return + /// \return /// Boolean for success //------------------------------------------------------------------ bool GetWorkingDir(FileSpec &working_dir); @@ -462,7 +462,7 @@ public: /// packet. The response is the complete string payload returned /// to the client. /// - /// @return + /// \return /// The string returned by the server to the qSupported query. //------------------------------------------------------------------ const std::string &GetServerSupportedFeatures() const { @@ -485,7 +485,7 @@ public: /// A plugin indicates whether it knows how to handle a type_name. /// If so, it can be used to process the async JSON packet. /// - /// @return + /// \return /// The string returned by the server to the qSupported query. //------------------------------------------------------------------ lldb_private::StructuredData::Array *GetSupportedStructuredDataPlugins(); @@ -493,7 +493,7 @@ public: //------------------------------------------------------------------ /// Configure a StructuredData feature on the remote end. /// - /// @see \b Process::ConfigureStructuredData(...) for details. + /// \see \b Process::ConfigureStructuredData(...) for details. //------------------------------------------------------------------ Status ConfigureRemoteStructuredData(ConstString type_name, diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h index c9400687b3b..d0615869d03 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h @@ -138,7 +138,7 @@ protected: /// server in a situation where the startup code has been provided /// with all the information for a child process to be launched. /// - /// @return + /// \return /// An Status object indicating the success or failure of the /// launch. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h index e26d0591d5e..786910ed93f 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h @@ -47,7 +47,7 @@ public: /// server in a situation where the startup code has been provided /// with all the information for a child process to be launched. /// - /// @return + /// \return /// An Status object indicating the success or failure of the /// launch. //------------------------------------------------------------------ @@ -59,7 +59,7 @@ public: /// This method supports attaching llgs to a process accessible via the /// configured Platform. /// - /// @return + /// \return /// An Status object indicating the success or failure of the /// attach operation. //------------------------------------------------------------------ diff --git a/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h b/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h index f9ddb040c40..d17e3cbe222 100644 --- a/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h +++ b/lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h @@ -42,7 +42,7 @@ public: /// that controls if we always enable it for newly created/attached /// processes. /// - /// @return + /// \return /// True if DarwinLog support is/will be enabled for existing or /// newly launched/attached processes. // ------------------------------------------------------------------------- diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h index 5ace0c7ad47..76575c7cd29 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h @@ -21,7 +21,7 @@ public: //------------------------------------------------------------------ /// Get the data that contains the DIE information for this unit. /// - /// @return + /// \return /// The correct data (.debug_types for DWARF 4 and earlier, and /// .debug_info for DWARF 5 and later) for the DIE information in /// this unit. @@ -31,7 +31,7 @@ public: //------------------------------------------------------------------ /// Get the size in bytes of the header. /// - /// @return + /// \return /// Byte size of the compile unit header //------------------------------------------------------------------ uint32_t GetHeaderByteSize() const override; diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h index 0bfa4c04e47..d5061f6d446 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h @@ -66,14 +66,14 @@ public: /// this DWARFUnit. It could be .debug_info or .debug_types /// depending on where the data for this unit originates. /// - /// @return + /// \return /// The correct data for the DIE information in this unit. //------------------------------------------------------------------ virtual const lldb_private::DWARFDataExtractor &GetData() const = 0; //------------------------------------------------------------------ /// Get the size in bytes of the compile unit header. /// - /// @return + /// \return /// Byte size of the compile unit header //------------------------------------------------------------------ virtual uint32_t GetHeaderByteSize() const = 0; @@ -86,7 +86,7 @@ public: /// In DWARF32 this is just 4 bytes, and DWARF64 it is 12 where 4 /// are 0xFFFFFFFF followed by the actual 64 bit length. /// - /// @return + /// \return /// Byte size of the compile unit header length field //------------------------------------------------------------------ size_t GetLengthByteSize() const { return IsDWARF64() ? 12 : 4; } diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h index 5139fffe672..6f5dddcda23 100644 --- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h +++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h @@ -336,10 +336,10 @@ protected: //------------------------------------------------------------------ /// Convert \a addr from a .o file address, to an executable address. /// - /// @param[in] addr + /// \param[in] addr /// A section offset address from a .o file /// - /// @return + /// \return /// Returns true if \a addr was converted to be an executable /// section/offset address, false otherwise. //------------------------------------------------------------------ @@ -348,13 +348,13 @@ protected: //------------------------------------------------------------------ /// Convert a .o file "file address" to an executable "file address". /// - /// @param[in] oso_symfile + /// \param[in] oso_symfile /// The DWARF symbol file that contains \a oso_file_addr /// - /// @param[in] oso_file_addr + /// \param[in] oso_file_addr /// A .o file "file address" to convert. /// - /// @return + /// \return /// LLDB_INVALID_ADDRESS if \a oso_file_addr is not in the /// linked executable, otherwise a valid "file address" from the /// linked executable that contains the debug map. @@ -367,13 +367,13 @@ protected: /// for a .o file represented by \a oso_symfile, link a new line table /// and return it. /// - /// @param[in] oso_symfile + /// \param[in] oso_symfile /// The DWARF symbol file that produced the \a line_table /// - /// @param[in] addr + /// \param[in] addr /// A section offset address from a .o file /// - /// @return + /// \return /// Returns a valid line table full of linked addresses, or NULL /// if none of the line table addresses exist in the main /// executable. diff --git a/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.h b/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.h index f984eecc9fe..48e4aedd83e 100644 --- a/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.h +++ b/lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.h @@ -25,20 +25,20 @@ class PDBSymbolData; //------------------------------------------------------------------------------ /// Converts a location information from a PDB symbol to a DWARF expression /// -/// @param[in] module +/// \param[in] module /// The module \a symbol belongs to. /// -/// @param[in] symbol +/// \param[in] symbol /// The symbol with a location information to convert. /// -/// @param[in] ranges +/// \param[in] ranges /// Ranges where this variable is valid. /// -/// @param[out] is_constant +/// \param[out] is_constant /// Set to \b true if the result expression is a constant value data, /// and \b false if it is a DWARF bytecode. /// -/// @return +/// \return /// The DWARF expression corresponding to the location data of \a symbol. //------------------------------------------------------------------------------ lldb_private::DWARFExpression diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h index d0e79fb1ed8..c9c4282d604 100644 --- a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h +++ b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h @@ -61,27 +61,27 @@ public: /// memory that needs to be freed, pass in the address and size and it will /// be freed before getting the list of queues. /// - /// @param [in] thread + /// \param [in] thread /// The thread to run this plan on. /// - /// @param [in] item + /// \param [in] item /// The introspection_dispatch_item_info_ref value for the item of /// interest. /// - /// @param [in] page_to_free + /// \param [in] page_to_free /// An address of an inferior process vm page that needs to be /// deallocated, /// LLDB_INVALID_ADDRESS if this is not needed. /// - /// @param [in] page_to_free_size + /// \param [in] page_to_free_size /// The size of the vm page that needs to be deallocated if an address was /// passed in to page_to_free. /// - /// @param [out] error + /// \param [out] error /// This object will be updated with the error status / error string from /// any failures encountered. /// - /// @returns + /// \returns /// The result of the inferior function call execution. If there was a /// failure of any kind while getting /// the information, the item_buffer_ptr value will be diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h index 742e09d92a5..4b59371ad75 100644 --- a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h +++ b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h @@ -66,26 +66,26 @@ public: /// memory that needs to be freed, pass in the address and size and it will /// be freed before getting the list of queues. /// - /// @param [in] thread + /// \param [in] thread /// The thread to run this plan on. /// - /// @param [in] queue + /// \param [in] queue /// The dispatch_queue_t value for the queue of interest. /// - /// @param [in] page_to_free + /// \param [in] page_to_free /// An address of an inferior process vm page that needs to be /// deallocated, /// LLDB_INVALID_ADDRESS if this is not needed. /// - /// @param [in] page_to_free_size + /// \param [in] page_to_free_size /// The size of the vm page that needs to be deallocated if an address was /// passed in to page_to_free. /// - /// @param [out] error + /// \param [out] error /// This object will be updated with the error status / error string from /// any failures encountered. /// - /// @returns + /// \returns /// The result of the inferior function call execution. If there was a /// failure of any kind while getting /// the information, the items_buffer_ptr value will be diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h index d361ef1c682..e1ff9e0e4e0 100644 --- a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h +++ b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h @@ -62,23 +62,23 @@ public: /// memory that needs to be freed, pass in the address and size and it will /// be freed before getting the list of queues. /// - /// @param [in] thread + /// \param [in] thread /// The thread to run this plan on. /// - /// @param [in] page_to_free + /// \param [in] page_to_free /// An address of an inferior process vm page that needs to be /// deallocated, /// LLDB_INVALID_ADDRESS if this is not needed. /// - /// @param [in] page_to_free_size + /// \param [in] page_to_free_size /// The size of the vm page that needs to be deallocated if an address was /// passed in to page_to_free. /// - /// @param [out] error + /// \param [out] error /// This object will be updated with the error status / error string from /// any failures encountered. /// - /// @returns + /// \returns /// The result of the inferior function call execution. If there was a /// failure of any kind while getting /// the information, the queues_buffer_ptr value will be diff --git a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h index 381f0f5d57a..2c519db06a3 100644 --- a/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h +++ b/lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h @@ -62,23 +62,23 @@ public: /// memory that needs to be freed, pass in the address and size and it will /// be freed before getting the list of queues. /// - /// @param [in] thread_id + /// \param [in] thread_id /// The thread to get the extended backtrace for. /// - /// @param [in] page_to_free + /// \param [in] page_to_free /// An address of an inferior process vm page that needs to be /// deallocated, /// LLDB_INVALID_ADDRESS if this is not needed. /// - /// @param [in] page_to_free_size + /// \param [in] page_to_free_size /// The size of the vm page that needs to be deallocated if an address was /// passed in to page_to_free. /// - /// @param [out] error + /// \param [out] error /// This object will be updated with the error status / error string from /// any failures encountered. /// - /// @returns + /// \returns /// The result of the inferior function call execution. If there was a /// failure of any kind while getting /// the information, the item_buffer_ptr value will be diff --git a/lldb/source/Target/StackFrame.cpp b/lldb/source/Target/StackFrame.cpp index 0b5b394e5c5..d23754c3b8e 100644 --- a/lldb/source/Target/StackFrame.cpp +++ b/lldb/source/Target/StackFrame.cpp @@ -1452,25 +1452,25 @@ ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame, /// Attempt to reconstruct the ValueObject for the address contained in a /// given register plus an offset. /// -/// @params [in] frame +/// \params [in] frame /// The current stack frame. /// -/// @params [in] reg +/// \params [in] reg /// The register. /// -/// @params [in] offset +/// \params [in] offset /// The offset from the register. /// -/// @param [in] disassembler +/// \param [in] disassembler /// A disassembler containing instructions valid up to the current PC. /// -/// @param [in] variables +/// \param [in] variables /// The variable list from the current frame, /// -/// @param [in] pc +/// \param [in] pc /// The program counter for the instruction considered the 'user'. /// -/// @return +/// \return /// A string describing the base for the ExpressionPath. This could be a /// variable, a register value, an argument, or a function return value. /// The ValueObject if found. If valid, it has a valid ExpressionPath. diff --git a/lldb/source/Utility/FileSpec.cpp b/lldb/source/Utility/FileSpec.cpp index f877b6f0ef9..72101f93b13 100644 --- a/lldb/source/Utility/FileSpec.cpp +++ b/lldb/source/Utility/FileSpec.cpp @@ -101,13 +101,13 @@ namespace { //------------------------------------------------------------------ /// Safely get a character at the specified index. /// -/// @param[in] path +/// \param[in] path /// A full, partial, or relative path to a file. /// -/// @param[in] i +/// \param[in] i /// An index into path which may or may not be valid. /// -/// @return +/// \return /// The character at index \a i if the index is valid, or 0 if /// the index is not valid. //------------------------------------------------------------------ @@ -130,10 +130,10 @@ inline char safeCharAtIndex(const llvm::StringRef &path, size_t i) { /// need normalization since we aren't trying to resolve the path, /// we are just trying to remove redundant things from the path. /// -/// @param[in] path +/// \param[in] path /// A full, partial, or relative path to a file. /// -/// @return +/// \return /// Returns \b true if the path needs to be normalized. //------------------------------------------------------------------ bool needsNormalization(const llvm::StringRef &path) { @@ -531,7 +531,7 @@ bool FileSpec::RemoveLastPathComponent() { /// file (files with a ".c", ".cpp", ".m", ".mm" (many more) /// extension). /// -/// @return +/// \return /// \b true if the filespec represents an implementation source /// file, \b false otherwise. //------------------------------------------------------------------ diff --git a/lldb/source/Utility/Status.cpp b/lldb/source/Utility/Status.cpp index 4d1b2723cb3..ef253875bf2 100644 --- a/lldb/source/Utility/Status.cpp +++ b/lldb/source/Utility/Status.cpp @@ -273,7 +273,7 @@ void Status::SetErrorString(llvm::StringRef err_str) { //------------------------------------------------------------------ /// Set the current error string to a formatted error string. /// -/// @param format +/// \param format /// A printf style format string //------------------------------------------------------------------ int Status::SetErrorStringWithFormat(const char *format, ...) { |
