replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Bring Doxygen comment syntax in sync with LLVM coding style. 

This changes '@' prefix to '\'.

llvm-svn: 355841
This commit is contained in:
Adrian Prantl 2019-03-11 17:09:29 +00:00
parent 5ccb339107
commit f05b42e960
221 changed files with 3561 additions and 3561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lldb/examples/interposing/darwin/fd_interposing/FDInterposing.cpp
View File

@ -69,7 +69,7 @@
#include <vector>
//----------------------------------------------------------------------
/// @def DISALLOW_COPY_AND_ASSIGN(TypeName)
/// \def DISALLOW_COPY_AND_ASSIGN(TypeName)
/// Macro definition for easily disallowing copy constructor and
/// assignment operators in C++ classes.
//----------------------------------------------------------------------

16
lldb/include/lldb/API/SBAttachInfo.h
View File

@ -27,10 +27,10 @@ public:
/// This function implies that a future call to SBTarget::Attach(...)
/// will be synchronous.
///
/// @param[in] path
/// \param[in] path
/// A full or partial name for the process to attach to.
///
/// @param[in] wait_for
/// \param[in] wait_for
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
//------------------------------------------------------------------
@ -42,14 +42,14 @@ public:
/// Future calls to SBTarget::Attach(...) will be synchronous or
/// asynchronous depending on the \a async argument.
///
/// @param[in] path
/// \param[in] path
/// A full or partial name for the process to attach to.
///
/// @param[in] wait_for
/// \param[in] wait_for
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
///
/// @param[in] async
/// \param[in] async
/// If \b false, then the SBTarget::Attach(...) call will be a
/// synchronous call with no way to cancel the attach in
/// progress.
@ -85,7 +85,7 @@ public:
/// This function implies that a call to SBTarget::Attach(...) will
/// be synchronous.
///
/// @param[in] b
/// \param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
//------------------------------------------------------------------
@ -98,11 +98,11 @@ public:
/// Future calls to SBTarget::Attach(...) will be synchronous or
/// asynchronous depending on the \a async argument.
///
/// @param[in] b
/// \param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
///
/// @param[in] async
/// \param[in] async
/// If \b false, then the SBTarget::Attach(...) call will be a
/// synchronous call with no way to cancel the attach in
/// progress.

2
lldb/include/lldb/API/SBBlock.h
View File

@ -63,7 +63,7 @@ public:
//------------------------------------------------------------------
/// Get the inlined block that contains this block.
///
/// @return
/// \return
/// If this block is inlined, it will return this block, else
/// parent blocks will be searched to see if any contain this
/// block and are themselves inlined. An invalid SBBlock will

4
lldb/include/lldb/API/SBCommandInterpreter.h
View File

@ -208,10 +208,10 @@ public:
/// terminal, so this function allows GUI programs to emulate this
/// functionality.
///
/// @param[in] ch
/// \param[in] ch
/// The character that was typed along with the control key
///
/// @return
/// \return
/// The string that should be written into the file handle that is
/// feeding the input stream for the debugger, or nullptr if there is
/// no string for this control key.

4
lldb/include/lldb/API/SBCompileUnit.h
View File

@ -52,7 +52,7 @@ public:
/// Get all types matching \a type_mask from debug info in this
/// compile unit.
///
/// @param[in] type_mask
/// \param[in] type_mask
/// A bitfield that consists of one or more bits logically OR'ed
/// together from the lldb::TypeClass enumeration. This allows
/// you to request only structure types, or only class, struct
@ -60,7 +60,7 @@ public:
/// all types found in the debug information for this compile
/// unit.
///
/// @return
/// \return
/// A list of types in this compile unit that match \a type_mask
//------------------------------------------------------------------
lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);

2
lldb/include/lldb/API/SBDebugger.h
View File

@ -151,7 +151,7 @@ public:
/// Get the name and description of one of the available platforms.
///
/// @param[in] idx
/// \param[in] idx
/// Zero-based index of the platform for which info should be retrieved,
/// must be less than the value returned by GetNumAvailablePlatforms().
lldb::SBStructuredData GetAvailablePlatformInfoAtIndex(uint32_t idx);

4
lldb/include/lldb/API/SBLaunchInfo.h
View File

@ -57,10 +57,10 @@ public:
/// SBTarget::Launch(...), the target will use the resolved executable
/// path that was used to create the target.
///
/// @param[in] exe_file
/// \param[in] exe_file
/// The override path to use when launching the executable.
///
/// @param[in] add_as_first_arg
/// \param[in] add_as_first_arg
/// If true, then the path will be inserted into the argument vector
/// prior to launching. Otherwise the argument vector will be left
/// alone.

14
lldb/include/lldb/API/SBMemoryRegionInfo.h
View File

@ -30,7 +30,7 @@ public:
//------------------------------------------------------------------
/// Get the base address of this memory range.
///
/// @return
/// \return
/// The base address of this memory range.
//------------------------------------------------------------------
lldb::addr_t GetRegionBase();
@ -38,7 +38,7 @@ public:
//------------------------------------------------------------------
/// Get the end address of this memory range.
///
/// @return
/// \return
/// The base address of this memory range.
//------------------------------------------------------------------
lldb::addr_t GetRegionEnd();
@ -46,7 +46,7 @@ public:
//------------------------------------------------------------------
/// Check if this memory address is marked readable to the process.
///
/// @return
/// \return
/// true if this memory address is marked readable
//------------------------------------------------------------------
bool IsReadable();
@ -54,7 +54,7 @@ public:
//------------------------------------------------------------------
/// Check if this memory address is marked writable to the process.
///
/// @return
/// \return
/// true if this memory address is marked writable
//------------------------------------------------------------------
bool IsWritable();
@ -62,7 +62,7 @@ public:
//------------------------------------------------------------------
/// Check if this memory address is marked executable to the process.
///
/// @return
/// \return
/// true if this memory address is marked executable
//------------------------------------------------------------------
bool IsExecutable();
@ -71,7 +71,7 @@ public:
/// Check if this memory address is mapped into the process address
/// space.
///
/// @return
/// \return
/// true if this memory address is in the process address space.
//------------------------------------------------------------------
bool IsMapped();
@ -80,7 +80,7 @@ public:
/// Returns the name of the memory region mapped at the given
/// address.
///
/// @return
/// \return
/// In case of memory mapped files it is the absolute path of
/// the file otherwise it is a name associated with the memory
/// region. If no name can be determined the returns nullptr.

48
lldb/include/lldb/API/SBModule.h
View File

@ -44,7 +44,7 @@ public:
/// that is running LLDB. This can differ from the path on the
/// platform since we might be doing remote debugging.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetFileSpec() const;
@ -61,7 +61,7 @@ public:
/// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
/// The file could also be cached in a local developer kit directory.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetPlatformFileSpec() const;
@ -77,7 +77,7 @@ public:
/// the target will install this module on the remote platform prior
/// to launching.
///
/// @return
/// \return
/// A file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetRemoteInstallFileSpec();
@ -97,7 +97,7 @@ public:
/// or "./usr/lib", then the install path will be resolved using
/// the platform's current working directory as the base path.
///
/// @param[in] file
/// \param[in] file
/// A file specification object.
//------------------------------------------------------------------
bool SetRemoteInstallFileSpec(lldb::SBFileSpec &file);
@ -134,11 +134,11 @@ public:
/// Find compile units related to *this module and passed source
/// file.
///
/// @param[in] sb_file_spec
/// \param[in] sb_file_spec
/// A lldb::SBFileSpec object that contains source file
/// specification.
///
/// @return
/// \return
/// A lldb::SBSymbolContextList that gets filled in with all of
/// the symbol contexts for all the matches.
//------------------------------------------------------------------
@ -161,17 +161,17 @@ public:
//------------------------------------------------------------------
/// Find functions by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the function we are looking for.
///
/// @param[in] name_type_mask
/// \param[in] name_type_mask
/// A logical OR of one or more FunctionNameType enum bits that
/// indicate what kind of names should be used when doing the
/// lookup. Bits include fully qualified names, base names,
/// C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @return
/// \return
/// A lldb::SBSymbolContextList that gets filled in with all of
/// the symbol contexts for all the matches.
//------------------------------------------------------------------
@ -182,17 +182,17 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by name.
///
/// @param[in] target
/// \param[in] target
/// A valid SBTarget instance representing the debuggee.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a max_matches.
///
/// @return
/// \return
/// A list of matched variables in an SBValueList.
//------------------------------------------------------------------
lldb::SBValueList FindGlobalVariables(lldb::SBTarget &target,
@ -201,14 +201,14 @@ public:
//------------------------------------------------------------------
/// Find the first global (or static) variable by name.
///
/// @param[in] target
/// \param[in] target
/// A valid SBTarget instance representing the debuggee.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @return
/// \return
/// An SBValue that gets filled in with the found variable (if any).
//------------------------------------------------------------------
lldb::SBValue FindFirstGlobalVariable(lldb::SBTarget &target,
@ -227,10 +227,10 @@ public:
///
/// For DWARF debug info, the type ID is the DIE offset.
///
/// @param[in] uid
/// \param[in] uid
/// The type user ID.
///
/// @return
/// \return
/// An SBType for the given type ID, or an empty SBType if the
/// type was not found.
//------------------------------------------------------------------
@ -242,14 +242,14 @@ public:
/// Get all types matching \a type_mask from debug info in this
/// module.
///
/// @param[in] type_mask
/// \param[in] type_mask
/// A bitfield that consists of one or more bits logically OR'ed
/// together from the lldb::TypeClass enumeration. This allows
/// you to request only structure types, or only class, struct
/// and union types. Passing in lldb::eTypeClassAny will return
/// all types found in the debug information for this module.
///
/// @return
/// \return
/// A list of types in this module that match \a type_mask
//------------------------------------------------------------------
lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
@ -268,7 +268,7 @@ public:
/// function with a value of \a versions and \a num_versions that
/// has enough storage to store some or all version numbers.
///
/// @param[out] versions
/// \param[out] versions
/// A pointer to an array of uint32_t types that is \a num_versions
/// long. If this value is NULL, the return value will indicate
/// how many version numbers are required for a subsequent call
@ -279,7 +279,7 @@ public:
/// will be filled with \a num_versions UINT32_MAX values
/// and zero will be returned.
///
/// @param[in] num_versions
/// \param[in] num_versions
/// The maximum number of entries to fill into \a versions. If
/// this value is zero, then the return value will indicate
/// how many version numbers there are in total so another call
@ -289,7 +289,7 @@ public:
/// numbers in this object file, only \a num_versions will be
/// filled into \a versions (if \a versions is non-NULL).
///
/// @return
/// \return
/// This function always returns the number of version numbers
/// that this object file has regardless of the number of
/// version numbers that were copied into \a versions.
@ -304,7 +304,7 @@ public:
/// like '/usr/lib/liba.dylib' then debug information can be located
/// in folder like '/usr/lib/liba.dylib.dSYM/'.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetSymbolFileSpec() const;

4
lldb/include/lldb/API/SBModuleSpec.h
View File

@ -37,7 +37,7 @@ public:
/// that is running LLDB. This can differ from the path on the
/// platform since we might be doing remote debugging.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetFileSpec();
@ -56,7 +56,7 @@ public:
/// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
/// The file could also be cached in a local developer kit directory.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
lldb::SBFileSpec GetPlatformFileSpec();

52
lldb/include/lldb/API/SBProcess.h
View File

@ -137,7 +137,7 @@ public:
/// this is typically the same as if you called "getpid()" in the
/// process.
///
/// @return
/// \return
/// Returns LLDB_INVALID_PROCESS_ID if this object does not
/// contain a valid process object, or if the process has not
/// been launched. Returns a valid process ID if the process is
@ -153,7 +153,7 @@ public:
/// create a process with the same process ID, there needs to be a
/// way to tell two process instances apart.
///
/// @return
/// \return
/// Returns a non-zero integer ID if this object contains a
/// valid process object, zero if this object does not contain
/// a valid process object.
@ -188,10 +188,10 @@ public:
/// Note that it wasn't fully implemented and tracks only the stop
/// event for the last natural stop ID.
///
/// @param [in] stop_id
/// \param [in] stop_id
/// The ID of the stop event to return.
///
/// @return
/// \return
/// The stop event corresponding to stop ID.
//------------------------------------------------------------------
lldb::SBEvent GetStopEventForStopID(uint32_t stop_id);
@ -239,7 +239,7 @@ public:
//------------------------------------------------------------------
/// Start Tracing with the given SBTraceOptions.
///
/// @param[in] options
/// \param[in] options
/// Class containing trace options like trace buffer size, meta
/// data buffer size, TraceType and any custom parameters
/// {formatted as a JSON Dictionary}. In case of errors in
@ -254,10 +254,10 @@ public:
/// parameters, only the parameters recognized by the target
/// would be used and others would be ignored.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong.
///
/// @return
/// \return
/// A SBTrace instance, which should be used
/// to get the trace data or other trace related operations.
//------------------------------------------------------------------
@ -268,15 +268,15 @@ public:
//------------------------------------------------------------------
/// Load a shared library into this process.
///
/// @param[in] remote_image_spec
/// \param[in] remote_image_spec
/// The path for the shared library on the target what you want
/// to load.
///
/// @param[out] error
/// \param[out] error
/// An error object that gets filled in with any errors that
/// might occur when trying to load the shared library.
///
/// @return
/// \return
/// A token that represents the shared library that can be
/// later used to unload the shared library. A value of
/// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
@ -287,24 +287,24 @@ public:
//------------------------------------------------------------------
/// Load a shared library into this process.
///
/// @param[in] local_image_spec
/// \param[in] local_image_spec
/// The file spec that points to the shared library that you
/// want to load if the library is located on the host. The
/// library will be copied over to the location specified by
/// remote_image_spec or into the current working directory with
/// the same filename if the remote_image_spec isn't specified.
///
/// @param[in] remote_image_spec
/// \param[in] remote_image_spec
/// If local_image_spec is specified then the location where the
/// library should be copied over from the host. If
/// local_image_spec isn't specified, then the path for the
/// shared library on the target what you want to load.
///
/// @param[out] error
/// \param[out] error
/// An error object that gets filled in with any errors that
/// might occur when trying to load the shared library.
///
/// @return
/// \return
/// A token that represents the shared library that can be
/// later used to unload the shared library. A value of
/// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
@ -319,25 +319,25 @@ public:
/// library name and a list of paths, searching along the list of
/// paths till you find a matching library.
///
/// @param[in] image_spec
/// \param[in] image_spec
/// The name of the shared library that you want to load.
/// If image_spec is a relative path, the relative path will be
/// appended to the search paths.
/// If the image_spec is an absolute path, just the basename is used.
///
/// @param[in] paths
/// \param[in] paths
/// A list of paths to search for the library whose basename is
/// local_spec.
///
/// @param[out] loaded_path
/// \param[out] loaded_path
/// If the library was found along the paths, this will store the
/// full path to the found library.
///
/// @param[out] error
/// \param[out] error
/// An error object that gets filled in with any errors that
/// might occur when trying to search for the shared library.
///
/// @return
/// \return
/// A token that represents the shared library that can be
/// later passed to UnloadImage. A value of
/// LLDB_INVALID_IMAGE_TOKEN will be returned if the shared
@ -361,7 +361,7 @@ public:
/// or the work item was enqueued to it (in the case of a libdispatch
/// queue).
///
/// @return
/// \return
/// The number of thread-origin extended backtrace types that may be
/// available.
//------------------------------------------------------------------
@ -371,13 +371,13 @@ public:
/// Return the name of one of the thread-origin extended backtrace
/// methods.
///
/// @param [in] idx
/// \param [in] idx
/// The index of the name to return. They will be returned in
/// the order that the user will most likely want to see them.
/// e.g. if the type at index 0 is not available for a thread,
/// see if the type at index 1 provides an extended backtrace.
///
/// @return
/// \return
/// The name at that index.
//------------------------------------------------------------------
const char *GetExtendedBacktraceTypeAtIndex(uint32_t idx);
@ -394,14 +394,14 @@ public:
/// region that contains it in the supplied SBMemoryRegionInfo object.
/// To iterate over all memory regions use GetMemoryRegionList.
///
/// @param[in] load_addr
/// \param[in] load_addr
/// The address to be queried.
///
/// @param[out] region_info
/// \param[out] region_info
/// A reference to an SBMemoryRegionInfo object that will contain
/// the details of the memory region containing load_addr.
///
/// @return
/// \return
/// An error object describes any errors that occurred while
/// querying load_addr.
//------------------------------------------------------------------
@ -411,7 +411,7 @@ public:
//------------------------------------------------------------------
/// Return the list of memory regions within the process.
///
/// @return
/// \return
/// A list of all witin the process memory regions.
//------------------------------------------------------------------
lldb::SBMemoryRegionInfoList GetMemoryRegions();

4
lldb/include/lldb/API/SBSection.h
View File

@ -63,7 +63,7 @@ public:
/// i.e. for a section having read and execute permissions, the value
/// returned is 6
///
/// @return
/// \return
/// Returns an unsigned value for Permissions for the section.
//------------------------------------------------------------------
uint32_t
@ -75,7 +75,7 @@ public:
/// varying minimum addressable unit (i.e. byte) size for their
/// CODE or DATA buses.
///
/// @return
/// \return
/// The number of host (8-bit) bytes needed to hold a target byte
//------------------------------------------------------------------
uint32_t GetTargetByteSize();

6
lldb/include/lldb/API/SBStructuredData.h
View File

@ -89,17 +89,17 @@ public:
//------------------------------------------------------------------
/// Provides the string value if this data structure is a string type.
///
/// @param[out] dst
/// \param[out] dst
/// pointer where the string value will be written. In case it is null,
/// nothing will be written at @dst.
///
/// @param[in] dst_len
/// \param[in] dst_len
/// max number of characters that can be written at @dst. In case it is
/// zero, nothing will be written at @dst. If this length is not enough
/// to write the complete string value, (dst_len-1) bytes of the string
/// value will be written at @dst followed by a null character.
///
/// @return
/// \return
/// Returns the byte size needed to completely write the string value at
/// @dst in all cases.
//------------------------------------------------------------------

188
lldb/include/lldb/API/SBTarget.h
View File

@ -75,7 +75,7 @@ public:
//------------------------------------------------------------------
/// Sets whether we should collect statistics on lldb or not.
///
/// @param[in] v
/// \param[in] v
/// A boolean to control the collection.
//------------------------------------------------------------------
void SetCollectingStats(bool v);
@ -83,7 +83,7 @@ public:
//------------------------------------------------------------------
/// Returns whether statistics collection are enabled.
///
/// @return
/// \return
/// true if statistics are currently being collected, false
/// otherwise.
//------------------------------------------------------------------
@ -92,7 +92,7 @@ public:
//------------------------------------------------------------------
/// Returns a dump of the collected statistics.
///
/// @return
/// \return
/// A SBStructuredData with the statistics collected.
//------------------------------------------------------------------
lldb::SBStructuredData GetStatistics();
@ -103,7 +103,7 @@ public:
/// After return, the platform object should be checked for
/// validity.
///
/// @return
/// \return
/// A platform object.
//------------------------------------------------------------------
lldb::SBPlatform GetPlatform();
@ -118,7 +118,7 @@ public:
/// have an install location set, it will be installed in the remote
/// platform's working directory.
///
/// @return
/// \return
/// An error describing anything that went wrong during
/// installation.
//------------------------------------------------------------------
@ -134,47 +134,47 @@ public:
/// optionally re-directed to \a stdin_path, \a stdout_path, and
/// \a stderr_path.
///
/// @param[in] listener
/// \param[in] listener
/// An optional listener that will receive all process events.
/// If \a listener is valid then \a listener will listen to all
/// process events. If not valid, then this target's debugger
/// (SBTarget::GetDebugger()) will listen to all process events.
///
/// @param[in] argv
/// \param[in] argv
/// The argument array.
///
/// @param[in] envp
/// \param[in] envp
/// The environment array.
///
/// @param[in] stdin_path
/// \param[in] stdin_path
/// The path to use when re-directing the STDIN of the new
/// process. If all stdXX_path arguments are nullptr, a pseudo
/// terminal will be used.
///
/// @param[in] stdout_path
/// \param[in] stdout_path
/// The path to use when re-directing the STDOUT of the new
/// process. If all stdXX_path arguments are nullptr, a pseudo
/// terminal will be used.
///
/// @param[in] stderr_path
/// \param[in] stderr_path
/// The path to use when re-directing the STDERR of the new
/// process. If all stdXX_path arguments are nullptr, a pseudo
/// terminal will be used.
///
/// @param[in] working_directory
/// \param[in] working_directory
/// The working directory to have the child process run in
///
/// @param[in] launch_flags
/// \param[in] launch_flags
/// Some launch options specified by logical OR'ing
/// lldb::LaunchFlags enumeration values together.
///
/// @param[in] stop_at_entry
/// \param[in] stop_at_entry
/// If false do not stop the inferior at the entry point.
///
/// @param[out] error
/// \param[out] error
/// An error object. Contains the reason if there is some failure.
///
/// @return
/// \return
/// A process object for the newly created process.
//------------------------------------------------------------------
lldb::SBProcess Launch(SBListener &listener, char const **argv,
@ -190,13 +190,13 @@ public:
//------------------------------------------------------------------
/// Launch a new process with sensible defaults.
///
/// @param[in] argv
/// \param[in] argv
/// The argument array.
///
/// @param[in] envp
/// \param[in] envp
/// The environment array.
///
/// @param[in] working_directory
/// \param[in] working_directory
/// The working directory to have the child process run in
///
/// Default: listener
@ -210,7 +210,7 @@ public:
/// Default: stderr_path
/// A pseudo terminal will be used.
///
/// @return
/// \return
/// A process object for the newly created process.
//------------------------------------------------------------------
SBProcess LaunchSimple(const char **argv, const char **envp,
@ -223,19 +223,19 @@ public:
//------------------------------------------------------------------
/// Attach to process with pid.
///
/// @param[in] listener
/// \param[in] listener
/// An optional listener that will receive all process events.
/// If \a listener is valid then \a listener will listen to all
/// process events. If not valid, then this target's debugger
/// (SBTarget::GetDebugger()) will listen to all process events.
///
/// @param[in] pid
/// \param[in] pid
/// The process ID to attach to.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong if attach fails.
///
/// @return
/// \return
/// A process object for the attached process.
//------------------------------------------------------------------
lldb::SBProcess AttachToProcessWithID(SBListener &listener, lldb::pid_t pid,
@ -244,22 +244,22 @@ public:
//------------------------------------------------------------------
/// Attach to process with name.
///
/// @param[in] listener
/// \param[in] listener
/// An optional listener that will receive all process events.
/// If \a listener is valid then \a listener will listen to all
/// process events. If not valid, then this target's debugger
/// (SBTarget::GetDebugger()) will listen to all process events.
///
/// @param[in] name
/// \param[in] name
/// Basename of process to attach to.
///
/// @param[in] wait_for
/// \param[in] wait_for
/// If true wait for a new instance of 'name' to be launched.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong if attach fails.
///
/// @return
/// \return
/// A process object for the attached process.
//------------------------------------------------------------------
lldb::SBProcess AttachToProcessWithName(SBListener &listener,
@ -269,22 +269,22 @@ public:
//------------------------------------------------------------------
/// Connect to a remote debug server with url.
///
/// @param[in] listener
/// \param[in] listener
/// An optional listener that will receive all process events.
/// If \a listener is valid then \a listener will listen to all
/// process events. If not valid, then this target's debugger
/// (SBTarget::GetDebugger()) will listen to all process events.
///
/// @param[in] url
/// \param[in] url
/// The url to connect to, e.g., 'connect://localhost:12345'.
///
/// @param[in] plugin_name
/// \param[in] plugin_name
/// The plugin name to be used; can be nullptr.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong if the connect fails.
///
/// @return
/// \return
/// A process object for the connected process.
//------------------------------------------------------------------
lldb::SBProcess ConnectRemote(SBListener &listener, const char *url,
@ -320,11 +320,11 @@ public:
/// Find compile units related to *this target and passed source
/// file.
///
/// @param[in] sb_file_spec
/// \param[in] sb_file_spec
/// A lldb::SBFileSpec object that contains source file
/// specification.
///
/// @return
/// \return
/// A lldb::SBSymbolContextList that gets filled in with all of
/// the symbol contexts for all the matches.
//------------------------------------------------------------------
@ -340,7 +340,7 @@ public:
//------------------------------------------------------------------
/// Architecture data byte width accessor
///
/// @return
/// \return
/// The size in 8-bit (host) bytes of a minimum addressable
/// unit from the Architecture's data bus
//------------------------------------------------------------------
@ -349,7 +349,7 @@ public:
//------------------------------------------------------------------
/// Architecture code byte width accessor
///
/// @return
/// \return
/// The size in 8-bit (host) bytes of a minimum addressable
/// unit from the Architecture's code bus
//------------------------------------------------------------------
@ -358,14 +358,14 @@ public:
//------------------------------------------------------------------
/// Set the base load address for a module section.
///
/// @param[in] section
/// \param[in] section
/// The section whose base load address will be set within this
/// target.
///
/// @param[in] section_base_addr
/// \param[in] section_base_addr
/// The base address for the section.
///
/// @return
/// \return
/// An error to indicate success, fail, and any reason for
/// failure.
//------------------------------------------------------------------
@ -375,11 +375,11 @@ public:
//------------------------------------------------------------------
/// Clear the base load address for a module section.
///
/// @param[in] section
/// \param[in] section
/// The section whose base load address will be cleared within
/// this target.
///
/// @return
/// \return
/// An error to indicate success, fail, and any reason for
/// failure.
//------------------------------------------------------------------
@ -394,14 +394,14 @@ public:
/// this function will allow you to easily and quickly slide all
/// module sections.
///
/// @param[in] module
/// \param[in] module
/// The module to load.
///
/// @param[in] sections_offset
/// \param[in] sections_offset
/// An offset that will be applied to all section file addresses
/// (the virtual addresses found in the object file itself).
///
/// @return
/// \return
/// An error to indicate success, fail, and any reason for
/// failure.
//------------------------------------------------------------------
@ -411,10 +411,10 @@ public:
//------------------------------------------------------------------
/// Clear the section base load addresses for all sections in a module.
///
/// @param[in] module
/// \param[in] module
/// The module to unload.
///
/// @return
/// \return
/// An error to indicate success, fail, and any reason for
/// failure.
//------------------------------------------------------------------
@ -423,17 +423,17 @@ public:
//------------------------------------------------------------------
/// Find functions by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the function we are looking for.
///
/// @param[in] name_type_mask
/// \param[in] name_type_mask
/// A logical OR of one or more FunctionNameType enum bits that
/// indicate what kind of names should be used when doing the
/// lookup. Bits include fully qualified names, base names,
/// C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @return
/// \return
/// A lldb::SBSymbolContextList that gets filled in with all of
/// the symbol contexts for all the matches.
//------------------------------------------------------------------
@ -444,14 +444,14 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a max_matches.
///
/// @return
/// \return
/// A list of matched variables in an SBValueList.
//------------------------------------------------------------------
lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches);
@ -459,11 +459,11 @@ public:
//------------------------------------------------------------------
/// Find the first global (or static) variable by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @return
/// \return
/// An SBValue that gets filled in with the found variable (if any).
//------------------------------------------------------------------
lldb::SBValue FindFirstGlobalVariable(const char *name);
@ -471,16 +471,16 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by pattern.
///
/// @param[in] name
/// \param[in] name
/// The pattern to search for global or static variables
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a max_matches.
///
/// @param[in] matchtype
/// \param[in] matchtype
/// The match type to use.
///
/// @return
/// \return
/// A list of matched variables in an SBValueList.
//------------------------------------------------------------------
lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches,
@ -489,16 +489,16 @@ public:
//------------------------------------------------------------------
/// Find global functions by their name with pattern matching.
///
/// @param[in] name
/// \param[in] name
/// The pattern to search for global or static variables
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a max_matches.
///
/// @param[in] matchtype
/// \param[in] matchtype
/// The match type to use.
///
/// @return
/// \return
/// A list of matched variables in an SBValueList.
//------------------------------------------------------------------
lldb::SBSymbolContextList FindGlobalFunctions(const char *name,
@ -510,10 +510,10 @@ public:
//------------------------------------------------------------------
/// Resolve a current file address into a section offset address.
///
/// @param[in] file_addr
/// \param[in] file_addr
/// The file address to resolve.
///
/// @return
/// \return
/// An SBAddress which will be valid if...
//------------------------------------------------------------------
lldb::SBAddress ResolveFileAddress(lldb::addr_t file_addr);
@ -521,11 +521,11 @@ public:
//------------------------------------------------------------------
/// Resolve a current load address into a section offset address.
///
/// @param[in] vm_addr
/// \param[in] vm_addr
/// A virtual address from the current process state that is to
/// be translated into a section offset address.
///
/// @return
/// \return
/// An SBAddress which will be valid if \a vm_addr was
/// successfully resolved into a section offset address, or an
/// invalid SBAddress if \a vm_addr doesn't resolve to a section
@ -537,7 +537,7 @@ public:
/// Resolve a current load address into a section offset address
/// using the process stop ID to identify a time in the past.
///
/// @param[in] stop_id
/// \param[in] stop_id
/// Each time a process stops, the process stop ID integer gets
/// incremented. These stop IDs are used to identify past times
/// and can be used in history objects as a cheap way to store
@ -545,11 +545,11 @@ public:
/// UINT32_MAX will always resolve the address using the
/// currently loaded sections.
///
/// @param[in] vm_addr
/// \param[in] vm_addr
/// A virtual address from the current process state that is to
/// be translated into a section offset address.
///
/// @return
/// \return
/// An SBAddress which will be valid if \a vm_addr was
/// successfully resolved into a section offset address, or an
/// invalid SBAddress if \a vm_addr doesn't resolve to a section
@ -567,20 +567,20 @@ public:
/// files. For a target whose bytes are sized as a multiple of host
/// bytes, the data read back will preserve the target's byte order.
///
/// @param[in] addr
/// \param[in] addr
/// A target address to read from.
///
/// @param[out] buf
/// \param[out] buf
/// The buffer to read memory into.
///
/// @param[in] size
/// \param[in] size
/// The maximum number of host bytes to read in the buffer passed
/// into this call
///
/// @param[out] error
/// \param[out] error
/// Status information is written here if the memory read fails.
///
/// @return
/// \return
/// The amount of data read in host bytes.
//------------------------------------------------------------------
size_t ReadMemory(const SBAddress addr, void *buf, size_t size,
@ -686,24 +686,24 @@ public:
//------------------------------------------------------------------
/// Create a breakpoint using a scripted resolver.
///
/// @param[in] class_name
/// \param[in] class_name
/// This is the name of the class that implements a scripted resolver.
///
/// @param[in] extra_args
/// \param[in] extra_args
/// This is an SBStructuredData object that will get passed to the
/// constructor of the class in class_name. You can use this to
/// reuse the same class, parametrizing with entries from this
/// dictionary.
///
/// @param module_list
/// \param module_list
/// If this is non-empty, this will be used as the module filter in the
/// SearchFilter created for this breakpoint.
///
/// @param file_list
/// \param file_list
/// If this is non-empty, this will be used as the comp unit filter in the
/// SearchFilter created for this breakpoint.
///
/// @return
/// \return
/// An SBBreakpoint that will set locations based on the logic in the
/// resolver's search callback.
//------------------------------------------------------------------
@ -718,13 +718,13 @@ public:
/// Read breakpoints from source_file and return the newly created
/// breakpoints in bkpt_list.
///
/// @param[in] source_file
/// \param[in] source_file
/// The file from which to read the breakpoints.
///
/// @param[out] new_bps
/// \param[out] new_bps
/// A list of the newly created breakpoints.
///
/// @return
/// \return
/// An SBError detailing any errors in reading in the breakpoints.
//------------------------------------------------------------------
lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
@ -734,17 +734,17 @@ public:
/// Read breakpoints from source_file and return the newly created
/// breakpoints in bkpt_list.
///
/// @param[in] source_file
/// \param[in] source_file
/// The file from which to read the breakpoints.
///
/// @param[in] matching_names
/// \param[in] matching_names
/// Only read in breakpoints whose names match one of the names in this
/// list.
///
/// @param[out] new_bps
/// \param[out] new_bps
/// A list of the newly created breakpoints.
///
/// @return
/// \return
/// An SBError detailing any errors in reading in the breakpoints.
//------------------------------------------------------------------
lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
@ -754,10 +754,10 @@ public:
//------------------------------------------------------------------
/// Write breakpoints to dest_file.
///
/// @param[in] dest_file
/// \param[in] dest_file
/// The file to which to write the breakpoints.
///
/// @return
/// \return
/// An SBError detailing any errors in writing in the breakpoints.
//------------------------------------------------------------------
lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file);
@ -765,18 +765,18 @@ public:
//------------------------------------------------------------------
/// Write breakpoints listed in bkpt_list to dest_file.
///
/// @param[in] dest_file
/// \param[in] dest_file
/// The file to which to write the breakpoints.
///
/// @param[in] bkpt_list
/// \param[in] bkpt_list
/// Only write breakpoints from this list.
///
/// @param[in] append
/// \param[in] append
/// If \btrue, append the breakpoints in bkpt_list to the others
/// serialized in dest_file. If dest_file doesn't exist, then a new
/// file will be created and the breakpoints in bkpt_list written to it.
///
/// @return
/// \return
/// An SBError detailing any errors in writing in the breakpoints.
//------------------------------------------------------------------
lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file,

20
lldb/include/lldb/API/SBTrace.h
View File

@ -22,22 +22,22 @@ public:
//------------------------------------------------------------------
/// Obtain the trace data as raw bytes.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong.
///
/// @param[in] buf
/// \param[in] buf
/// Buffer to write the trace data to.
///
/// @param[in] size
/// \param[in] size
/// The size of the buffer used to read the data. This is
/// also the size of the data intended to read. It is also
/// possible to partially read the trace data for some trace
/// technologies by specifying a smaller buffer.
///
/// @param[in] offset
/// \param[in] offset
/// The start offset to begin reading the trace data.
///
/// @param[in] thread_id
/// \param[in] thread_id
/// Tracing could be started for the complete process or a
/// single thread, in the first case the traceid obtained would
/// map to all the threads existing within the process and the
@ -45,7 +45,7 @@ public:
/// such a scenario to select the trace data for a specific
/// thread.
///
/// @return
/// \return
/// The size of the trace data effectively read by the API call.
//------------------------------------------------------------------
size_t GetTraceData(SBError &error, void *buf, size_t size, size_t offset = 0,
@ -63,10 +63,10 @@ public:
/// Stop the tracing instance. Stopping the trace will also
/// lead to deletion of any gathered trace data.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong.
///
/// @param[in] thread_id
/// \param[in] thread_id
/// The trace id could map to a tracing instance for a thread
/// or could also map to a group of threads being traced with
/// the same trace options. A thread_id is normally optional
@ -89,11 +89,11 @@ public:
/// The threadid in the SBTraceOptions needs to be set when the
/// configuration used by a specific thread is being requested.
///
/// @param[out] options
/// \param[out] options
/// The trace options actually used by the trace instance
/// would be filled by the API.
///
/// @param[out] error
/// \param[out] error
/// An error explaining what went wrong.
//------------------------------------------------------------------
void GetTraceConfig(SBTraceOptions &options, SBError &error);

44
lldb/include/lldb/API/SBValue.h
View File

@ -177,20 +177,20 @@ public:
/// that aren't in the array bounds using positive or negative
/// indexes.
///
/// @param[in] idx
/// \param[in] idx
/// The index of the child value to get
///
/// @param[in] use_dynamic
/// \param[in] use_dynamic
/// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///
/// @param[in] can_create_synthetic
/// \param[in] can_create_synthetic
/// If \b true, then allow child values to be created by index
/// for pointers and arrays for indexes that normally wouldn't
/// be allowed.
///
/// @return
/// \return
/// A new SBValue object that represents the child member value.
//------------------------------------------------------------------
lldb::SBValue GetChildAtIndex(uint32_t idx,
@ -226,17 +226,17 @@ public:
/// data type is a T* or T[], and extract item_count elements
/// of type T from it, copying their contents in an SBData.
///
/// @param[in] item_idx
/// \param[in] item_idx
/// The index of the first item to retrieve. For an array
/// this is equivalent to array[item_idx], for a pointer
/// to *(pointer + item_idx). In either case, the measurement
/// unit for item_idx is the sizeof(T) rather than the byte
///
/// @param[in] item_count
/// \param[in] item_count
/// How many items should be copied into the output. By default
/// only one item is copied, but more can be asked for.
///
/// @return
/// \return
/// An SBData with the contents of the copied items, on success.
/// An empty SBData otherwise.
//------------------------------------------------------------------
@ -248,7 +248,7 @@ public:
/// This method will read the contents of this object in memory
/// and copy them into an SBData for future use.
///
/// @return
/// \return
/// An SBData with the contents of this SBValue, on success.
/// An empty SBData otherwise.
//------------------------------------------------------------------
@ -270,7 +270,7 @@ public:
/// pointers, references, arrays and more. Again, it does so without
/// doing any expensive type completion.
///
/// @return
/// \return
/// Returns \b true if the SBValue might have children, or \b
/// false otherwise.
//------------------------------------------------------------------
@ -322,22 +322,22 @@ public:
///
/// Sets a watchpoint on the value.
///
/// @param[in] resolve_location
/// \param[in] resolve_location
/// Resolve the location of this value once and watch its address.
/// This value must currently be set to \b true as watching all
/// locations of a variable or a variable path is not yet supported,
/// though we plan to support it in the future.
///
/// @param[in] read
/// \param[in] read
/// Stop when this value is accessed.
///
/// @param[in] write
/// \param[in] write
/// Stop when this value is modified
///
/// @param[out] error
/// \param[out] error
/// An error object. Contains the reason if there is some failure.
///
/// @return
/// \return
/// An SBWatchpoint object. This object might not be valid upon
/// return due to a value not being contained in memory, too
/// large, or watchpoint resources are not available or all in
@ -354,22 +354,22 @@ public:
///
/// Sets a watchpoint on the value.
///
/// @param[in] resolve_location
/// \param[in] resolve_location
/// Resolve the location of this value once and watch its address.
/// This value must currently be set to \b true as watching all
/// locations of a variable or a variable path is not yet supported,
/// though we plan to support it in the future.
///
/// @param[in] read
/// \param[in] read
/// Stop when this value is accessed.
///
/// @param[in] write
/// \param[in] write
/// Stop when this value is modified
///
/// @param[out] error
/// \param[out] error
/// An error object. Contains the reason if there is some failure.
///
/// @return
/// \return
/// An SBWatchpoint object. This object might not be valid upon
/// return due to a value not being contained in memory, too
/// large, or watchpoint resources are not available or all in
@ -387,7 +387,7 @@ public:
/// already
/// holding the two above-mentioned locks.
///
/// @return
/// \return
/// A ValueObjectSP of the best kind (static, dynamic or synthetic) we
/// can cons up, in accordance with the SBValue's settings.
//------------------------------------------------------------------
@ -415,13 +415,13 @@ protected:
/// ValueObject.h/cpp or somewhere else convenient. We haven't needed to so
/// far.
///
/// @param[in] value_locker
/// \param[in] value_locker
/// An object that will hold the Target API, and Process RunLocks, and
/// auto-destroy them when it goes out of scope. Currently this is only
/// useful in
/// SBValue.cpp.
///
/// @return
/// \return
/// A ValueObjectSP of the best kind (static, dynamic or synthetic) we
/// can cons up, in accordance with the SBValue's settings.
//------------------------------------------------------------------

114
lldb/include/lldb/Breakpoint/Breakpoint.h
View File

@ -28,7 +28,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that
/// \class Breakpoint Breakpoint.h "lldb/Breakpoint/Breakpoint.h" Class that
/// manages logical breakpoint setting.
//----------------------------------------------------------------------
@ -184,7 +184,7 @@ public:
//------------------------------------------------------------------
//------------------------------------------------------------------
/// Tell whether this breakpoint is an "internal" breakpoint. @return
/// Tell whether this breakpoint is an "internal" breakpoint. \return
/// Returns \b true if this is an internal breakpoint, \b false otherwise.
//------------------------------------------------------------------
bool IsInternal() const;
@ -215,10 +215,10 @@ public:
/// Tell this breakpoint to scan a given module list and resolve any new
/// locations that match the breakpoint's specifications.
///
/// @param[in] module_list
/// \param[in] module_list
/// The list of modules to look in for new locations.
///
/// @param[in] send_event
/// \param[in] send_event
/// If \b true, send a breakpoint location added event for non-internal
/// breakpoints.
//------------------------------------------------------------------
@ -229,10 +229,10 @@ public:
/// Tell this breakpoint to scan a given module list and resolve any new
/// locations that match the breakpoint's specifications.
///
/// @param[in] changed_modules
/// \param[in] changed_modules
/// The list of modules to look in for new locations.
///
/// @param[in] new_locations
/// \param[in] new_locations
/// Fills new_locations with the new locations that were made.
//------------------------------------------------------------------
void ResolveBreakpointInModules(ModuleList &module_list,
@ -243,11 +243,11 @@ public:
/// which case we will remove any locations that are in modules that got
/// unloaded.
///
/// @param[in] changedModules
/// \param[in] changedModules
/// The list of modules to look in for new locations.
/// @param[in] load_event
/// \param[in] load_event
/// If \b true then the modules were loaded, if \b false, unloaded.
/// @param[in] delete_locations
/// \param[in] delete_locations
/// If \b true then the modules were unloaded delete any locations in the
/// changed modules.
//------------------------------------------------------------------
@ -259,9 +259,9 @@ public:
/// by new_module_sp (usually because the underlying file has been rebuilt,
/// and the old version is gone.)
///
/// @param[in] old_module_sp
/// \param[in] old_module_sp
/// The old module that is going away.
/// @param[in] new_module_sp
/// \param[in] new_module_sp
/// The new module that is replacing it.
//------------------------------------------------------------------
void ModuleReplaced(lldb::ModuleSP old_module_sp,
@ -276,12 +276,12 @@ public:
/// Add a location to the breakpoint's location list. This is only meant to
/// be called by the breakpoint's resolver. FIXME: how do I ensure that?
///
/// @param[in] addr
/// \param[in] addr
/// The Address specifying the new location.
/// @param[out] new_location
/// \param[out] new_location
/// Set to \b true if a new location was created, to \b false if there
/// already was a location at this Address.
/// @return
/// \return
/// Returns a pointer to the new location.
//------------------------------------------------------------------
lldb::BreakpointLocationSP AddLocation(const Address &addr,
@ -290,9 +290,9 @@ public:
//------------------------------------------------------------------
/// Find a breakpoint location by Address.
///
/// @param[in] addr
/// \param[in] addr
/// The Address specifying the location.
/// @return
/// \return
/// Returns a shared pointer to the location at \a addr. The pointer
/// in the shared pointer will be nullptr if there is no location at that
/// address.
@ -302,9 +302,9 @@ public:
//------------------------------------------------------------------
/// Find a breakpoint location ID by Address.
///
/// @param[in] addr
/// \param[in] addr
/// The Address specifying the location.
/// @return
/// \return
/// Returns the UID of the location at \a addr, or \b LLDB_INVALID_ID if
/// there is no breakpoint location at that address.
//------------------------------------------------------------------
@ -313,9 +313,9 @@ public:
//------------------------------------------------------------------
/// Find a breakpoint location for a given breakpoint location ID.
///
/// @param[in] bp_loc_id
/// \param[in] bp_loc_id
/// The ID specifying the location.
/// @return
/// \return
/// Returns a shared pointer to the location with ID \a bp_loc_id. The
/// pointer
/// in the shared pointer will be nullptr if there is no location with that
@ -326,10 +326,10 @@ public:
//------------------------------------------------------------------
/// Get breakpoint locations by index.
///
/// @param[in] index
/// \param[in] index
/// The location index.
///
/// @return
/// \return
/// Returns a shared pointer to the location with index \a
/// index. The shared pointer might contain nullptr if \a index is
/// greater than then number of actual locations.
@ -347,7 +347,7 @@ public:
/// This is typically used after the process calls exec, or anytime the
/// architecture of the target changes.
///
/// @param[in] arch
/// \param[in] arch
/// If valid, check the module in each breakpoint to make sure
/// they are compatible, otherwise, ignore architecture.
//------------------------------------------------------------------
@ -364,27 +364,27 @@ public:
//------------------------------------------------------------------
/// Check the Enable/Disable state.
/// @return
/// \return
/// \b true if the breakpoint is enabled, \b false if disabled.
//------------------------------------------------------------------
bool IsEnabled() override;
//------------------------------------------------------------------
/// Set the breakpoint to ignore the next \a count breakpoint hits.
/// @param[in] count
/// \param[in] count
/// The number of breakpoint hits to ignore.
//------------------------------------------------------------------
void SetIgnoreCount(uint32_t count);
//------------------------------------------------------------------
/// Return the current ignore count/
/// @return
/// \return
/// The number of breakpoint hits to be ignored.
//------------------------------------------------------------------
uint32_t GetIgnoreCount() const;
//------------------------------------------------------------------
/// Return the current hit count for all locations. @return
/// Return the current hit count for all locations. \return
/// The current hit count for all locations.
//------------------------------------------------------------------
uint32_t GetHitCount() const;
@ -396,7 +396,7 @@ public:
//------------------------------------------------------------------
/// Check the OneShot state.
/// @return
/// \return
/// \b true if the breakpoint is one shot, \b false otherwise.
//------------------------------------------------------------------
bool IsOneShot() const;
@ -409,21 +409,21 @@ public:
//------------------------------------------------------------------
/// Check the AutoContinue state.
/// @return
/// \return
/// \b true if the breakpoint is set to auto-continue, \b false otherwise.
//------------------------------------------------------------------
bool IsAutoContinue() const;
//------------------------------------------------------------------
/// Set the valid thread to be checked when the breakpoint is hit.
/// @param[in] thread_id
/// \param[in] thread_id
/// If this thread hits the breakpoint, we stop, otherwise not.
//------------------------------------------------------------------
void SetThreadID(lldb::tid_t thread_id);
//------------------------------------------------------------------
/// Return the current stop thread value.
/// @return
/// \return
/// The thread id for which the breakpoint hit will stop,
/// LLDB_INVALID_THREAD_ID for all threads.
//------------------------------------------------------------------
@ -444,16 +444,16 @@ public:
//------------------------------------------------------------------
/// Set the callback action invoked when the breakpoint is hit.
///
/// @param[in] callback
/// \param[in] callback
/// The method that will get called when the breakpoint is hit.
/// @param[in] baton
/// \param[in] baton
/// A void * pointer that will get passed back to the callback function.
/// @param[in] is_synchronous
/// \param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
/// handled on the public event thread after the stop has been posted.
///
/// @return
/// \return
/// \b true if the process should stop when you hit the breakpoint.
/// \b false if it should continue.
//------------------------------------------------------------------
@ -469,7 +469,7 @@ public:
//------------------------------------------------------------------
/// Set the breakpoint's condition.
///
/// @param[in] condition
/// \param[in] condition
/// The condition expression to evaluate when the breakpoint is hit.
/// Pass in nullptr to clear the condition.
//------------------------------------------------------------------
@ -478,7 +478,7 @@ public:
//------------------------------------------------------------------
/// Return a pointer to the text of the condition expression.
///
/// @return
/// \return
/// A pointer to the condition expression text, or nullptr if no
// condition has been set.
//------------------------------------------------------------------
@ -492,7 +492,7 @@ public:
/// Return the number of breakpoint locations that have resolved to actual
/// breakpoint sites.
///
/// @return
/// \return
/// The number locations resolved breakpoint sites.
//------------------------------------------------------------------
size_t GetNumResolvedLocations() const;
@ -500,7 +500,7 @@ public:
//------------------------------------------------------------------
/// Return whether this breakpoint has any resolved locations.
///
/// @return
/// \return
/// True if GetNumResolvedLocations > 0
//------------------------------------------------------------------
bool HasResolvedLocations() const;
@ -508,7 +508,7 @@ public:
//------------------------------------------------------------------
/// Return the number of breakpoint locations.
///
/// @return
/// \return
/// The number breakpoint locations.
//------------------------------------------------------------------
size_t GetNumLocations() const;
@ -516,14 +516,14 @@ public:
//------------------------------------------------------------------
/// Put a description of this breakpoint into the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// Stream into which to dump the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level,
bool show_locations = false);
@ -534,7 +534,7 @@ public:
/// breakpoint number. Mostly useful for internal breakpoints, where the
/// breakpoint number doesn't have meaning to the user.
///
/// @param[in] kind
/// \param[in] kind
/// New "kind" description.
//------------------------------------------------------------------
void SetBreakpointKind(const char *kind) { m_kind_description.assign(kind); }
@ -542,14 +542,14 @@ public:
//------------------------------------------------------------------
/// Return the "kind" description for a breakpoint.
///
/// @return
/// \return
/// The breakpoint kind, or nullptr if none is set.
//------------------------------------------------------------------
const char *GetBreakpointKind() const { return m_kind_description.c_str(); }
//------------------------------------------------------------------
/// Accessor for the breakpoint Target.
/// @return
/// \return
/// This breakpoint's Target.
//------------------------------------------------------------------
Target &GetTarget() { return m_target; }
@ -566,7 +566,7 @@ public:
/// matching locations. It should be initialized with 0 size by the API
/// client.
///
/// @return
/// \return
/// True if there is a match
///
/// The locations which match the filename and line_number in loc_coll.
@ -585,7 +585,7 @@ public:
///
/// Meant to be used by the BreakpointLocation class.
///
/// @return
/// \return
/// A pointer to this breakpoint's BreakpointOptions.
//------------------------------------------------------------------
BreakpointOptions *GetOptions();
@ -595,7 +595,7 @@ public:
///
/// Meant to be used by the BreakpointLocation class.
///
/// @return
/// \return
/// A pointer to this breakpoint's BreakpointOptions.
//------------------------------------------------------------------
const BreakpointOptions *GetOptions() const;
@ -605,13 +605,13 @@ public:
///
/// Meant to be used by the BreakpointLocation class.
///
/// @param[in] context
/// \param[in] context
/// Described the breakpoint event.
///
/// @param[in] bp_loc_id
/// \param[in] bp_loc_id
/// Which breakpoint location hit this breakpoint.
///
/// @return
/// \return
/// \b true if the target should stop at this breakpoint and \b false not.
//------------------------------------------------------------------
bool InvokeCallback(StoppointCallbackContext *context,
@ -696,22 +696,22 @@ protected:
/// there are convenience variants that make breakpoints for some common
/// cases.
///
/// @param[in] target
/// \param[in] target
/// The target in which the breakpoint will be set.
///
/// @param[in] filter_sp
/// \param[in] filter_sp
/// Shared pointer to the search filter that restricts the search domain of
/// the breakpoint.
///
/// @param[in] resolver_sp
/// \param[in] resolver_sp
/// Shared pointer to the resolver object that will determine breakpoint
/// matches.
///
/// @param hardware
/// \param hardware
/// If true, request a hardware breakpoint to be used to implement the
/// breakpoint locations.
///
/// @param resolve_indirect_symbols
/// \param resolve_indirect_symbols
/// If true, and the address of a given breakpoint location in this
/// breakpoint is set on an
/// indirect symbol (i.e. Symbol::IsIndirect returns true) then the actual

14
lldb/include/lldb/Breakpoint/BreakpointID.h
View File

@ -55,9 +55,9 @@ public:
/// breakpoint and location and returns a BreakpointID filled out with
/// the proper id and location.
///
/// @param[in] input
/// \param[in] input
/// A string containing JUST the breakpoint description.
/// @return
/// \return
/// If \p input was not a valid breakpoint ID string, returns
/// \b llvm::None. Otherwise returns a BreakpointID with members filled
/// out accordingly.
@ -70,12 +70,12 @@ public:
/// If it is a mal-formed breakpoint name, error will be set to an appropriate
/// error string.
///
/// @param[in] input
/// \param[in] input
/// A string containing JUST the breakpoint description.
/// @param[out] error
/// \param[out] error
/// If the name is a well-formed breakpoint name, set to success,
/// otherwise set to an error.
/// @return
/// \return
/// \b true if the name is a breakpoint name (as opposed to an ID or
/// range) false otherwise.
//------------------------------------------------------------------
@ -86,10 +86,10 @@ public:
/// a string containing the canonical description for the breakpoint
/// or breakpoint location.
///
/// @param[out] break_id
/// \param[out] break_id
/// This is the break id.
///
/// @param[out] break_loc_id
/// \param[out] break_loc_id
/// This is breakpoint location id, or LLDB_INVALID_BREAK_ID is no
/// location is to be specified.
//------------------------------------------------------------------

34
lldb/include/lldb/Breakpoint/BreakpointList.h
View File

@ -17,7 +17,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointList BreakpointList.h "lldb/Breakpoint/BreakpointList.h"
/// \class BreakpointList BreakpointList.h "lldb/Breakpoint/BreakpointList.h"
/// This class manages a list of breakpoints.
//----------------------------------------------------------------------
@ -35,10 +35,10 @@ public:
//------------------------------------------------------------------
/// Add the breakpoint \a bp_sp to the list.
///
/// @param[in] bp_sp
/// \param[in] bp_sp
/// Shared pointer to the breakpoint that will get added to the list.
///
/// @result
/// \result
/// Returns breakpoint id.
//------------------------------------------------------------------
lldb::break_id_t Add(lldb::BreakpointSP &bp_sp, bool notify);
@ -52,10 +52,10 @@ public:
/// Returns a shared pointer to the breakpoint with id \a breakID. Const
/// version.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint ID to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
@ -64,10 +64,10 @@ public:
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint with index \a i.
///
/// @param[in] i
/// \param[in] i
/// The breakpoint index to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL pointer if the
/// breakpoint doesn't exist.
//------------------------------------------------------------------
@ -76,10 +76,10 @@ public:
//------------------------------------------------------------------
/// Find all the breakpoints with a given name
///
/// @param[in] name
/// \param[in] name
/// The breakpoint name for which to search.
///
/// @result
/// \result
/// \bfalse if the input name was not a legal breakpoint name.
//------------------------------------------------------------------
bool FindBreakpointsByName(const char *name, BreakpointList &matching_bps);
@ -87,7 +87,7 @@ public:
//------------------------------------------------------------------
/// Returns the number of elements in this breakpoint list.
///
/// @result
/// \result
/// The number of elements.
//------------------------------------------------------------------
size_t GetSize() const {
@ -98,10 +98,10 @@ public:
//------------------------------------------------------------------
/// Removes the breakpoint given by \b breakID from this list.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint index to remove.
///
/// @result
/// \result
/// \b true if the breakpoint \a breakID was in the list.
//------------------------------------------------------------------
bool Remove(lldb::break_id_t breakID, bool notify);
@ -117,7 +117,7 @@ public:
/// This is typically used after the process calls exec, or anytime the
/// architecture of the target changes.
///
/// @param[in] arch
/// \param[in] arch
/// If valid, check the module in each breakpoint to make sure
/// they are compatible, otherwise, ignore architecture.
//------------------------------------------------------------------
@ -144,13 +144,13 @@ public:
/// modules in \a module_list. \a added says whether the module was loaded
/// or unloaded.
///
/// @param[in] module_list
/// \param[in] module_list
/// The module list that has changed.
///
/// @param[in] load
/// \param[in] load
/// \b true if the modules are loaded, \b false if unloaded.
///
/// @param[in] delete_locations
/// \param[in] delete_locations
/// If \a load is \b false, then delete breakpoint locations when
/// when updating breakpoints.
//------------------------------------------------------------------
@ -165,7 +165,7 @@ public:
//------------------------------------------------------------------
/// Sets the passed in Locker to hold the Breakpoint List mutex.
///
/// @param[in] locker
/// \param[in] locker
/// The locker object that is set.
//------------------------------------------------------------------
void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);

76
lldb/include/lldb/Breakpoint/BreakpointLocation.h
View File

@ -21,7 +21,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointLocation BreakpointLocation.h
/// \class BreakpointLocation BreakpointLocation.h
/// "lldb/Breakpoint/BreakpointLocation.h" Class that manages one unique (by
/// address) instance of a logical breakpoint.
//----------------------------------------------------------------------
@ -45,19 +45,19 @@ public:
~BreakpointLocation() override;
//------------------------------------------------------------------
/// Gets the load address for this breakpoint location @return
/// Gets the load address for this breakpoint location \return
/// Returns breakpoint location load address, \b
/// LLDB_INVALID_ADDRESS if not yet set.
//------------------------------------------------------------------
lldb::addr_t GetLoadAddress() const override;
//------------------------------------------------------------------
/// Gets the Address for this breakpoint location @return
/// Gets the Address for this breakpoint location \return
/// Returns breakpoint location Address.
//------------------------------------------------------------------
Address &GetAddress();
//------------------------------------------------------------------
/// Gets the Breakpoint that created this breakpoint location @return
/// Gets the Breakpoint that created this breakpoint location \return
/// Returns the owning breakpoint.
//------------------------------------------------------------------
Breakpoint &GetBreakpoint();
@ -71,7 +71,7 @@ public:
/// Side Effects: This may evaluate the breakpoint condition, and run the
/// callback. So this command may do a considerable amount of work.
///
/// @return
/// \return
/// \b true if this breakpoint location thinks we should stop,
/// \b false otherwise.
//------------------------------------------------------------------
@ -89,7 +89,7 @@ public:
//------------------------------------------------------------------
/// Check the Enable/Disable state.
///
/// @return
/// \return
/// \b true if the breakpoint is enabled, \b false if disabled.
//------------------------------------------------------------------
bool IsEnabled() const;
@ -102,7 +102,7 @@ public:
//------------------------------------------------------------------
/// Check the AutoContinue state.
///
/// @return
/// \return
/// \b true if the breakpoint is set to auto-continue, \b false if not.
//------------------------------------------------------------------
bool IsAutoContinue() const;
@ -110,7 +110,7 @@ public:
//------------------------------------------------------------------
/// Return the current Ignore Count.
///
/// @return
/// \return
/// The number of breakpoint hits to be ignored.
//------------------------------------------------------------------
uint32_t GetIgnoreCount();
@ -118,7 +118,7 @@ public:
//------------------------------------------------------------------
/// Set the breakpoint to ignore the next \a count breakpoint hits.
///
/// @param[in] count
/// \param[in] count
/// The number of breakpoint hits to ignore.
//------------------------------------------------------------------
void SetIgnoreCount(uint32_t n);
@ -129,14 +129,14 @@ public:
/// The callback will return a bool indicating whether the target should
/// stop at this breakpoint or not.
///
/// @param[in] callback
/// \param[in] callback
/// The method that will get called when the breakpoint is hit.
///
/// @param[in] callback_baton_sp
/// \param[in] callback_baton_sp
/// A shared pointer to a Baton that provides the void * needed
/// for the callback.
///
/// @see lldb_private::Baton
/// \see lldb_private::Baton
//------------------------------------------------------------------
void SetCallback(BreakpointHitCallback callback,
const lldb::BatonSP &callback_baton_sp, bool is_synchronous);
@ -149,7 +149,7 @@ public:
//------------------------------------------------------------------
/// Set the breakpoint location's condition.
///
/// @param[in] condition
/// \param[in] condition
/// The condition expression to evaluate when the breakpoint is hit.
//------------------------------------------------------------------
void SetCondition(const char *condition);
@ -157,7 +157,7 @@ public:
//------------------------------------------------------------------
/// Return a pointer to the text of the condition expression.
///
/// @return
/// \return
/// A pointer to the condition expression text, or nullptr if no
// condition has been set.
//------------------------------------------------------------------
@ -168,7 +168,7 @@ public:
//------------------------------------------------------------------
/// Set the valid thread to be checked when the breakpoint is hit.
///
/// @param[in] thread_id
/// \param[in] thread_id
/// If this thread hits the breakpoint, we stop, otherwise not.
//------------------------------------------------------------------
void SetThreadID(lldb::tid_t thread_id);
@ -194,7 +194,7 @@ public:
//------------------------------------------------------------------
/// Try to resolve the breakpoint site for this location.
///
/// @return
/// \return
/// \b true if we were successful at setting a breakpoint site,
/// \b false otherwise.
//------------------------------------------------------------------
@ -204,14 +204,14 @@ public:
/// Clear this breakpoint location's breakpoint site - for instance when
/// disabling the breakpoint.
///
/// @return
/// \return
/// \b true if there was a breakpoint site to be cleared, \b false
/// otherwise.
//------------------------------------------------------------------
bool ClearBreakpointSite();
//------------------------------------------------------------------
/// Return whether this breakpoint location has a breakpoint site. @return
/// Return whether this breakpoint location has a breakpoint site. \return
/// \b true if there was a breakpoint site for this breakpoint
/// location, \b false otherwise.
//------------------------------------------------------------------
@ -226,14 +226,14 @@ public:
//------------------------------------------------------------------
/// Print a description of this breakpoint location to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to print the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level);
@ -248,7 +248,7 @@ public:
/// It will create a copy of the containing breakpoint's options if that
/// hasn't been done already
///
/// @return
/// \return
/// A pointer to the breakpoint options.
//------------------------------------------------------------------
BreakpointOptions *GetLocationOptions();
@ -258,9 +258,9 @@ public:
/// This will return the options that have a setting for the specified
/// BreakpointOptions kind.
///
/// @param[in] kind
/// \param[in] kind
/// The particular option you are looking up.
/// @return
/// \return
/// A pointer to the containing breakpoint's options if this
/// location doesn't have its own copy.
//------------------------------------------------------------------
@ -274,13 +274,13 @@ public:
///
/// Meant to be used by the BreakpointLocation class.
///
/// @param[in] context
/// \param[in] context
/// Described the breakpoint event.
///
/// @param[in] bp_loc_id
/// \param[in] bp_loc_id
/// Which breakpoint location hit this breakpoint.
///
/// @return
/// \return
/// \b true if the target should stop at this breakpoint and \b
/// false not.
//------------------------------------------------------------------
@ -290,7 +290,7 @@ public:
/// Returns whether we should resolve Indirect functions in setting the
/// breakpoint site for this location.
///
/// @return
/// \return
/// \b true if the breakpoint SITE for this location should be set on the
/// resolved location for Indirect functions.
//------------------------------------------------------------------
@ -302,7 +302,7 @@ public:
/// Returns whether the address set in the breakpoint site for this location
/// was found by resolving an indirect symbol.
///
/// @return
/// \return
/// \b true or \b false as given in the description above.
//------------------------------------------------------------------
bool IsIndirect() { return m_is_indirect; }
@ -313,7 +313,7 @@ public:
/// Returns whether the address set in the breakpoint location was re-routed
/// to the target of a re-exported symbol.
///
/// @return
/// \return
/// \b true or \b false as given in the description above.
//------------------------------------------------------------------
bool IsReExported() { return m_is_reexported; }
@ -325,10 +325,10 @@ public:
/// locations". This is used when modules changed to determine if a Location
/// in the old module might be the "same as" the input location.
///
/// @param[in] location
/// \param[in] location
/// The location to compare against.
///
/// @return
/// \return
/// \b true or \b false as given in the description above.
//------------------------------------------------------------------
bool EquivalentToLocation(BreakpointLocation &location);
@ -342,10 +342,10 @@ protected:
//------------------------------------------------------------------
/// Set the breakpoint site for this location to \a bp_site_sp.
///
/// @param[in] bp_site_sp
/// \param[in] bp_site_sp
/// The breakpoint site we are setting for this location.
///
/// @return
/// \return
/// \b true if we were successful at setting the breakpoint site,
/// \b false otherwise.
//------------------------------------------------------------------
@ -371,17 +371,17 @@ private:
//------------------------------------------------------------------
/// Constructor.
///
/// @param[in] owner
/// \param[in] owner
/// A back pointer to the breakpoint that owns this location.
///
/// @param[in] addr
/// \param[in] addr
/// The Address defining this location.
///
/// @param[in] tid
/// \param[in] tid
/// The thread for which this breakpoint location is valid, or
/// LLDB_INVALID_THREAD_ID if it is valid for all threads.
///
/// @param[in] hardware
/// \param[in] hardware
/// \b true if a hardware breakpoint is requested.
//------------------------------------------------------------------

48
lldb/include/lldb/Breakpoint/BreakpointLocationCollection.h
View File

@ -26,11 +26,11 @@ public:
//------------------------------------------------------------------
/// Add the breakpoint \a bp_loc_sp to the list.
///
/// @param[in] bp_sp
/// \param[in] bp_sp
/// Shared pointer to the breakpoint location that will get added
/// to the list.
///
/// @result
/// \result
/// Returns breakpoint location id.
//------------------------------------------------------------------
void Add(const lldb::BreakpointLocationSP &bp_loc_sp);
@ -39,13 +39,13 @@ public:
/// Removes the breakpoint location given by \b breakID from this
/// list.
///
/// @param[in] break_id
/// \param[in] break_id
/// The breakpoint index to remove.
///
/// @param[in] break_loc_id
/// \param[in] break_loc_id
/// The breakpoint location index in break_id to remove.
///
/// @result
/// \result
/// \b true if the breakpoint was in the list.
//------------------------------------------------------------------
bool Remove(lldb::break_id_t break_id, lldb::break_id_t break_loc_id);
@ -54,13 +54,13 @@ public:
/// Returns a shared pointer to the breakpoint location with id \a
/// breakID.
///
/// @param[in] break_id
/// \param[in] break_id
/// The breakpoint ID to seek for.
///
/// @param[in] break_loc_id
/// \param[in] break_loc_id
/// The breakpoint location ID in \a break_id to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -71,13 +71,13 @@ public:
/// Returns a shared pointer to the breakpoint location with id \a
/// breakID, const version.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint location ID to seek for.
///
/// @param[in] break_loc_id
/// \param[in] break_loc_id
/// The breakpoint location ID in \a break_id to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -88,10 +88,10 @@ public:
/// Returns a shared pointer to the breakpoint location with index
/// \a i.
///
/// @param[in] i
/// \param[in] i
/// The breakpoint location index to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -101,10 +101,10 @@ public:
/// Returns a shared pointer to the breakpoint location with index
/// \a i, const version.
///
/// @param[in] i
/// \param[in] i
/// The breakpoint location index to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a NULL
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -113,7 +113,7 @@ public:
//------------------------------------------------------------------
/// Returns the number of elements in this breakpoint location list.
///
/// @result
/// \result
/// The number of elements.
//------------------------------------------------------------------
size_t GetSize() const { return m_break_loc_collection.size(); }
@ -122,13 +122,13 @@ public:
/// Enquires of all the breakpoint locations in this list whether
/// we should stop at a hit at \a breakID.
///
/// @param[in] context
/// \param[in] context
/// This contains the information about this stop.
///
/// @param[in] breakID
/// \param[in] breakID
/// This break ID that we hit.
///
/// @return
/// \return
/// \b true if we should stop, \b false otherwise.
//------------------------------------------------------------------
bool ShouldStop(StoppointCallbackContext *context);
@ -137,14 +137,14 @@ public:
/// Print a description of the breakpoint locations in this list
/// to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to print the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level);
@ -153,7 +153,7 @@ public:
/// thread specifiers, and if yes, is \a thread_id contained in any
/// of these specifiers.
///
/// @param[in] thread
/// \param[in] thread
/// The thread against which to test.
///
/// return
@ -165,7 +165,7 @@ public:
//------------------------------------------------------------------
/// Tell whether ALL the breakpoints in the location collection are internal.
///
/// @result
/// \result
/// \b true if all breakpoint locations are owned by internal breakpoints,
/// \b false otherwise.
//------------------------------------------------------------------

50
lldb/include/lldb/Breakpoint/BreakpointLocationList.h
View File

@ -20,7 +20,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointLocationList BreakpointLocationList.h
/// \class BreakpointLocationList BreakpointLocationList.h
/// "lldb/Breakpoint/BreakpointLocationList.h" This class is used by
/// Breakpoint to manage a list of breakpoint locations, each breakpoint
/// location in the list has a unique ID, and is unique by Address as well.
@ -45,10 +45,10 @@ public:
/// Returns a shared pointer to the breakpoint location at address \a addr -
/// const version.
///
/// @param[in] addr
/// \param[in] addr
/// The address to look for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a nullptr
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -58,10 +58,10 @@ public:
/// Returns a shared pointer to the breakpoint location with id \a breakID,
/// const version.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint location ID to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a nullptr
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -71,10 +71,10 @@ public:
/// Returns the breakpoint location id to the breakpoint location at address
/// \a addr.
///
/// @param[in] addr
/// \param[in] addr
/// The address to match.
///
/// @result
/// \result
/// The ID of the breakpoint location, or LLDB_INVALID_BREAK_ID.
//------------------------------------------------------------------
lldb::break_id_t FindIDByAddress(const Address &addr);
@ -83,14 +83,14 @@ public:
/// Returns a breakpoint location list of the breakpoint locations in the
/// module \a module. This list is allocated, and owned by the caller.
///
/// @param[in] module
/// \param[in] module
/// The module to seek in.
///
/// @param[in]
/// \param[in]
/// A breakpoint collection that gets any breakpoint locations
/// that match \a module appended to.
///
/// @result
/// \result
/// The number of matches
//------------------------------------------------------------------
size_t FindInModule(Module *module,
@ -99,10 +99,10 @@ public:
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint location with index \a i.
///
/// @param[in] i
/// \param[in] i
/// The breakpoint location index to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a nullptr
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -112,10 +112,10 @@ public:
/// Returns a shared pointer to the breakpoint location with index \a i,
/// const version.
///
/// @param[in] i
/// \param[in] i
/// The breakpoint location index to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint. May contain a nullptr
/// pointer if the breakpoint doesn't exist.
//------------------------------------------------------------------
@ -137,7 +137,7 @@ public:
/// Returns the number of breakpoint locations in this list with resolved
/// breakpoints.
///
/// @result
/// \result
/// Number of qualifying breakpoint locations.
//------------------------------------------------------------------
size_t GetNumResolvedLocations() const;
@ -145,7 +145,7 @@ public:
//------------------------------------------------------------------
/// Returns the number hit count of all locations in this list.
///
/// @result
/// \result
/// Hit count of all locations in this list.
//------------------------------------------------------------------
uint32_t GetHitCount() const;
@ -154,13 +154,13 @@ public:
/// Enquires of the breakpoint location in this list with ID \a breakID
/// whether we should stop.
///
/// @param[in] context
/// \param[in] context
/// This contains the information about this stop.
///
/// @param[in] breakID
/// \param[in] breakID
/// This break ID that we hit.
///
/// @return
/// \return
/// \b true if we should stop, \b false otherwise.
//------------------------------------------------------------------
bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID);
@ -168,7 +168,7 @@ public:
//------------------------------------------------------------------
/// Returns the number of elements in this breakpoint location list.
///
/// @result
/// \result
/// The number of elements.
//------------------------------------------------------------------
size_t GetSize() const { return m_locations.size(); }
@ -177,14 +177,14 @@ public:
/// Print a description of the breakpoint locations in this list to the
/// stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to print the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level);
@ -201,11 +201,11 @@ protected:
//------------------------------------------------------------------
/// Add the breakpoint \a bp_loc_sp to the list.
///
/// @param[in] bp_sp
/// \param[in] bp_sp
/// Shared pointer to the breakpoint location that will get
/// added to the list.
///
/// @result
/// \result
/// Returns breakpoint location id.
//------------------------------------------------------------------
lldb::BreakpointLocationSP Create(const Address &addr,

50
lldb/include/lldb/Breakpoint/BreakpointOptions.h
View File

@ -21,7 +21,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointOptions BreakpointOptions.h
/// \class BreakpointOptions BreakpointOptions.h
/// "lldb/Breakpoint/BreakpointOptions.h" Class that manages the options on a
/// breakpoint or breakpoint location.
//----------------------------------------------------------------------
@ -103,13 +103,13 @@ public:
/// This constructor allows you to specify all the breakpoint options except
/// the callback. That one is more complicated, and better to do by hand.
///
/// @param[in] condition
/// \param[in] condition
/// The expression which if it evaluates to \b true if we are to stop
///
/// @param[in] enabled
/// \param[in] enabled
/// Is this breakpoint enabled.
///
/// @param[in] ignore
/// \param[in] ignore
/// How many breakpoint hits we should ignore before stopping.
///
//------------------------------------------------------------------
@ -182,13 +182,13 @@ public:
//------------------------------------------------------------------
/// Adds a callback to the breakpoint option set.
///
/// @param[in] callback
/// \param[in] callback
/// The function to be called when the breakpoint gets hit.
///
/// @param[in] baton_sp
/// \param[in] baton_sp
/// A baton which will get passed back to the callback when it is invoked.
///
/// @param[in] synchronous
/// \param[in] synchronous
/// Whether this is a synchronous or asynchronous callback. See discussion
/// above.
//------------------------------------------------------------------
@ -202,10 +202,10 @@ public:
//------------------------------------------------------------------
/// Returns the command line commands for the callback on this breakpoint.
///
/// @param[out] command_list
/// \param[out] command_list
/// The commands will be appended to this list.
///
/// @return
/// \return
/// \btrue if the command callback is a command-line callback,
/// \bfalse otherwise.
//------------------------------------------------------------------
@ -222,7 +222,7 @@ public:
//------------------------------------------------------------------
/// Use this function to invoke the callback for a specific stop.
///
/// @param[in] context
/// \param[in] context
/// The context in which the callback is to be invoked. This includes the
/// stop event, the
/// execution context of the stop (since you might hit the same breakpoint
@ -230,13 +230,13 @@ public:
/// whether we are currently executing synchronous or asynchronous
/// callbacks.
///
/// @param[in] break_id
/// \param[in] break_id
/// The breakpoint ID that owns this option set.
///
/// @param[in] break_loc_id
/// \param[in] break_loc_id
/// The breakpoint location ID that owns this option set.
///
/// @return
/// \return
/// The callback return value.
//------------------------------------------------------------------
bool InvokeCallback(StoppointCallbackContext *context,
@ -246,7 +246,7 @@ public:
/// Used in InvokeCallback to tell whether it is the right time to run this
/// kind of callback.
///
/// @return
/// \return
/// The synchronicity of our callback.
//------------------------------------------------------------------
bool IsCallbackSynchronous() const { return m_callback_is_synchronous; }
@ -254,7 +254,7 @@ public:
//------------------------------------------------------------------
/// Fetch the baton from the callback.
///
/// @return
/// \return
/// The baton.
//------------------------------------------------------------------
Baton *GetBaton();
@ -262,7 +262,7 @@ public:
//------------------------------------------------------------------
/// Fetch a const version of the baton from the callback.
///
/// @return
/// \return
/// The baton.
//------------------------------------------------------------------
const Baton *GetBaton() const;
@ -273,7 +273,7 @@ public:
//------------------------------------------------------------------
/// Set the breakpoint option's condition.
///
/// @param[in] condition
/// \param[in] condition
/// The condition expression to evaluate when the breakpoint is hit.
//------------------------------------------------------------------
void SetCondition(const char *condition);
@ -281,7 +281,7 @@ public:
//------------------------------------------------------------------
/// Return a pointer to the text of the condition expression.
///
/// @return
/// \return
/// A pointer to the condition expression text, or nullptr if no
// condition has been set.
//------------------------------------------------------------------
@ -293,7 +293,7 @@ public:
//------------------------------------------------------------------
/// Check the Enable/Disable state.
/// @return
/// \return
/// \b true if the breakpoint is enabled, \b false if disabled.
//------------------------------------------------------------------
bool IsEnabled() const { return m_enabled; }
@ -308,7 +308,7 @@ public:
//------------------------------------------------------------------
/// Check the auto-continue state.
/// @return
/// \return
/// \b true if the breakpoint is set to auto-continue, \b false otherwise.
//------------------------------------------------------------------
bool IsAutoContinue() const { return m_auto_continue; }
@ -323,7 +323,7 @@ public:
//------------------------------------------------------------------
/// Check the One-shot state.
/// @return
/// \return
/// \b true if the breakpoint is one-shot, \b false otherwise.
//------------------------------------------------------------------
bool IsOneShot() const { return m_one_shot; }
@ -338,7 +338,7 @@ public:
//------------------------------------------------------------------
/// Set the breakpoint to ignore the next \a count breakpoint hits.
/// @param[in] count
/// \param[in] count
/// The number of breakpoint hits to ignore.
//------------------------------------------------------------------
@ -349,7 +349,7 @@ public:
//------------------------------------------------------------------
/// Return the current Ignore Count.
/// @return
/// \return
/// The number of breakpoint hits to be ignored.
//------------------------------------------------------------------
uint32_t GetIgnoreCount() const { return m_ignore_count; }
@ -357,7 +357,7 @@ public:
//------------------------------------------------------------------
/// Return the current thread spec for this option. This will return nullptr
/// if the no thread specifications have been set for this Option yet.
/// @return
/// \return
/// The thread specification pointer for this option, or nullptr if none
/// has
/// been set yet.
@ -388,7 +388,7 @@ public:
lldb::user_id_t break_loc_id);
//------------------------------------------------------------------
/// Set a callback based on BreakpointOptions::CommandData. @param[in]
/// Set a callback based on BreakpointOptions::CommandData. \param[in]
/// cmd_data
/// A UP holding the new'ed CommandData object.
/// The breakpoint will take ownership of pointer held by this object.

20
lldb/include/lldb/Breakpoint/BreakpointResolver.h
View File

@ -20,7 +20,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointResolver BreakpointResolver.h
/// \class BreakpointResolver BreakpointResolver.h
/// "lldb/Breakpoint/BreakpointResolver.h" This class works with SearchFilter
/// to resolve logical breakpoints to their of concrete breakpoint locations.
//----------------------------------------------------------------------
@ -45,12 +45,12 @@ public:
/// to make sense. It can be constructed without a breakpoint, but you have
/// to call SetBreakpoint before ResolveBreakpoint.
///
/// @param[in] bkpt
/// \param[in] bkpt
/// The breakpoint that owns this resolver.
/// @param[in] resolverType
/// \param[in] resolverType
/// The concrete breakpoint resolver type for this breakpoint.
///
/// @result
/// \result
/// Returns breakpoint location id.
//------------------------------------------------------------------
BreakpointResolver(Breakpoint *bkpt, unsigned char resolverType,
@ -65,7 +65,7 @@ public:
//------------------------------------------------------------------
/// This sets the breakpoint for this resolver.
///
/// @param[in] bkpt
/// \param[in] bkpt
/// The breakpoint that owns this resolver.
//------------------------------------------------------------------
void SetBreakpoint(Breakpoint *bkpt);
@ -75,7 +75,7 @@ public:
/// currently set for this breakpoint will have their offset adjusted when
/// this is called.
///
/// @param[in] offset
/// \param[in] offset
/// The offset to add to all locations.
//------------------------------------------------------------------
void SetOffset(lldb::addr_t offset);
@ -85,7 +85,7 @@ public:
/// currently set for this breakpoint will have their offset adjusted when
/// this is called.
///
/// @param[in] offset
/// \param[in] offset
/// The offset to add to all locations.
//------------------------------------------------------------------
lldb::addr_t GetOffset() const { return m_offset; }
@ -94,7 +94,7 @@ public:
/// In response to this method the resolver scans all the modules in the
/// breakpoint's target, and adds any new locations it finds.
///
/// @param[in] filter
/// \param[in] filter
/// The filter that will manage the search for this resolver.
//------------------------------------------------------------------
virtual void ResolveBreakpoint(SearchFilter &filter);
@ -103,7 +103,7 @@ public:
/// In response to this method the resolver scans the modules in the module
/// list \a modules, and adds any new locations it finds.
///
/// @param[in] filter
/// \param[in] filter
/// The filter that will manage the search for this resolver.
//------------------------------------------------------------------
virtual void ResolveBreakpointInModules(SearchFilter &filter,
@ -112,7 +112,7 @@ public:
//------------------------------------------------------------------
/// Prints a canonical description for the breakpoint to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// Stream to which the output is copied.
//------------------------------------------------------------------
void GetDescription(Stream *s) override = 0;

2
lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h
View File

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

2
lldb/include/lldb/Breakpoint/BreakpointResolverFileLine.h
View File

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

2
lldb/include/lldb/Breakpoint/BreakpointResolverFileRegex.h
View File

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

2
lldb/include/lldb/Breakpoint/BreakpointResolverName.h
View File

@ -18,7 +18,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointResolverName BreakpointResolverName.h
/// \class BreakpointResolverName BreakpointResolverName.h
/// "lldb/Breakpoint/BreakpointResolverName.h" This class sets breakpoints on
/// a given function name, either by exact match or by regular expression.
//----------------------------------------------------------------------

2
lldb/include/lldb/Breakpoint/BreakpointResolverScripted.h
View File

@ -17,7 +17,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointResolverScripted BreakpointResolverScripted.h
/// \class BreakpointResolverScripted BreakpointResolverScripted.h
/// "lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints
/// on a given Address. This breakpoint only takes once, and then it won't
/// attempt to reset itself.

38
lldb/include/lldb/Breakpoint/BreakpointSite.h
View File

@ -22,7 +22,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointSite BreakpointSite.h "lldb/Breakpoint/BreakpointSite.h"
/// \class BreakpointSite BreakpointSite.h "lldb/Breakpoint/BreakpointSite.h"
/// Class that manages the actual breakpoint that will be inserted into the
/// running program.
///
@ -105,7 +105,7 @@ public:
//------------------------------------------------------------------
/// Sets whether the current breakpoint site is enabled or not
///
/// @param[in] enabled
/// \param[in] enabled
/// \b true if the breakpoint is enabled, \b false otherwise.
//------------------------------------------------------------------
void SetEnabled(bool enabled);
@ -114,10 +114,10 @@ public:
/// Enquires of the breakpoint locations that produced this breakpoint site
/// whether we should stop at this location.
///
/// @param[in] context
/// \param[in] context
/// This contains the information about this stop.
///
/// @return
/// \return
/// \b true if we should stop, \b false otherwise.
//------------------------------------------------------------------
bool ShouldStop(StoppointCallbackContext *context) override;
@ -125,7 +125,7 @@ public:
//------------------------------------------------------------------
/// Standard Dump method
///
/// @param[in] context
/// \param[in] context
/// The stream to dump this output.
//------------------------------------------------------------------
void Dump(Stream *s) const override;
@ -134,7 +134,7 @@ public:
/// The "Owners" are the breakpoint locations that share this breakpoint
/// site. The method adds the \a owner to this breakpoint site's owner list.
///
/// @param[in] context
/// \param[in] context
/// \a owner is the Breakpoint Location to add.
//------------------------------------------------------------------
void AddOwner(const lldb::BreakpointLocationSP &owner);
@ -143,7 +143,7 @@ public:
/// This method returns the number of breakpoint locations currently located
/// at this breakpoint site.
///
/// @return
/// \return
/// The number of owners.
//------------------------------------------------------------------
size_t GetNumberOfOwners();
@ -154,9 +154,9 @@ public:
/// GetNumberOfOwners() - 1 so you can use this method to iterate over the
/// owners
///
/// @param[in] index
/// \param[in] index
/// The index in the list of owners for which you wish the owner location.
/// @return
/// \return
/// A shared pointer to the breakpoint location at that index.
//------------------------------------------------------------------
lldb::BreakpointLocationSP GetOwnerAtIndex(size_t idx);
@ -165,11 +165,11 @@ public:
/// This method copies the breakpoint site's owners into a new collection.
/// It does this while the owners mutex is locked.
///
/// @param[out] out_collection
/// \param[out] out_collection
/// The BreakpointLocationCollection into which to put the owners
/// of this breakpoint site.
///
/// @return
/// \return
/// The number of elements copied into out_collection.
//------------------------------------------------------------------
size_t CopyOwnersList(BreakpointLocationCollection &out_collection);
@ -179,7 +179,7 @@ public:
/// specifiers, and if yes, is \a thread contained in any of these
/// specifiers.
///
/// @param[in] thread
/// \param[in] thread
/// The thread against which to test.
///
/// return
@ -194,24 +194,24 @@ public:
/// BreakpointSite::Dump(Stream *) to get information about the breakpoint
/// site itself.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to print the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level);
//------------------------------------------------------------------
/// Tell whether a breakpoint has a location at this site.
///
/// @param[in] bp_id
/// \param[in] bp_id
/// The breakpoint id to query.
///
/// @result
/// \result
/// \b true if bp_id has a location that is at this site,
/// \b false otherwise.
//------------------------------------------------------------------
@ -221,7 +221,7 @@ public:
/// Tell whether ALL the breakpoints in the location collection are
/// internal.
///
/// @result
/// \result
/// \b true if all breakpoint locations are owned by internal breakpoints,
/// \b false otherwise.
//------------------------------------------------------------------
@ -245,7 +245,7 @@ private:
/// The method removes the owner at \a break_loc_id from this breakpoint
/// list.
///
/// @param[in] context
/// \param[in] context
/// \a break_loc_id is the Breakpoint Location to remove.
//------------------------------------------------------------------
size_t RemoveOwner(lldb::break_id_t break_id, lldb::break_id_t break_loc_id);

46
lldb/include/lldb/Breakpoint/BreakpointSiteList.h
View File

@ -18,7 +18,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class BreakpointSiteList BreakpointSiteList.h
/// \class BreakpointSiteList BreakpointSiteList.h
/// "lldb/Breakpoint/BreakpointSiteList.h" Class that manages lists of
/// BreakpointSite shared pointers.
//----------------------------------------------------------------------
@ -42,16 +42,16 @@ public:
//------------------------------------------------------------------
/// Add a BreakpointSite to the list.
///
/// @param[in] bp_site_sp
/// \param[in] bp_site_sp
/// A shared pointer to a breakpoint site being added to the list.
///
/// @return
/// \return
/// The ID of the BreakpointSite in the list.
//------------------------------------------------------------------
lldb::break_id_t Add(const lldb::BreakpointSiteSP &bp_site_sp);
//------------------------------------------------------------------
/// Standard Dump routine, doesn't do anything at present. @param[in] s
/// Standard Dump routine, doesn't do anything at present. \param[in] s
/// Stream into which to dump the description.
//------------------------------------------------------------------
void Dump(Stream *s) const;
@ -59,10 +59,10 @@ public:
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint site at address \a addr.
///
/// @param[in] addr
/// \param[in] addr
/// The address to look for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint site. May contain a NULL
/// pointer if no breakpoint site exists with a matching address.
//------------------------------------------------------------------
@ -71,10 +71,10 @@ public:
//------------------------------------------------------------------
/// Returns a shared pointer to the breakpoint site with id \a breakID.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint site ID to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint site. May contain a NULL pointer if
/// the
/// breakpoint doesn't exist.
@ -85,10 +85,10 @@ public:
/// Returns a shared pointer to the breakpoint site with id \a breakID -
/// const version.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint site ID to seek for.
///
/// @result
/// \result
/// A shared pointer to the breakpoint site. May contain a NULL pointer if
/// the
/// breakpoint doesn't exist.
@ -99,10 +99,10 @@ public:
/// Returns the breakpoint site id to the breakpoint site at address \a
/// addr.
///
/// @param[in] addr
/// \param[in] addr
/// The address to match.
///
/// @result
/// \result
/// The ID of the breakpoint site, or LLDB_INVALID_BREAK_ID.
//------------------------------------------------------------------
lldb::break_id_t FindIDByAddress(lldb::addr_t addr);
@ -111,13 +111,13 @@ public:
/// Returns whether the breakpoint site \a bp_site_id has \a bp_id
// as one of its owners.
///
/// @param[in] bp_site_id
/// \param[in] bp_site_id
/// The breakpoint site id to query.
///
/// @param[in] bp_id
/// \param[in] bp_id
/// The breakpoint id to look for in \a bp_site_id.
///
/// @result
/// \result
/// True if \a bp_site_id exists in the site list AND \a bp_id is one of the
/// owners of that site.
//------------------------------------------------------------------
@ -129,10 +129,10 @@ public:
//------------------------------------------------------------------
/// Removes the breakpoint site given by \b breakID from this list.
///
/// @param[in] breakID
/// \param[in] breakID
/// The breakpoint site index to remove.
///
/// @result
/// \result
/// \b true if the breakpoint site \a breakID was in the list.
//------------------------------------------------------------------
bool Remove(lldb::break_id_t breakID);
@ -140,10 +140,10 @@ public:
//------------------------------------------------------------------
/// Removes the breakpoint site at address \a addr from this list.
///
/// @param[in] addr
/// \param[in] addr
/// The address from which to remove a breakpoint site.
///
/// @result
/// \result
/// \b true if \a addr had a breakpoint site to remove from the list.
//------------------------------------------------------------------
bool RemoveByAddress(lldb::addr_t addr);
@ -158,13 +158,13 @@ public:
/// Enquires of the breakpoint site on in this list with ID \a breakID
/// whether we should stop for the breakpoint or not.
///
/// @param[in] context
/// \param[in] context
/// This contains the information about this stop.
///
/// @param[in] breakID
/// \param[in] breakID
/// This break ID that we hit.
///
/// @return
/// \return
/// \b true if we should stop, \b false otherwise.
//------------------------------------------------------------------
bool ShouldStop(StoppointCallbackContext *context, lldb::break_id_t breakID);
@ -172,7 +172,7 @@ public:
//------------------------------------------------------------------
/// Returns the number of elements in the list.
///
/// @result
/// \result
/// The number of elements.
//------------------------------------------------------------------
size_t GetSize() const {

2
lldb/include/lldb/Breakpoint/StoppointCallbackContext.h
View File

@ -15,7 +15,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class StoppointCallbackContext StoppointCallbackContext.h
/// \class StoppointCallbackContext StoppointCallbackContext.h
/// "lldb/Breakpoint/StoppointCallbackContext.h" Class holds the information
/// that a breakpoint callback needs to evaluate this stop.
//----------------------------------------------------------------------

18
lldb/include/lldb/Breakpoint/Watchpoint.h
View File

@ -100,7 +100,7 @@ public:
//------------------------------------------------------------------
/// Returns the WatchpointOptions structure set for this watchpoint.
///
/// @return
/// \return
/// A pointer to this watchpoint's WatchpointOptions.
//------------------------------------------------------------------
WatchpointOptions *GetOptions() { return &m_options; }
@ -108,16 +108,16 @@ public:
//------------------------------------------------------------------
/// Set the callback action invoked when the watchpoint is hit.
///
/// @param[in] callback
/// \param[in] callback
/// The method that will get called when the watchpoint is hit.
/// @param[in] callback_baton
/// \param[in] callback_baton
/// A void * pointer that will get passed back to the callback function.
/// @param[in] is_synchronous
/// \param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
/// handled on the public event thread after the stop has been posted.
///
/// @return
/// \return
/// \b true if the process should stop when you hit the watchpoint.
/// \b false if it should continue.
//------------------------------------------------------------------
@ -133,10 +133,10 @@ public:
//------------------------------------------------------------------
/// Invoke the callback action when the watchpoint is hit.
///
/// @param[in] context
/// \param[in] context
/// Described the watchpoint event.
///
/// @return
/// \return
/// \b true if the target should stop at this watchpoint and \b false not.
//------------------------------------------------------------------
bool InvokeCallback(StoppointCallbackContext *context);
@ -147,7 +147,7 @@ public:
//------------------------------------------------------------------
/// Set the watchpoint's condition.
///
/// @param[in] condition
/// \param[in] condition
/// The condition expression to evaluate when the watchpoint is hit.
/// Pass in nullptr to clear the condition.
//------------------------------------------------------------------
@ -156,7 +156,7 @@ public:
//------------------------------------------------------------------
/// Return a pointer to the text of the condition expression.
///
/// @return
/// \return
/// A pointer to the condition expression text, or nullptr if no
// condition has been set.
//------------------------------------------------------------------

56
lldb/include/lldb/Breakpoint/WatchpointList.h
View File

@ -19,7 +19,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class WatchpointList WatchpointList.h "lldb/Breakpoint/WatchpointList.h"
/// \class WatchpointList WatchpointList.h "lldb/Breakpoint/WatchpointList.h"
/// This class is used by Watchpoint to manage a list of watchpoints,
// each watchpoint in the list has a unique ID, and is unique by Address as
// well.
@ -46,10 +46,10 @@ public:
//------------------------------------------------------------------
/// Add a Watchpoint to the list.
///
/// @param[in] wp_sp
/// \param[in] wp_sp
/// A shared pointer to a watchpoint being added to the list.
///
/// @return
/// \return
/// The ID of the Watchpoint in the list.
//------------------------------------------------------------------
lldb::watch_id_t Add(const lldb::WatchpointSP &wp_sp, bool notify);
@ -68,10 +68,10 @@ public:
/// Returns a shared pointer to the watchpoint at address \a addr - const
/// version.
///
/// @param[in] addr
/// \param[in] addr
/// The address to look for.
///
/// @result
/// \result
/// A shared pointer to the watchpoint. May contain a NULL
/// pointer if the watchpoint doesn't exist.
//------------------------------------------------------------------
@ -81,10 +81,10 @@ public:
/// Returns a shared pointer to the watchpoint with watchpoint spec \a spec
/// - const version.
///
/// @param[in] spec
/// \param[in] spec
/// The watchpoint spec to look for.
///
/// @result
/// \result
/// A shared pointer to the watchpoint. May contain a NULL
/// pointer if the watchpoint doesn't exist.
//------------------------------------------------------------------
@ -94,10 +94,10 @@ public:
/// Returns a shared pointer to the watchpoint with id \a watchID, const
/// version.
///
/// @param[in] watchID
/// \param[in] watchID
/// The watchpoint location ID to seek for.
///
/// @result
/// \result
/// A shared pointer to the watchpoint. May contain a NULL
/// pointer if the watchpoint doesn't exist.
//------------------------------------------------------------------
@ -106,10 +106,10 @@ public:
//------------------------------------------------------------------
/// Returns the watchpoint id to the watchpoint at address \a addr.
///
/// @param[in] addr
/// \param[in] addr
/// The address to match.
///
/// @result
/// \result
/// The ID of the watchpoint, or LLDB_INVALID_WATCH_ID.
//------------------------------------------------------------------
lldb::watch_id_t FindIDByAddress(lldb::addr_t addr);
@ -118,10 +118,10 @@ public:
/// Returns the watchpoint id to the watchpoint with watchpoint spec \a
/// spec.
///
/// @param[in] spec
/// \param[in] spec
/// The watchpoint spec to match.
///
/// @result
/// \result
/// The ID of the watchpoint, or LLDB_INVALID_WATCH_ID.
//------------------------------------------------------------------
lldb::watch_id_t FindIDBySpec(std::string spec);
@ -129,10 +129,10 @@ public:
//------------------------------------------------------------------
/// Returns a shared pointer to the watchpoint with index \a i.
///
/// @param[in] i
/// \param[in] i
/// The watchpoint index to seek for.
///
/// @result
/// \result
/// A shared pointer to the watchpoint. May contain a NULL pointer if
/// the watchpoint doesn't exist.
//------------------------------------------------------------------
@ -142,10 +142,10 @@ public:
/// Returns a shared pointer to the watchpoint with index \a i, const
/// version.
///
/// @param[in] i
/// \param[in] i
/// The watchpoint index to seek for.
///
/// @result
/// \result
/// A shared pointer to the watchpoint. May contain a NULL pointer if
/// the watchpoint location doesn't exist.
//------------------------------------------------------------------
@ -154,10 +154,10 @@ public:
//------------------------------------------------------------------
/// Removes the watchpoint given by \b watchID from this list.
///
/// @param[in] watchID
/// \param[in] watchID
/// The watchpoint ID to remove.
///
/// @result
/// \result
/// \b true if the watchpoint \a watchID was in the list.
//------------------------------------------------------------------
bool Remove(lldb::watch_id_t watchID, bool notify);
@ -165,7 +165,7 @@ public:
//------------------------------------------------------------------
/// Returns the number hit count of all watchpoints in this list.
///
/// @result
/// \result
/// Hit count of all watchpoints in this list.
//------------------------------------------------------------------
uint32_t GetHitCount() const;
@ -174,13 +174,13 @@ public:
/// Enquires of the watchpoint in this list with ID \a watchID whether we
/// should stop.
///
/// @param[in] context
/// \param[in] context
/// This contains the information about this stop.
///
/// @param[in] watchID
/// \param[in] watchID
/// This watch ID that we hit.
///
/// @return
/// \return
/// \b true if we should stop, \b false otherwise.
//------------------------------------------------------------------
bool ShouldStop(StoppointCallbackContext *context, lldb::watch_id_t watchID);
@ -188,7 +188,7 @@ public:
//------------------------------------------------------------------
/// Returns the number of elements in this watchpoint list.
///
/// @result
/// \result
/// The number of elements.
//------------------------------------------------------------------
size_t GetSize() const {
@ -199,14 +199,14 @@ public:
//------------------------------------------------------------------
/// Print a description of the watchpoints in this list to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to print the description.
///
/// @param[in] level
/// \param[in] level
/// The description level that indicates the detail level to
/// provide.
///
/// @see lldb::DescriptionLevel
/// \see lldb::DescriptionLevel
//------------------------------------------------------------------
void GetDescription(Stream *s, lldb::DescriptionLevel level);
@ -217,7 +217,7 @@ public:
//------------------------------------------------------------------
/// Sets the passed in Locker to hold the Watchpoint List mutex.
///
/// @param[in] locker
/// \param[in] locker
/// The locker object that is set.
//------------------------------------------------------------------
void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);

30
lldb/include/lldb/Breakpoint/WatchpointOptions.h
View File

@ -19,7 +19,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class WatchpointOptions WatchpointOptions.h
/// \class WatchpointOptions WatchpointOptions.h
/// "lldb/Breakpoint/WatchpointOptions.h" Class that manages the options on a
/// watchpoint.
//----------------------------------------------------------------------
@ -40,14 +40,14 @@ public:
//------------------------------------------------------------------
/// This constructor allows you to specify all the watchpoint options.
///
/// @param[in] callback
/// \param[in] callback
/// This is the plugin for some code that gets run, returns \b true if we
/// are to stop.
///
/// @param[in] baton
/// \param[in] baton
/// Client data that will get passed to the callback.
///
/// @param[in] thread_id
/// \param[in] thread_id
/// Only stop if \a thread_id hits the watchpoint.
//------------------------------------------------------------------
WatchpointOptions(WatchpointHitCallback callback, void *baton,
@ -93,13 +93,13 @@ public:
//------------------------------------------------------------------
/// Adds a callback to the watchpoint option set.
///
/// @param[in] callback
/// \param[in] callback
/// The function to be called when the watchpoint gets hit.
///
/// @param[in] baton_sp
/// \param[in] baton_sp
/// A baton which will get passed back to the callback when it is invoked.
///
/// @param[in] synchronous
/// \param[in] synchronous
/// Whether this is a synchronous or asynchronous callback. See discussion
/// above.
//------------------------------------------------------------------
@ -117,7 +117,7 @@ public:
//------------------------------------------------------------------
/// Use this function to invoke the callback for a specific stop.
///
/// @param[in] context
/// \param[in] context
/// The context in which the callback is to be invoked. This includes the
/// stop event, the
/// execution context of the stop (since you might hit the same watchpoint
@ -125,10 +125,10 @@ public:
/// whether we are currently executing synchronous or asynchronous
/// callbacks.
///
/// @param[in] watch_id
/// \param[in] watch_id
/// The watchpoint ID that owns this option set.
///
/// @return
/// \return
/// The callback return value.
//------------------------------------------------------------------
bool InvokeCallback(StoppointCallbackContext *context,
@ -138,7 +138,7 @@ public:
/// Used in InvokeCallback to tell whether it is the right time to run this
/// kind of callback.
///
/// @return
/// \return
/// The synchronicity of our callback.
//------------------------------------------------------------------
bool IsCallbackSynchronous() { return m_callback_is_synchronous; }
@ -146,7 +146,7 @@ public:
//------------------------------------------------------------------
/// Fetch the baton from the callback.
///
/// @return
/// \return
/// The baton.
//------------------------------------------------------------------
Baton *GetBaton();
@ -154,7 +154,7 @@ public:
//------------------------------------------------------------------
/// Fetch a const version of the baton from the callback.
///
/// @return
/// \return
/// The baton.
//------------------------------------------------------------------
const Baton *GetBaton() const;
@ -162,7 +162,7 @@ public:
//------------------------------------------------------------------
/// Return the current thread spec for this option. This will return nullptr
/// if the no thread specifications have been set for this Option yet.
/// @return
/// \return
/// The thread specification pointer for this option, or nullptr if none
/// has
/// been set yet.
@ -192,7 +192,7 @@ public:
//------------------------------------------------------------------
/// This is the default empty callback.
/// @return
/// \return
/// The thread id for which the watchpoint hit will stop,
/// LLDB_INVALID_THREAD_ID for all threads.
//------------------------------------------------------------------

80
lldb/include/lldb/Core/Address.h
View File

@ -51,7 +51,7 @@ struct LineEntry;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Address Address.h "lldb/Core/Address.h"
/// \class Address Address.h "lldb/Core/Address.h"
/// A section + offset based address class.
///
/// The Address class allows addresses to be relative to a section that can
@ -59,8 +59,8 @@ namespace lldb_private {
/// frameworks) being loaded at different addresses than the addresses found
/// in the object file that represents them on disk. There are currently two
/// types of addresses for a section:
/// @li file addresses
/// @li load addresses
/// \li file addresses
/// \li load addresses
///
/// File addresses represent the virtual addresses that are in the "on disk"
/// object files. These virtual addresses are converted to be relative to
@ -140,7 +140,7 @@ public:
///
/// Makes a copy of the another Address object \a rhs.
///
/// @param[in] rhs
/// \param[in] rhs
/// A const Address object reference to copy.
//------------------------------------------------------------------
Address(const Address &rhs)
@ -151,11 +151,11 @@ public:
///
/// Initialize the address with the supplied \a section and \a offset.
///
/// @param[in] section
/// \param[in] section
/// A section pointer to a valid lldb::Section, or NULL if the
/// address doesn't have a section or will get resolved later.
///
/// @param[in] offset
/// \param[in] offset
/// The offset in bytes into \a section.
//------------------------------------------------------------------
Address(const lldb::SectionSP &section_sp, lldb::addr_t offset)
@ -172,10 +172,10 @@ public:
/// Initialize and resolve the address with the supplied virtual address \a
/// file_addr.
///
/// @param[in] file_addr
/// \param[in] file_addr
/// A virtual file address.
///
/// @param[in] section_list
/// \param[in] section_list
/// A list of sections, one of which may contain the \a file_addr.
//------------------------------------------------------------------
Address(lldb::addr_t file_addr, const SectionList *section_list);
@ -188,10 +188,10 @@ public:
/// Copies the address value from another Address object \a rhs into \a this
/// object.
///
/// @param[in] rhs
/// \param[in] rhs
/// A const Address object reference to copy.
///
/// @return
/// \return
/// A const Address object reference to \a this.
//------------------------------------------------------------------
#ifndef SWIG
@ -212,16 +212,16 @@ public:
//------------------------------------------------------------------
/// Compare two Address objects.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const Address object reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const Address object reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
/// \return
/// \li -1 if lhs < rhs
/// \li 0 if lhs == rhs
/// \li 1 if lhs > rhs
//------------------------------------------------------------------
static int CompareFileAddress(const Address &lhs, const Address &rhs);
@ -248,22 +248,22 @@ public:
/// \a s. There are many ways to display a section offset based address, and
/// \a style lets the user choose.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] style
/// \param[in] style
/// The display style for the address.
///
/// @param[in] fallback_style
/// \param[in] fallback_style
/// The display style for the address.
///
/// @return
/// \return
/// Returns \b true if the address was able to be displayed.
/// File and load addresses may be unresolved and it may not be
/// possible to display a valid value, \b false will be returned
/// in such cases.
///
/// @see Address::DumpStyle
/// \see Address::DumpStyle
//------------------------------------------------------------------
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
DumpStyle fallback_style = DumpStyleInvalid,
@ -278,7 +278,7 @@ public:
/// addresses, then it has a virtual address that is relative to unique
/// section in the object file.
///
/// @return
/// \return
/// The valid file virtual address, or LLDB_INVALID_ADDRESS if
/// the address doesn't have a file virtual address (image is
/// from memory only with no representation on disk).
@ -295,7 +295,7 @@ public:
/// loaded/unloaded. If a section is loaded, then the load address can be
/// resolved.
///
/// @return
/// \return
/// The valid load virtual address, or LLDB_INVALID_ADDRESS if
/// the address is currently not loaded.
//------------------------------------------------------------------
@ -311,7 +311,7 @@ public:
/// target) that are required when changing the program counter to setting a
/// return address.
///
/// @return
/// \return
/// The valid load virtual address, or LLDB_INVALID_ADDRESS if
/// the address is currently not loaded.
//------------------------------------------------------------------
@ -330,7 +330,7 @@ public:
/// special purposes. The result of this function can be used to safely
/// write a software breakpoint trap to memory.
///
/// @return
/// \return
/// The valid load virtual address with extra callable bits
/// removed, or LLDB_INVALID_ADDRESS if the address is currently
/// not loaded.
@ -342,7 +342,7 @@ public:
//------------------------------------------------------------------
/// Get the section relative offset value.
///
/// @return
/// \return
/// The current offset, or LLDB_INVALID_ADDRESS if this address
/// doesn't contain a valid offset.
//------------------------------------------------------------------
@ -357,7 +357,7 @@ public:
/// returns true if the current value contained in this object is section
/// offset based.
///
/// @return
/// \return
/// Returns \b true if the address has a valid section and
/// offset, \b false otherwise.
//------------------------------------------------------------------
@ -372,7 +372,7 @@ public:
/// offset (for section offset based addresses), or just a valid offset
/// (for absolute addresses that have no section).
///
/// @return
/// \return
/// Returns \b true if the offset is valid, \b false
/// otherwise.
//------------------------------------------------------------------
@ -381,7 +381,7 @@ public:
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
//------------------------------------------------------------------
size_t MemorySize() const;
@ -392,7 +392,7 @@ public:
/// Given a list of sections, attempt to resolve \a addr as an offset into
/// one of the file sections.
///
/// @return
/// \return
/// Returns \b true if \a addr was able to be resolved, \b false
/// otherwise.
//------------------------------------------------------------------
@ -407,19 +407,19 @@ public:
/// valid section and offset. Else this address object will have no section
/// (NULL) and the offset will be \a load_addr.
///
/// @param[in] load_addr
/// \param[in] load_addr
/// A load address from a current process.
///
/// @param[in] target
/// \param[in] target
/// The target to use when trying resolve the address into
/// a section + offset. The Target's SectionLoadList object
/// is used to resolve the address.
///
/// @param[in] allow_section_end
/// \param[in] allow_section_end
/// If true, treat an address pointing to the end of the module as
/// belonging to that module.
///
/// @return
/// \return
/// Returns \b true if the load address was resolved to be
/// section/offset, \b false otherwise. It is often ok for an
/// address no not resolve to a section in a module, this often
@ -439,7 +439,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the module for this address.
///
/// @return
/// \return
/// Returns the Module pointer that this address is an offset
/// in, or NULL if this address doesn't belong in a module, or
/// isn't resolved yet.
@ -449,7 +449,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the section.
///
/// @return
/// \return
/// Returns the const lldb::Section pointer that this address is an
/// offset in, or NULL if this address is absolute.
//------------------------------------------------------------------
@ -458,10 +458,10 @@ public:
//------------------------------------------------------------------
/// Set accessor for the offset.
///
/// @param[in] offset
/// \param[in] offset
/// A new offset value for this object.
///
/// @return
/// \return
/// Returns \b true if the offset changed, \b false otherwise.
//------------------------------------------------------------------
bool SetOffset(lldb::addr_t offset) {
@ -486,7 +486,7 @@ public:
//------------------------------------------------------------------
/// Set accessor for the section.
///
/// @param[in] section
/// \param[in] section
/// A new lldb::Section pointer to use as the section base. Can
/// be NULL for absolute addresses that are not relative to
/// any section.
@ -505,7 +505,7 @@ public:
/// can reconstruct their symbol context by looking up the address in the
/// module found in the section.
///
/// @see SymbolContextScope::CalculateSymbolContext(SymbolContext*)
/// \see SymbolContextScope::CalculateSymbolContext(SymbolContext*)
//------------------------------------------------------------------
uint32_t CalculateSymbolContext(SymbolContext *sc,
lldb::SymbolContextItem resolve_scope =

62
lldb/include/lldb/Core/AddressRange.h
View File

@ -28,7 +28,7 @@ class Target;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class AddressRange AddressRange.h "lldb/Core/AddressRange.h"
/// \class AddressRange AddressRange.h "lldb/Core/AddressRange.h"
/// A section + offset based address range class.
//----------------------------------------------------------------------
class AddressRange {
@ -47,14 +47,14 @@ public:
/// Initialize the address with the supplied \a section, \a offset and \a
/// byte_size.
///
/// @param[in] section
/// \param[in] section
/// A section pointer to a valid lldb::Section, or NULL if the
/// address doesn't have a section or will get resolved later.
///
/// @param[in] offset
/// \param[in] offset
/// The offset in bytes into \a section.
///
/// @param[in] byte_size
/// \param[in] byte_size
/// The size in bytes of the address range.
//------------------------------------------------------------------
AddressRange(const lldb::SectionSP &section, lldb::addr_t offset,
@ -66,13 +66,13 @@ public:
/// Initialize and resolve the address with the supplied virtual address \a
/// file_addr, and byte size \a byte_size.
///
/// @param[in] file_addr
/// \param[in] file_addr
/// A virtual address.
///
/// @param[in] byte_size
/// \param[in] byte_size
/// The size in bytes of the address range.
///
/// @param[in] section_list
/// \param[in] section_list
/// A list of sections, one of which may contain the \a vaddr.
//------------------------------------------------------------------
AddressRange(lldb::addr_t file_addr, lldb::addr_t byte_size,
@ -84,10 +84,10 @@ public:
/// Initialize by copying the section offset address in \a so_addr, and
/// setting the byte size to \a byte_size.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object.
///
/// @param[in] byte_size
/// \param[in] byte_size
/// The size in bytes of the address range.
//------------------------------------------------------------------
AddressRange(const Address &so_addr, lldb::addr_t byte_size);
@ -110,10 +110,10 @@ public:
//------------------------------------------------------------------
/// Check if a section offset address is contained in this range.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object reference.
///
/// @return
/// \return
/// Returns \b true if \a so_addr is contained in this range,
/// \b false otherwise.
//------------------------------------------------------------------
@ -123,10 +123,10 @@ public:
//------------------------------------------------------------------
/// Check if a section offset address is contained in this range.
///
/// @param[in] so_addr_ptr
/// \param[in] so_addr_ptr
/// A section offset address object pointer.
///
/// @return
/// \return
/// Returns \b true if \a so_addr is contained in this range,
/// \b false otherwise.
//------------------------------------------------------------------
@ -137,10 +137,10 @@ public:
/// Check if a section offset \a so_addr when represented as a file address
/// is contained within this object's file address range.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object reference.
///
/// @return
/// \return
/// Returns \b true if both \a this and \a so_addr have
/// resolvable file address values and \a so_addr is contained
/// in the address range, \b false otherwise.
@ -151,10 +151,10 @@ public:
/// Check if the resolved file address \a file_addr is contained within this
/// object's file address range.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object reference.
///
/// @return
/// \return
/// Returns \b true if both \a this has a resolvable file
/// address value and \a so_addr is contained in the address
/// range, \b false otherwise.
@ -165,10 +165,10 @@ public:
/// Check if a section offset \a so_addr when represented as a load address
/// is contained within this object's load address range.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object reference.
///
/// @return
/// \return
/// Returns \b true if both \a this and \a so_addr have
/// resolvable load address values and \a so_addr is contained
/// in the address range, \b false otherwise.
@ -179,10 +179,10 @@ public:
/// Check if the resolved load address \a load_addr is contained within this
/// object's load address range.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object reference.
///
/// @return
/// \return
/// Returns \b true if both \a this has a resolvable load
/// address value and \a so_addr is contained in the address
/// range, \b false otherwise.
@ -197,19 +197,19 @@ public:
/// range, and \a style lets the user choose how the base address gets
/// displayed.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] style
/// \param[in] style
/// The display style for the address.
///
/// @return
/// \return
/// Returns \b true if the address was able to be displayed.
/// File and load addresses may be unresolved and it may not be
/// possible to display a valid value, \b false will be returned
/// in such cases.
///
/// @see Address::DumpStyle
/// \see Address::DumpStyle
//------------------------------------------------------------------
bool
Dump(Stream *s, Target *target, Address::DumpStyle style,
@ -224,7 +224,7 @@ public:
/// The debug description contains verbose internal state such and pointer
/// values, reference counts, etc.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void DumpDebug(Stream *s) const;
@ -232,7 +232,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the base address of the range.
///
/// @return
/// \return
/// A reference to the base address object.
//------------------------------------------------------------------
Address &GetBaseAddress() { return m_base_addr; }
@ -240,7 +240,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the base address of the range.
///
/// @return
/// \return
/// A const reference to the base address object.
//------------------------------------------------------------------
const Address &GetBaseAddress() const { return m_base_addr; }
@ -248,7 +248,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the byte size of this range.
///
/// @return
/// \return
/// The size in bytes of this address range.
//------------------------------------------------------------------
lldb::addr_t GetByteSize() const { return m_byte_size; }
@ -256,7 +256,7 @@ public:
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
//------------------------------------------------------------------
size_t MemorySize() const {
@ -268,7 +268,7 @@ public:
//------------------------------------------------------------------
/// Set accessor for the byte size of this range.
///
/// @param[in] byte_size
/// \param[in] byte_size
/// The new size in bytes of this address range.
//------------------------------------------------------------------
void SetByteSize(lldb::addr_t byte_size) { m_byte_size = byte_size; }

2
lldb/include/lldb/Core/AddressResolver.h
View File

@ -25,7 +25,7 @@ class Stream;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class AddressResolver AddressResolver.h "lldb/Core/AddressResolver.h"
/// \class AddressResolver AddressResolver.h "lldb/Core/AddressResolver.h"
/// This class works with SearchFilter to resolve function names and source
/// file locations to their concrete addresses.
//----------------------------------------------------------------------

2
lldb/include/lldb/Core/AddressResolverFileLine.h
View File

@ -29,7 +29,7 @@ class SymbolContext;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class AddressResolverFileLine AddressResolverFileLine.h
/// \class AddressResolverFileLine AddressResolverFileLine.h
/// "lldb/Core/AddressResolverFileLine.h" This class finds address for source
/// file and line. Optionally, it will look for inlined instances of the file
/// and line specification.

2
lldb/include/lldb/Core/AddressResolverName.h
View File

@ -28,7 +28,7 @@ class SymbolContext;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class AddressResolverName AddressResolverName.h
/// \class AddressResolverName AddressResolverName.h
/// "lldb/Core/AddressResolverName.h" This class finds addresses for a given
/// function name, either by exact match or by regular expression.
//----------------------------------------------------------------------

70
lldb/include/lldb/Core/Communication.h
View File

@ -38,7 +38,7 @@ class Status;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Communication Communication.h "lldb/Core/Communication.h" An
/// \class Communication Communication.h "lldb/Core/Communication.h" An
/// abstract communications class.
///
/// Communication is an class that handles data communication between two data
@ -59,8 +59,8 @@ namespace lldb_private {
/// "eBroadcastBit" below).
///
/// There are two modes in which communications can occur:
/// @li single-threaded
/// @li multi-threaded
/// \li single-threaded
/// \li multi-threaded
///
/// In single-threaded mode, all reads and writes happen synchronously on the
/// calling thread.
@ -119,7 +119,7 @@ public:
/// Construct the Communication object with the specified name for the
/// Broadcaster that this object inherits from.
///
/// @param[in] broadcaster_name
/// \param[in] broadcaster_name
/// The name of the broadcaster object. This name should be as
/// complete as possible to uniquely identify this object. The
/// broadcaster name can be updated after the connect function
@ -140,37 +140,37 @@ public:
/// Connect using the current connection by passing \a url to its connect
/// function. string.
///
/// @param[in] url
/// \param[in] url
/// A string that contains all information needed by the
/// subclass to connect to another client.
///
/// @return
/// \return
/// \b True if the connect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
/// @see bool Connection::Connect (const char *url);
/// \see Status& Communication::GetError ();
/// \see bool Connection::Connect (const char *url);
//------------------------------------------------------------------
lldb::ConnectionStatus Connect(const char *url, Status *error_ptr);
//------------------------------------------------------------------
/// Disconnect the communications connection if one is currently connected.
///
/// @return
/// \return
/// \b True if the disconnect succeeded, \b false otherwise. The
/// internal error object should be filled in with an
/// appropriate value based on the result of this function.
///
/// @see Status& Communication::GetError ();
/// @see bool Connection::Disconnect ();
/// \see Status& Communication::GetError ();
/// \see bool Connection::Disconnect ();
//------------------------------------------------------------------
lldb::ConnectionStatus Disconnect(Status *error_ptr = nullptr);
//------------------------------------------------------------------
/// Check if the connection is valid.
///
/// @return
/// \return
/// \b True if this object is currently connected, \b false
/// otherwise.
//------------------------------------------------------------------
@ -193,21 +193,21 @@ public:
/// event. If this function consumes all of the bytes in the cache, it will
/// reset the \a eBroadcastBitReadThreadGotBytes event bit.
///
/// @param[in] dst
/// \param[in] dst
/// A destination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// \param[in] dst_len
/// The number of bytes to attempt to read, and also the max
/// number of bytes that can be placed into \a dst.
///
/// @param[in] timeout
/// \param[in] timeout
/// A timeout value or llvm::None for no timeout.
///
/// @return
/// \return
/// The number of bytes actually read.
///
/// @see size_t Connection::Read (void *, size_t);
/// \see size_t Connection::Read (void *, size_t);
//------------------------------------------------------------------
size_t Read(void *dst, size_t dst_len, const Timeout<std::micro> &timeout,
lldb::ConnectionStatus &status, Status *error_ptr);
@ -218,15 +218,15 @@ public:
///
/// Subclasses must override this function.
///
/// @param[in] src
/// \param[in] src
/// A source buffer that must be at least \a src_len bytes
/// long.
///
/// @param[in] src_len
/// \param[in] src_len
/// The number of bytes to attempt to write, and also the
/// number of bytes are currently available in \a src.
///
/// @return
/// \return
/// The number of bytes actually Written.
//------------------------------------------------------------------
size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
@ -240,10 +240,10 @@ public:
/// connection without any interruption to the client. It also allows the
/// Communication class to be subclassed for packet based communication.
///
/// @param[in] connection
/// \param[in] connection
/// A connection that this class will own and destroy.
///
/// @see
/// \see
/// class Connection
//------------------------------------------------------------------
void SetConnection(Connection *connection);
@ -264,12 +264,12 @@ public:
/// default action of caching the bytes and broadcasting a \b
/// eBroadcastBitReadThreadGotBytes event.
///
/// @return
/// \return
/// \b True if the read thread was successfully started, \b
/// false otherwise.
///
/// @see size_t Connection::Read (void *, size_t);
/// @see void Communication::AppendBytesToCache (const uint8_t * bytes,
/// \see size_t Connection::Read (void *, size_t);
/// \see void Communication::AppendBytesToCache (const uint8_t * bytes,
/// size_t len, bool broadcast);
//------------------------------------------------------------------
virtual bool StartReadThread(Status *error_ptr = nullptr);
@ -277,7 +277,7 @@ public:
//------------------------------------------------------------------
/// Stops the read thread by cancelling it.
///
/// @return
/// \return
/// \b True if the read thread was successfully canceled, \b
/// false otherwise.
//------------------------------------------------------------------
@ -287,7 +287,7 @@ public:
//------------------------------------------------------------------
/// Checks if there is a currently running read thread.
///
/// @return
/// \return
/// \b True if the read thread is running, \b false otherwise.
//------------------------------------------------------------------
bool ReadThreadIsRunning();
@ -298,13 +298,13 @@ public:
/// is received it will append the available data to the internal cache and
/// broadcast a \b eBroadcastBitReadThreadGotBytes event.
///
/// @param[in] comm_ptr
/// \param[in] comm_ptr
/// A pointer to an instance of this class.
///
/// @return
/// \return
/// \b NULL.
///
/// @see void Communication::ReadThreadGotBytes (const uint8_t *, size_t);
/// \see void Communication::ReadThreadGotBytes (const uint8_t *, size_t);
//------------------------------------------------------------------
static lldb::thread_result_t ReadThread(lldb::thread_arg_t comm_ptr);
@ -367,11 +367,11 @@ protected:
/// of the \a eBroadcastBitReadThreadGotBytes event by setting \a broadcast
/// to false.
///
/// @param[in] src
/// \param[in] src
/// A source buffer that must be at least \a src_len bytes
/// long.
///
/// @param[in] src_len
/// \param[in] src_len
/// The number of bytes to append to the cache.
//------------------------------------------------------------------
virtual void AppendBytesToCache(const uint8_t *src, size_t src_len,
@ -383,16 +383,16 @@ protected:
/// data cache, the \b eBroadcastBitReadThreadGotBytes event will be reset
/// to signify no more bytes are available.
///
/// @param[in] dst
/// \param[in] dst
/// A destination buffer that must be at least \a dst_len bytes
/// long.
///
/// @param[in] dst_len
/// \param[in] dst_len
/// The number of bytes to attempt to read from the cache,
/// and also the max number of bytes that can be placed into
/// \a dst.
///
/// @return
/// \return
/// The number of bytes extracted from the data cache.
//------------------------------------------------------------------
size_t GetCachedBytes(void *dst, size_t dst_len);

4
lldb/include/lldb/Core/Debugger.h
View File

@ -75,7 +75,7 @@ class raw_ostream;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Debugger Debugger.h "lldb/Core/Debugger.h"
/// \class Debugger Debugger.h "lldb/Core/Debugger.h"
/// A class to manage flag bits.
///
/// Provides a global root objects for the debugger core.
@ -176,7 +176,7 @@ public:
/// debugger shared instance to control where targets get created and to
/// allow for tracking and searching for targets based on certain criteria.
///
/// @return
/// \return
/// A global shared target list.
//------------------------------------------------------------------
TargetList &GetTargetList() { return m_target_list; }

18
lldb/include/lldb/Core/Disassembler.h
View File

@ -115,32 +115,32 @@ public:
/// Print the (optional) address, (optional) bytes, opcode,
/// operands, and instruction comments to a stream.
///
/// @param[in] s
/// \param[in] s
/// The Stream to add the text to.
///
/// @param[in] show_address
/// \param[in] show_address
/// Whether the address (using disassembly_addr_format_spec formatting)
/// should be printed.
///
/// @param[in] show_bytes
/// \param[in] show_bytes
/// Whether the bytes of the assembly instruction should be printed.
///
/// @param[in] max_opcode_byte_size
/// \param[in] max_opcode_byte_size
/// The size (in bytes) of the largest instruction in the list that
/// we are printing (for text justification/alignment purposes)
/// Only needed if show_bytes is true.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The current execution context, if available. May be used in
/// the assembling of the operands+comments for this instruction.
/// Pass NULL if not applicable.
///
/// @param[in] sym_ctx
/// \param[in] sym_ctx
/// The SymbolContext for this instruction.
/// Pass NULL if not available/computed.
/// Only needed if show_address is true.
///
/// @param[in] prev_sym_ctx
/// \param[in] prev_sym_ctx
/// The SymbolContext for the previous instruction. Depending on
/// the disassembly address format specification, a change in
/// Symbol / Function may mean that a line is printed with the new
@ -149,11 +149,11 @@ public:
/// the InstructionList.
/// Only needed if show_address is true.
///
/// @param[in] disassembly_addr_format
/// \param[in] disassembly_addr_format
/// The format specification for how addresses are printed.
/// Only needed if show_address is true.
///
/// @param[in] max_address_text_size
/// \param[in] max_address_text_size
/// The length of the longest address string at the start of the
/// disassembly line that will be printed (the
/// Debugger::FormatDisassemblerAddress() string)

20
lldb/include/lldb/Core/DumpDataExtractor.h
View File

@ -34,31 +34,31 @@ class Stream;
/// same start offset, format and size, yet differing \a
/// item_bit_size and \a item_bit_offset values.
///
/// @param[in] s
/// \param[in] s
/// The stream to dump the output to. This value can not be nullptr.
///
/// @param[in] offset
/// \param[in] offset
/// The offset into the data at which to start dumping.
///
/// @param[in] item_format
/// \param[in] item_format
/// The format to use when dumping each item.
///
/// @param[in] item_byte_size
/// \param[in] item_byte_size
/// The byte size of each item.
///
/// @param[in] item_count
/// \param[in] item_count
/// The number of items to dump.
///
/// @param[in] num_per_line
/// \param[in] num_per_line
/// The number of items to display on each line.
///
/// @param[in] base_addr
/// \param[in] base_addr
/// The base address that gets added to the offset displayed on
/// each line if the value is valid. Is \a base_addr is
/// LLDB_INVALID_ADDRESS then no address values will be prepended
/// to any lines.
///
/// @param[in] item_bit_size
/// \param[in] item_bit_size
/// If the value to display is a bitfield, this value should
/// be the number of bits that the bitfield item has within the
/// item's byte size value. This function will need to be called
@ -67,7 +67,7 @@ class Stream;
/// exist within the same integer value. If the items being
/// displayed are not bitfields, this value should be zero.
///
/// @param[in] item_bit_offset
/// \param[in] item_bit_offset
/// If the value to display is a bitfield, this value should
/// be the offset in bits, or shift right amount, that the
/// bitfield item occupies within the item's byte size value.
@ -77,7 +77,7 @@ class Stream;
/// same integer value. If the items being displayed are not
/// bitfields, this value should be zero.
///
/// @return
/// \return
/// The offset at which dumping ended.
//------------------------------------------------------------------
lldb::offset_t

2
lldb/include/lldb/Core/EmulateInstruction.h
View File

@ -45,7 +45,7 @@ class UnwindPlan;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class EmulateInstruction EmulateInstruction.h
/// \class EmulateInstruction EmulateInstruction.h
/// "lldb/Core/EmulateInstruction.h"
/// A class that allows emulation of CPU opcodes.
///

2
lldb/include/lldb/Core/FileLineResolver.h
View File

@ -26,7 +26,7 @@ class Stream;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class FileLineResolver FileLineResolver.h "lldb/Core/FileLineResolver.h"
/// \class FileLineResolver FileLineResolver.h "lldb/Core/FileLineResolver.h"
/// This class finds address for source file and line. Optionally, it will
/// look for inlined instances of the file and line specification.
//----------------------------------------------------------------------

36
lldb/include/lldb/Core/FileSpecList.h
View File

@ -23,7 +23,7 @@ class Stream;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
/// \class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
/// A file collection class.
///
/// A class that contains a mutable list of FileSpec objects.
@ -56,10 +56,10 @@ public:
///
/// Replace the file list in this object with the file list from \a rhs.
///
/// @param[in] rhs
/// \param[in] rhs
/// A file list object to copy.
///
/// @return
/// \return
/// A const reference to this object.
//------------------------------------------------------------------
FileSpecList &operator=(const FileSpecList &rhs) = default;
@ -72,7 +72,7 @@ public:
///
/// Appends \a file to the end of the file list.
///
/// @param[in] file
/// \param[in] file
/// A new file to append to this file list.
//------------------------------------------------------------------
void Append(const FileSpec &file);
@ -83,10 +83,10 @@ public:
/// Appends \a file to the end of the file list if it doesn't already exist
/// in the file list.
///
/// @param[in] file
/// \param[in] file
/// A new file to append to this file list.
///
/// @return
/// \return
/// \b true if the file was appended, \b false otherwise.
//------------------------------------------------------------------
bool AppendIfUnique(const FileSpec &file);
@ -99,7 +99,7 @@ public:
//------------------------------------------------------------------
/// Dumps the file list to the supplied stream pointer "s".
///
/// @param[in] s
/// \param[in] s
/// The stream that will be used to dump the object description.
//------------------------------------------------------------------
void Dump(Stream *s, const char *separator_cstr = "\n") const;
@ -110,16 +110,16 @@ public:
/// Find the index of the file in the file spec list that matches \a file
/// starting \a idx entries into the file spec list.
///
/// @param[in] idx
/// \param[in] idx
/// An index into the file list.
///
/// @param[in] file
/// \param[in] file
/// The file specification to search for.
///
/// @param[in] full
/// \param[in] full
/// Should FileSpec::Equal be called with "full" true or false.
///
/// @return
/// \return
/// The index of the file that matches \a file if it is found,
/// else UINT32_MAX is returned.
//------------------------------------------------------------------
@ -132,10 +132,10 @@ public:
/// FileSpec object will be returned. The file objects that are returned can
/// be tested using FileSpec::operator void*().
///
/// @param[in] idx
/// \param[in] idx
/// An index into the file list.
///
/// @return
/// \return
/// A copy of the FileSpec object at index \a idx. If \a idx
/// is out of range, then an empty FileSpec object will be
/// returned.
@ -148,10 +148,10 @@ public:
/// Gets a file from the file list. The file objects that are returned can
/// be tested using FileSpec::operator void*().
///
/// @param[in] idx
/// \param[in] idx
/// An index into the file list.
///
/// @return
/// \return
/// A pointer to a contained FileSpec object at index \a idx.
/// If \a idx is out of range, then an NULL is returned.
//------------------------------------------------------------------
@ -164,10 +164,10 @@ public:
/// the size in bytes of this object, not any shared string values it may
/// refer to.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const;
@ -176,7 +176,7 @@ public:
//------------------------------------------------------------------
/// Get the number of files in the file list.
///
/// @return
/// \return
/// The number of files in the file spec list.
//------------------------------------------------------------------
size_t GetSize() const;

4
lldb/include/lldb/Core/Highlighter.h
View File

@ -47,8 +47,8 @@ struct HighlightStyle {
void Apply(Stream &s, llvm::StringRef value) const;
/// Sets the prefix and suffix strings.
/// @param prefix
/// @param suffix
/// \param prefix
/// \param suffix
void Set(llvm::StringRef prefix, llvm::StringRef suffix);
};

14
lldb/include/lldb/Core/IOHandler.h
View File

@ -218,18 +218,18 @@ public:
/// This function determines how much indentation should be added
/// or removed to match the recommended amount for the final line.
///
/// @param[in] io_handler
/// \param[in] io_handler
/// The IOHandler that responsible for input.
///
/// @param[in] lines
/// \param[in] lines
/// The current input up to the line to be corrected. Lines
/// following the line containing the cursor are not included.
///
/// @param[in] cursor_position
/// \param[in] cursor_position
/// The number of characters preceding the cursor on the final
/// line at the time.
///
/// @return
/// \return
/// Returns an integer describing the number of spaces needed
/// to correct the indentation level. Positive values indicate
/// that spaces should be added, while negative values represent
@ -260,14 +260,14 @@ public:
/// Called to determine whether typing enter after the last line in
/// \a lines should end input. This function will not be called on
/// IOHandler objects that are getting single lines.
/// @param[in] io_handler
/// \param[in] io_handler
/// The IOHandler that responsible for updating the lines.
///
/// @param[in] lines
/// \param[in] lines
/// The current multi-line content. May be altered to provide
/// alternative input when complete.
///
/// @return
/// \return
/// Return an boolean to indicate whether input is complete,
/// true indicates that no additional input is necessary, while
/// false indicates that more input is required.

70
lldb/include/lldb/Core/Mangled.h
View File

@ -23,7 +23,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Mangled Mangled.h "lldb/Core/Mangled.h"
/// \class Mangled Mangled.h "lldb/Core/Mangled.h"
/// A class that handles mangled names.
///
/// Designed to handle mangled names. The demangled version of any names will
@ -61,10 +61,10 @@ public:
/// Constructor with an optional string and a boolean indicating if it is
/// the mangled version.
///
/// @param[in] name
/// \param[in] name
/// The already const name to copy into this object.
///
/// @param[in] is_mangled
/// \param[in] is_mangled
/// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled.
//----------------------------------------------------------------------
@ -77,7 +77,7 @@ public:
/// Constructor with an optional string and auto-detect if \a name is
/// mangled or not.
///
/// @param[in] name
/// \param[in] name
/// The already const name to copy into this object.
//----------------------------------------------------------------------
explicit Mangled(ConstString name);
@ -98,13 +98,13 @@ public:
/// This allows code to check a Mangled object to see if it contains a valid
/// mangled name using code such as:
///
/// @code
/// \code
/// Mangled mangled(...);
/// if (mangled)
/// { ...
/// @endcode
/// \endcode
///
/// @return
/// \return
/// A pointer to this object if either the mangled or unmangled
/// name is set, NULL otherwise.
//----------------------------------------------------------------------
@ -116,13 +116,13 @@ public:
/// This allows code to check a Mangled object to see if it contains an
/// empty mangled name using code such as:
///
/// @code
/// \code
/// Mangled mangled(...);
/// if (!mangled)
/// { ...
/// @endcode
/// \endcode
///
/// @return
/// \return
/// Returns \b true if the object has an empty mangled and
/// unmangled name, \b false otherwise.
//----------------------------------------------------------------------
@ -138,16 +138,16 @@ public:
///
/// Compares the Mangled::GetName() string in \a lhs and \a rhs.
///
/// @param[in] lhs
/// \param[in] lhs
/// A const reference to the Left Hand Side object to compare.
///
/// @param[in] rhs
/// \param[in] rhs
/// A const reference to the Right Hand Side object to compare.
///
/// @return
/// @li -1 if \a lhs is less than \a rhs
/// @li 0 if \a lhs is equal to \a rhs
/// @li 1 if \a lhs is greater than \a rhs
/// \return
/// \li -1 if \a lhs is less than \a rhs
/// \li 0 if \a lhs is equal to \a rhs
/// \li 1 if \a lhs is greater than \a rhs
//----------------------------------------------------------------------
static int Compare(const Mangled &lhs, const Mangled &rhs);
@ -157,7 +157,7 @@ public:
/// Dump a Mangled object to stream \a s. We don't force our demangled name
/// to be computed currently (we don't use the accessor).
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//----------------------------------------------------------------------
void Dump(Stream *s) const;
@ -165,7 +165,7 @@ public:
//----------------------------------------------------------------------
/// Dump a debug description of this object to a Stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//----------------------------------------------------------------------
void DumpDebug(Stream *s) const;
@ -173,7 +173,7 @@ public:
//----------------------------------------------------------------------
/// Demangled name get accessor.
///
/// @return
/// \return
/// A const reference to the demangled name string object.
//----------------------------------------------------------------------
ConstString GetDemangledName(lldb::LanguageType language) const;
@ -181,7 +181,7 @@ public:
//----------------------------------------------------------------------
/// Display demangled name get accessor.
///
/// @return
/// \return
/// A const reference to the display demangled name string object.
//----------------------------------------------------------------------
ConstString GetDisplayDemangledName(lldb::LanguageType language) const;
@ -193,7 +193,7 @@ public:
//----------------------------------------------------------------------
/// Mangled name get accessor.
///
/// @return
/// \return
/// A reference to the mangled name string object.
//----------------------------------------------------------------------
ConstString &GetMangledName() { return m_mangled; }
@ -201,7 +201,7 @@ public:
//----------------------------------------------------------------------
/// Mangled name get accessor.
///
/// @return
/// \return
/// A const reference to the mangled name string object.
//----------------------------------------------------------------------
ConstString GetMangledName() const { return m_mangled; }
@ -209,10 +209,10 @@ public:
//----------------------------------------------------------------------
/// Best name get accessor.
///
/// @param[in] preference
/// \param[in] preference
/// Which name would you prefer to get?
///
/// @return
/// \return
/// A const reference to the preferred name string object if this
/// object has a valid name of that kind, else a const reference to the
/// other name is returned.
@ -223,10 +223,10 @@ public:
//----------------------------------------------------------------------
/// Check if "name" matches either the mangled or demangled name.
///
/// @param[in] name
/// \param[in] name
/// A name to match against both strings.
///
/// @return
/// \return
/// \b True if \a name matches either name, \b false otherwise.
//----------------------------------------------------------------------
bool NameMatches(ConstString name, lldb::LanguageType language) const {
@ -244,10 +244,10 @@ public:
/// the size in bytes of this object, not any shared string values it may
/// refer to.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//----------------------------------------------------------------------
size_t MemorySize() const;
@ -257,10 +257,10 @@ public:
/// If \a is_mangled is \b true, then the mangled named is set to \a name,
/// else the demangled name is set to \a name.
///
/// @param[in] name
/// \param[in] name
/// The already const version of the name for this object.
///
/// @param[in] is_mangled
/// \param[in] is_mangled
/// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled.
//----------------------------------------------------------------------
@ -272,7 +272,7 @@ public:
/// This version auto detects if the string is mangled by inspecting the
/// string value and looking for common mangling prefixes.
///
/// @param[in] name
/// \param[in] name
/// The already const version of the name for this object.
//----------------------------------------------------------------------
void SetValue(ConstString name);
@ -289,7 +289,7 @@ public:
/// aren't mangled and it isn't clear what language the name represents
/// (there will be no mangled name).
///
/// @return
/// \return
/// The language for the mangled/demangled name, eLanguageTypeUnknown
/// if there is no mangled or demangled counterpart.
//----------------------------------------------------------------------
@ -311,15 +311,15 @@ public:
/// This function is thread-safe when used with different \a context
/// instances in different threads.
///
/// @param[in] context
/// \param[in] context
/// The context for this function. A single instance can be stack-
/// allocated in the caller's frame and used for multiple calls.
///
/// @param[in] skip_mangled_name
/// \param[in] skip_mangled_name
/// A filtering function for skipping entities based on name and mangling
/// scheme. This can be null if unused.
///
/// @return
/// \return
/// True on success, false otherwise.
//----------------------------------------------------------------------
bool DemangleWithRichManglingInfo(RichManglingContext &context,

216
lldb/include/lldb/Core/Module.h
View File

@ -92,7 +92,7 @@ class VariableList;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Module Module.h "lldb/Core/Module.h"
/// \class Module Module.h "lldb/Core/Module.h"
/// A class that describes an executable image and its associated
/// object and symbol files.
///
@ -129,20 +129,20 @@ public:
/// Clients that wish to share modules with other targets should use
/// ModuleList::GetSharedModule().
///
/// @param[in] file_spec
/// \param[in] file_spec
/// The file specification for the on disk representation of
/// this executable image.
///
/// @param[in] arch
/// \param[in] arch
/// The architecture to set as the current architecture in
/// this module.
///
/// @param[in] object_name
/// \param[in] object_name
/// The name of an object in a module used to extract a module
/// within a module (.a files and modules that contain multiple
/// architectures).
///
/// @param[in] object_offset
/// \param[in] object_offset
/// The offset within an existing module used to extract a
/// module within a module (.a files and modules that contain
/// multiple architectures).
@ -190,23 +190,23 @@ public:
/// address for all top level sections to be the section file address +
/// offset.
///
/// @param[in] target
/// \param[in] target
/// The target in which to apply the section load addresses.
///
/// @param[in] value
/// \param[in] value
/// if \a value_is_offset is true, then value is the offset to
/// apply to all file addresses for all top level sections in
/// the object file as each section load address is being set.
/// If \a value_is_offset is false, then "value" is the new
/// absolute base address for the image.
///
/// @param[in] value_is_offset
/// \param[in] value_is_offset
/// If \b true, then \a value is an offset to apply to each
/// file address of each top level section.
/// If \b false, then \a value is the image base address that
/// will be used to rigidly slide all loadable sections.
///
/// @param[out] changed
/// \param[out] changed
/// If any section load addresses were changed in \a target,
/// then \a changed will be set to \b true. Else \a changed
/// will be set to false. This allows this function to be
@ -215,7 +215,7 @@ public:
/// be false and no module updated notification will need to
/// be sent out.
///
/// @return
/// \return
/// /b True if any sections were successfully loaded in \a target,
/// /b false otherwise.
//------------------------------------------------------------------
@ -223,9 +223,9 @@ public:
bool &changed);
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
/// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void CalculateSymbolContext(SymbolContext *sc) override;
@ -251,7 +251,7 @@ public:
/// There are many places where logging wants to log this fully qualified
/// specification, so we centralize this functionality here.
///
/// @return
/// \return
/// The object path + object name if there is one.
//------------------------------------------------------------------
std::string GetSpecificationDescription() const;
@ -264,31 +264,31 @@ public:
/// to this point at which this function is called, so this is a good way to
/// see what has been parsed in a module.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void Dump(Stream *s);
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
/// \copydoc SymbolContextScope::DumpSymbolContext(Stream*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void DumpSymbolContext(Stream *s) override;
//------------------------------------------------------------------
/// Find a symbol in the object file's symbol table.
///
/// @param[in] name
/// \param[in] name
/// The name of the symbol that we are looking for.
///
/// @param[in] symbol_type
/// \param[in] symbol_type
/// If set to eSymbolTypeAny, find a symbol of any type that
/// has a name that matches \a name. If set to any other valid
/// SymbolType enumeration value, then search only for
/// symbols that match \a symbol_type.
///
/// @return
/// \return
/// Returns a valid symbol pointer if a symbol was found,
/// nullptr otherwise.
//------------------------------------------------------------------
@ -307,18 +307,18 @@ public:
//------------------------------------------------------------------
/// Find a function symbols in the object file's symbol table.
///
/// @param[in] name
/// \param[in] name
/// The name of the symbol that we are looking for.
///
/// @param[in] name_type_mask
/// \param[in] name_type_mask
/// A mask that has one or more bitwise OR'ed values from the
/// lldb::FunctionNameType enumeration type that indicate what
/// kind of names we are looking for.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A list to append any matching symbol contexts to.
///
/// @return
/// \return
/// The number of symbol contexts that were added to \a sc_list
//------------------------------------------------------------------
size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
@ -330,19 +330,19 @@ public:
/// Finds all compile units that match \a path in all of the modules and
/// returns the results in \a sc_list.
///
/// @param[in] path
/// \param[in] path
/// The name of the function we are looking for.
///
/// @param[in] append
/// \param[in] append
/// If \b true, then append any compile units that were found
/// to \a sc_list. If \b false, then the \a sc_list is cleared
/// and the contents of \a sc_list are replaced.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// \return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t FindCompileUnits(const FileSpec &path, bool append,
@ -355,27 +355,27 @@ public:
/// representing the inlined function, and the function will be the
/// containing function. If it is not inlined, then the block will be NULL.
///
/// @param[in] name
/// \param[in] name
/// The name of the compile unit we are looking for.
///
/// @param[in] namespace_decl
/// \param[in] namespace_decl
/// If valid, a namespace to search in.
///
/// @param[in] name_type_mask
/// \param[in] name_type_mask
/// A bit mask of bits that indicate what kind of names should
/// be used when doing the lookup. Bits include fully qualified
/// names, base names, C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @param[in] append
/// \param[in] append
/// If \b true, any matches will be appended to \a sc_list, else
/// matches replace the contents of \a sc_list.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// \return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t FindFunctions(ConstString name,
@ -391,18 +391,18 @@ public:
/// representing the inlined function, and the function will be the
/// containing function. If it is not inlined, then the block will be NULL.
///
/// @param[in] regex
/// \param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] append
/// \param[in] append
/// If \b true, any matches will be appended to \a sc_list, else
/// matches replace the contents of \a sc_list.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// \return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t FindFunctions(const RegularExpression &regex, bool symbols_ok,
@ -412,24 +412,24 @@ public:
//------------------------------------------------------------------
/// Find addresses by file/line
///
/// @param[in] target_sp
/// \param[in] target_sp
/// The target the addresses are desired for.
///
/// @param[in] file
/// \param[in] file
/// Source file to locate.
///
/// @param[in] line
/// \param[in] line
/// Source line to locate.
///
/// @param[in] function
/// \param[in] function
/// Optional filter function. Addresses within this function will be
/// added to the 'local' list. All others will be added to the 'extern'
/// list.
///
/// @param[out] output_local
/// \param[out] output_local
/// All matching addresses within 'function'
///
/// @param[out] output_extern
/// \param[out] output_extern
/// All matching addresses not within 'function'
void FindAddressesForLine(const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
@ -440,21 +440,21 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @param[in] parent_decl_ctx
/// \param[in] parent_decl_ctx
/// If valid, a decl context that results must exist within
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
/// @return
/// \return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t FindGlobalVariables(ConstString name,
@ -464,17 +464,17 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by regular expression.
///
/// @param[in] regex
/// \param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
/// @return
/// \return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t FindGlobalVariables(const RegularExpression &regex, size_t max_matches,
@ -498,21 +498,21 @@ public:
/// have to specify complete scoping on all expressions, but it also allows
/// for exact matching when required.
///
/// @param[in] type_name
/// \param[in] type_name
/// The name of the type we are looking for that is a fully
/// or partially qualified type name.
///
/// @param[in] exact_match
/// \param[in] exact_match
/// If \b true, \a type_name is fully qualified and must match
/// exactly. If \b false, \a type_name is a partially qualified
/// name where the leading namespaces or classes can be
/// omitted to make finding types that a user may type
/// easier.
///
/// @param[out] type_list
/// \param[out] type_list
/// A type list gets populated with any matches.
///
/// @return
/// \return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t
@ -528,17 +528,17 @@ public:
/// expression parser when searches need to happen in an exact namespace
/// scope.
///
/// @param[in] type_name
/// \param[in] type_name
/// The name of a type within a namespace that should not include
/// any qualifying namespaces (just a type basename).
///
/// @param[in] namespace_decl
/// \param[in] namespace_decl
/// The namespace declaration that this type must exist in.
///
/// @param[out] type_list
/// \param[out] type_list
/// A type list gets populated with any matches.
///
/// @return
/// \return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t FindTypesInNamespace(ConstString type_name,
@ -548,7 +548,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the module architecture.
///
/// @return
/// \return
/// A const reference to the architecture object.
//------------------------------------------------------------------
const ArchSpec &GetArchitecture() const;
@ -560,7 +560,7 @@ public:
/// running LLDB. This can differ from the path on the platform since we
/// might be doing remote debugging.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
const FileSpec &GetFileSpec() const { return m_file; }
@ -576,7 +576,7 @@ public:
/// "/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib" The
/// file could also be cached in a local developer kit directory.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
const FileSpec &GetPlatformFileSpec() const {
@ -617,7 +617,7 @@ public:
/// Tells whether this module is capable of being the main executable for a
/// process.
///
/// @return
/// \return
/// \b true if it is, \b false otherwise.
//------------------------------------------------------------------
bool IsExecutable();
@ -627,10 +627,10 @@ public:
/// call doesn't distinguish between whether the module is loaded by the
/// dynamic loader, or by a "target module add" type call.
///
/// @param[in] target
/// \param[in] target
/// The target to check whether this is loaded in.
///
/// @return
/// \return
/// \b true if it is, \b false otherwise.
//------------------------------------------------------------------
bool IsLoadedInTarget(Target *target);
@ -641,7 +641,7 @@ public:
//------------------------------------------------------------------
/// Get the number of compile units for this module.
///
/// @return
/// \return
/// The number of compile units that the symbol vendor plug-in
/// finds.
//------------------------------------------------------------------
@ -659,7 +659,7 @@ public:
/// If the object file has not been located or parsed yet, this function
/// will find the best ObjectFile plug-in that can parse Module::m_file.
///
/// @return
/// \return
/// If Module::m_file does not exist, or no plug-in was found
/// that can parse the file, or the object file doesn't contain
/// the current architecture in Module::m_arch, nullptr will be
@ -677,7 +677,7 @@ public:
/// If the symbol vendor has not been loaded yet, this function will return
/// the section list for the object file.
///
/// @return
/// \return
/// Unified module section list.
//------------------------------------------------------------------
virtual SectionList *GetSectionList();
@ -702,7 +702,7 @@ public:
/// requested. Specifically, we do not create FuncUnwinders objects for
/// functions until they are needed.
///
/// @return
/// \return
/// Returns the unwind table for this module. If this object has no
/// associated object file, an empty UnwindTable is returned.
//------------------------------------------------------------------
@ -719,7 +719,7 @@ public:
/// enable the ObjectFile plugins to read the header of the object file
/// without going back to the process.
///
/// @return
/// \return
/// The object file loaded from memory or nullptr, if the operation
/// failed (see the `error` for more information in that case).
//------------------------------------------------------------------
@ -732,7 +732,7 @@ public:
/// If the symbol vendor file has not been located yet, this function will
/// find the best SymbolVendor plug-in that can use the current object file.
///
/// @return
/// \return
/// If this module does not have a valid object file, or no
/// plug-in can be found that can use the object file, nullptr will
/// be returned, else a valid symbol vendor plug-in interface
@ -746,7 +746,7 @@ public:
//------------------------------------------------------------------
/// Get accessor the type list for this module.
///
/// @return
/// \return
/// A valid type list pointer, or nullptr if there is no valid
/// symbol vendor for this module.
//------------------------------------------------------------------
@ -759,7 +759,7 @@ public:
/// the file format, an MD5 checksum of the entire file, or slice of the
/// file for the current architecture should be used.
///
/// @return
/// \return
/// A const pointer to the internal copy of the UUID value in
/// this module if this module has a valid UUID value, NULL
/// otherwise.
@ -796,10 +796,10 @@ public:
/// line entry. Use the return value to determine which of these properties
/// have been modified.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A load address to resolve.
///
/// @param[in] resolve_scope
/// \param[in] resolve_scope
/// The scope that should be resolved (see SymbolContext::Scope).
/// A combination of flags from the enumeration SymbolContextItem
/// requesting a resolution depth. Note that the flags that are
@ -808,18 +808,18 @@ public:
/// eSymbolContextModule, and eSymbolContextFunction requires
/// eSymbolContextSymbol.
///
/// @param[out] sc
/// \param[out] sc
/// The SymbolContext that is modified based on symbol resolution.
///
/// @param[in] resolve_tail_call_address
/// \param[in] resolve_tail_call_address
/// Determines if so_addr should resolve to a symbol in the case
/// of a function whose last instruction is a call. In this case,
/// the PC can be one past the address range of the function.
///
/// @return
/// \return
/// The scope that has been resolved (see SymbolContext::Scope).
///
/// @see SymbolContext::Scope
/// \see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForAddress(
const Address &so_addr, lldb::SymbolContextItem resolve_scope,
@ -837,34 +837,34 @@ public:
/// to only what is needed -- typically the module, compile unit, line table
/// and line table entry are sufficient.
///
/// @param[in] file_path
/// \param[in] file_path
/// A path to a source file to match. If \a file_path does not
/// specify a directory, then this query will match all files
/// whose base filename matches. If \a file_path does specify
/// a directory, the fullpath to the file must match.
///
/// @param[in] line
/// \param[in] line
/// The source line to match, or zero if just the compile unit
/// should be resolved.
///
/// @param[in] check_inlines
/// \param[in] check_inlines
/// Check for inline file and line number matches. This option
/// should be used sparingly as it will cause all line tables
/// for every compile unit to be parsed and searched for
/// matching inline file entries.
///
/// @param[in] resolve_scope
/// \param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets matching symbols contexts
/// appended to.
///
/// @return
/// \return
/// The number of matches that were added to \a sc_list.
///
/// @see SymbolContext::Scope
/// \see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForFilePath(
const char *file_path, uint32_t line, bool check_inlines,
@ -882,35 +882,35 @@ public:
/// to only what is needed -- typically the module, compile unit, line table
/// and line table entry are sufficient.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// A file spec to a source file to match. If \a file_path does
/// not specify a directory, then this query will match all
/// files whose base filename matches. If \a file_path does
/// specify a directory, the fullpath to the file must match.
///
/// @param[in] line
/// \param[in] line
/// The source line to match, or zero if just the compile unit
/// should be resolved.
///
/// @param[in] check_inlines
/// \param[in] check_inlines
/// Check for inline file and line number matches. This option
/// should be used sparingly as it will cause all line tables
/// for every compile unit to be parsed and searched for
/// matching inline file entries.
///
/// @param[in] resolve_scope
/// \param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// \return
/// A integer that contains SymbolContext::Scope bits set for
/// each item that was successfully resolved.
///
/// @see SymbolContext::Scope
/// \see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextsForFileSpec(
const FileSpec &file_spec, uint32_t line, bool check_inlines,
@ -973,13 +973,13 @@ public:
/// if the remappings are on a network file system, so use this function
/// sparingly (not in a tight debug info parsing loop).
///
/// @param[in] orig_spec
/// \param[in] orig_spec
/// The original source file path to try and remap.
///
/// @param[out] new_spec
/// \param[out] new_spec
/// The newly remapped filespec that is guaranteed to exist.
///
/// @return
/// \return
/// /b true if \a orig_spec was successfully located and
/// \a new_spec is filled in with an existing file spec,
/// \b false otherwise.
@ -993,13 +993,13 @@ public:
/// stat the file system so it can be used in tight loops where debug info
/// is being parsed.
///
/// @param[in] path
/// \param[in] path
/// The original source file path to try and remap.
///
/// @param[out] new_path
/// \param[out] new_path
/// The newly remapped filespec that is may or may not exist.
///
/// @return
/// \return
/// /b true if \a path was successfully located and \a new_path
/// is filled in with a new source path, \b false otherwise.
//------------------------------------------------------------------
@ -1007,7 +1007,7 @@ public:
bool RemapSourceFile(const char *, std::string &) const = delete;
//----------------------------------------------------------------------
/// @class LookupInfo Module.h "lldb/Core/Module.h"
/// \class LookupInfo Module.h "lldb/Core/Module.h"
/// A class that encapsulates name lookup information.
///
/// Users can type a wide variety of partial names when setting breakpoints
@ -1140,30 +1140,30 @@ protected:
/// indicates what clients wish to resolve and can be used to limit the
/// scope of what is parsed.
///
/// @param[in] vm_addr
/// \param[in] vm_addr
/// The load virtual address to resolve.
///
/// @param[in] vm_addr_is_file_addr
/// \param[in] vm_addr_is_file_addr
/// If \b true, \a vm_addr is a file address, else \a vm_addr
/// if a load address.
///
/// @param[in] resolve_scope
/// \param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] so_addr
/// \param[out] so_addr
/// The section offset based address that got resolved if
/// any bits are returned.
///
/// @param[out] sc
/// \param[out] sc
// The symbol context that has objects filled in. Each bit
/// in the \a resolve_scope pertains to a member in the \a sc.
///
/// @return
/// \return
/// A integer that contains SymbolContext::Scope bits set for
/// each item that was successfully resolved.
///
/// @see SymbolContext::Scope
/// \see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForAddress(lldb::addr_t vm_addr,
bool vm_addr_is_file_addr,

14
lldb/include/lldb/Core/ModuleChild.h
View File

@ -14,7 +14,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ModuleChild ModuleChild.h "lldb/Core/ModuleChild.h"
/// \class ModuleChild ModuleChild.h "lldb/Core/ModuleChild.h"
/// A mix in class that contains a pointer back to the module
/// that owns the object which inherits from it.
//----------------------------------------------------------------------
@ -23,7 +23,7 @@ public:
//------------------------------------------------------------------
/// Construct with owning module.
///
/// @param[in] module
/// \param[in] module
/// The module that owns the object that inherits from this
/// class.
//------------------------------------------------------------------
@ -32,7 +32,7 @@ public:
//------------------------------------------------------------------
/// Copy constructor.
///
/// @param[in] rhs
/// \param[in] rhs
/// A const ModuleChild class reference to copy.
//------------------------------------------------------------------
ModuleChild(const ModuleChild &rhs);
@ -45,10 +45,10 @@ public:
//------------------------------------------------------------------
/// Assignment operator.
///
/// @param[in] rhs
/// \param[in] rhs
/// A const ModuleChild class reference to copy.
///
/// @return
/// \return
/// A const reference to this object.
//------------------------------------------------------------------
const ModuleChild &operator=(const ModuleChild &rhs);
@ -56,7 +56,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the module pointer.
///
/// @return
/// \return
/// A const pointer to the module that owns the object that
/// inherits from this class.
//------------------------------------------------------------------
@ -65,7 +65,7 @@ public:
//------------------------------------------------------------------
/// Set accessor for the module pointer.
///
/// @param[in] module
/// \param[in] module
/// A new module that owns the object that inherits from this
/// class.
//------------------------------------------------------------------

118
lldb/include/lldb/Core/ModuleList.h
View File

@ -84,7 +84,7 @@ public:
};
//----------------------------------------------------------------------
/// @class ModuleList ModuleList.h "lldb/Core/ModuleList.h"
/// \class ModuleList ModuleList.h "lldb/Core/ModuleList.h"
/// A collection class for Module objects.
///
/// Modules in the module collection class are stored as reference counted
@ -118,7 +118,7 @@ public:
///
/// Creates a new module list object with a copy of the modules from \a rhs.
///
/// @param[in] rhs
/// \param[in] rhs
/// Another module list object.
//------------------------------------------------------------------
ModuleList(const ModuleList &rhs);
@ -135,10 +135,10 @@ public:
///
/// Copies the module list from \a rhs into this list.
///
/// @param[in] rhs
/// \param[in] rhs
/// Another module list object.
///
/// @return
/// \return
/// A const reference to this object.
//------------------------------------------------------------------
const ModuleList &operator=(const ModuleList &rhs);
@ -148,7 +148,7 @@ public:
///
/// Appends the module to the collection.
///
/// @param[in] module_sp
/// \param[in] module_sp
/// A shared pointer to a module to add to this collection.
//------------------------------------------------------------------
void Append(const lldb::ModuleSP &module_sp);
@ -160,7 +160,7 @@ public:
///
/// Replaces the module to the collection.
///
/// @param[in] module_sp
/// \param[in] module_sp
/// A shared pointer to a module to replace in this collection.
//------------------------------------------------------------------
void ReplaceEquivalent(const lldb::ModuleSP &module_sp);
@ -199,10 +199,10 @@ public:
/// Dump the description of each module contained in this list to the
/// supplied stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @see Module::Dump(Stream *) const
/// \see Module::Dump(Stream *) const
//------------------------------------------------------------------
void Dump(Stream *s) const;
@ -215,14 +215,14 @@ public:
//------------------------------------------------------------------
/// Get the module shared pointer for the module at index \a idx.
///
/// @param[in] idx
/// \param[in] idx
/// An index into this module collection.
///
/// @return
/// \return
/// A shared pointer to a Module which can contain NULL if
/// \a idx is out of range.
///
/// @see ModuleList::GetSize()
/// \see ModuleList::GetSize()
//------------------------------------------------------------------
lldb::ModuleSP GetModuleAtIndex(size_t idx) const;
@ -231,28 +231,28 @@ public:
/// acquiring the ModuleList mutex. This MUST already have been acquired
/// with ModuleList::GetMutex and locked for this call to be safe.
///
/// @param[in] idx
/// \param[in] idx
/// An index into this module collection.
///
/// @return
/// \return
/// A shared pointer to a Module which can contain NULL if
/// \a idx is out of range.
///
/// @see ModuleList::GetSize()
/// \see ModuleList::GetSize()
//------------------------------------------------------------------
lldb::ModuleSP GetModuleAtIndexUnlocked(size_t idx) const;
//------------------------------------------------------------------
/// Get the module pointer for the module at index \a idx.
///
/// @param[in] idx
/// \param[in] idx
/// An index into this module collection.
///
/// @return
/// \return
/// A pointer to a Module which can by nullptr if \a idx is out
/// of range.
///
/// @see ModuleList::GetSize()
/// \see ModuleList::GetSize()
//------------------------------------------------------------------
Module *GetModulePointerAtIndex(size_t idx) const;
@ -261,14 +261,14 @@ public:
/// the ModuleList mutex. This MUST already have been acquired with
/// ModuleList::GetMutex and locked for this call to be safe.
///
/// @param[in] idx
/// \param[in] idx
/// An index into this module collection.
///
/// @return
/// \return
/// A pointer to a Module which can by nullptr if \a idx is out
/// of range.
///
/// @see ModuleList::GetSize()
/// \see ModuleList::GetSize()
//------------------------------------------------------------------
Module *GetModulePointerAtIndexUnlocked(size_t idx) const;
@ -278,26 +278,26 @@ public:
/// Finds all compile units that match \a path in all of the modules and
/// returns the results in \a sc_list.
///
/// @param[in] path
/// \param[in] path
/// The name of the compile unit we are looking for.
///
/// @param[in] append
/// \param[in] append
/// If \b true, then append any compile units that were found
/// to \a sc_list. If \b false, then the \a sc_list is cleared
/// and the contents of \a sc_list are replaced.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// \return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t FindCompileUnits(const FileSpec &path, bool append,
SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @see Module::FindFunctions ()
/// \see Module::FindFunctions ()
//------------------------------------------------------------------
size_t FindFunctions(ConstString name,
lldb::FunctionNameType name_type_mask,
@ -305,14 +305,14 @@ public:
SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @see Module::FindFunctionSymbols ()
/// \see Module::FindFunctionSymbols ()
//------------------------------------------------------------------
size_t FindFunctionSymbols(ConstString name,
lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list);
//------------------------------------------------------------------
/// @see Module::FindFunctions ()
/// \see Module::FindFunctions ()
//------------------------------------------------------------------
size_t FindFunctions(const RegularExpression &name, bool include_symbols,
bool include_inlines, bool append,
@ -321,18 +321,18 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by name.
///
/// @param[in] name
/// \param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
/// @return
/// \return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t FindGlobalVariables(ConstString name, size_t max_matches,
@ -341,17 +341,17 @@ public:
//------------------------------------------------------------------
/// Find global and static variables by regular expression.
///
/// @param[in] regex
/// \param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// \param[in] variable_list
/// A list of variables that gets the matches appended to.
///
/// @return
/// \return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t FindGlobalVariables(const RegularExpression &regex, size_t max_matches,
@ -360,7 +360,7 @@ public:
//------------------------------------------------------------------
/// Finds the first module whose file specification matches \a file_spec.
///
/// @param[in] file_spec_ptr
/// \param[in] file_spec_ptr
/// A file specification object to match against the Module's
/// file specifications. If \a file_spec does not have
/// directory information, matches will occur by matching only
@ -368,23 +368,23 @@ public:
/// NULL, then file specifications won't be compared when
/// searching for matching modules.
///
/// @param[in] arch_ptr
/// \param[in] arch_ptr
/// The architecture to search for if non-NULL. If this value
/// is NULL no architecture matching will be performed.
///
/// @param[in] uuid_ptr
/// \param[in] uuid_ptr
/// The uuid to search for if non-NULL. If this value is NULL
/// no uuid matching will be performed.
///
/// @param[in] object_name
/// \param[in] object_name
/// An optional object name that must match as well. This value
/// can be NULL.
///
/// @param[out] matching_module_list
/// \param[out] matching_module_list
/// A module list that gets filled in with any modules that
/// match the search criteria.
///
/// @return
/// \return
/// The number of matching modules found by the search.
//------------------------------------------------------------------
size_t FindModules(const ModuleSpec &module_spec,
@ -416,34 +416,34 @@ public:
//------------------------------------------------------------------
/// Find types by name.
///
/// @param[in] search_first
/// \param[in] search_first
/// If non-null, this module will be searched before any other
/// modules.
///
/// @param[in] name
/// \param[in] name
/// The name of the type we are looking for.
///
/// @param[in] append
/// \param[in] append
/// If \b true, any matches will be appended to \a
/// variable_list, else matches replace the contents of
/// \a variable_list.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] encoding
/// \param[in] encoding
/// Limit the search to specific types, or get all types if
/// set to Type::invalid.
///
/// @param[in] udt_name
/// \param[in] udt_name
/// If the encoding is a user defined type, specify the name
/// of the user defined type ("struct", "union", "class", etc).
///
/// @param[out] type_list
/// \param[out] type_list
/// A type list gets populated with any matches.
///
/// @return
/// \return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t FindTypes(Module *search_first, ConstString name,
@ -456,24 +456,24 @@ public:
//------------------------------------------------------------------
/// Find addresses by file/line
///
/// @param[in] target_sp
/// \param[in] target_sp
/// The target the addresses are desired for.
///
/// @param[in] file
/// \param[in] file
/// Source file to locate.
///
/// @param[in] line
/// \param[in] line
/// Source line to locate.
///
/// @param[in] function
/// \param[in] function
/// Optional filter function. Addresses within this function will be
/// added to the 'local' list. All others will be added to the 'extern'
/// list.
///
/// @param[out] output_local
/// \param[out] output_local
/// All matching addresses within 'function'
///
/// @param[out] output_extern
/// \param[out] output_extern
/// All matching addresses not within 'function'
void FindAddressesForLine(const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
@ -492,7 +492,7 @@ public:
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const;
//------------------------------------------------------------------
/// @copydoc Module::ResolveSymbolContextForAddress (const Address
/// \copydoc Module::ResolveSymbolContextForAddress (const Address
/// &,uint32_t,SymbolContext&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForAddress(const Address &so_addr,
@ -500,7 +500,7 @@ public:
SymbolContext &sc) const;
//------------------------------------------------------------------
/// @copydoc Module::ResolveSymbolContextForFilePath (const char
/// \copydoc Module::ResolveSymbolContextForFilePath (const char
/// *,uint32_t,bool,uint32_t,SymbolContextList&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextForFilePath(
@ -508,7 +508,7 @@ public:
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const;
//------------------------------------------------------------------
/// @copydoc Module::ResolveSymbolContextsForFileSpec (const FileSpec
/// \copydoc Module::ResolveSymbolContextsForFileSpec (const FileSpec
/// &,uint32_t,bool,uint32_t,SymbolContextList&)
//------------------------------------------------------------------
uint32_t ResolveSymbolContextsForFileSpec(
@ -518,7 +518,7 @@ public:
//------------------------------------------------------------------
/// Gets the size of the module list.
///
/// @return
/// \return
/// The number of modules in the module list.
//------------------------------------------------------------------
size_t GetSize() const;

12
lldb/include/lldb/Core/PluginManager.h
View File

@ -304,21 +304,21 @@ public:
/// callbacks for debugger initialization and Process launch info
/// filtering and manipulation.
///
/// @param[in] name
/// \param[in] name
/// The name of the plugin.
///
/// @param[in] description
/// \param[in] description
/// A description string for the plugin.
///
/// @param[in] create_callback
/// \param[in] create_callback
/// The callback that will be invoked to create an instance of
/// the callback. This may not be nullptr.
///
/// @param[in] debugger_init_callback
/// \param[in] debugger_init_callback
/// An optional callback that will be made when a Debugger
/// instance is initialized.
///
/// @param[in] filter_callback
/// \param[in] filter_callback
/// An optional callback that will be invoked before LLDB
/// launches a process for debugging. The callback must
/// do the following:
@ -330,7 +330,7 @@ public:
/// plugin if, for instance, additional environment variables
/// are needed to support the feature when enabled.
///
/// @return
/// \return
/// Returns true upon success; otherwise, false.
//------------------------------------------------------------------
static bool

58
lldb/include/lldb/Core/SearchFilter.h
View File

@ -51,7 +51,7 @@ class Target;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Searcher SearchFilter.h "lldb/Core/SearchFilter.h" Class that is
/// \class Searcher SearchFilter.h "lldb/Core/SearchFilter.h" Class that is
/// driven by the SearchFilter to search the SymbolContext space of the target
/// program.
//----------------------------------------------------------------------
@ -82,14 +82,14 @@ public:
//------------------------------------------------------------------
/// Prints a canonical description for the searcher to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// Stream to which the output is copied.
//------------------------------------------------------------------
virtual void GetDescription(Stream *s);
};
//----------------------------------------------------------------------
/// @class SearchFilter SearchFilter.h "lldb/Core/SearchFilter.h" Class
/// \class SearchFilter SearchFilter.h "lldb/Core/SearchFilter.h" Class
/// descends through the SymbolContext space of the target, applying a filter
/// at each stage till it reaches the depth specified by the GetDepth method
/// of the searcher, and calls its callback at that point.
@ -113,7 +113,7 @@ public:
//------------------------------------------------------------------
/// The basic constructor takes a Target, which gives the space to search.
///
/// @param[in] target
/// \param[in] target
/// The Target that provides the module list to search.
//------------------------------------------------------------------
SearchFilter(const lldb::TargetSP &target_sp);
@ -129,9 +129,9 @@ public:
//------------------------------------------------------------------
/// Call this method with a file spec to see if that spec passes the filter.
///
/// @param[in] spec
/// \param[in] spec
/// The file spec to check against the filter.
/// @return
/// \return
/// \b true if \a spec passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool ModulePasses(const FileSpec &spec);
@ -139,10 +139,10 @@ public:
//------------------------------------------------------------------
/// Call this method with a Module to see if that module passes the filter.
///
/// @param[in] module
/// \param[in] module
/// The Module to check against the filter.
///
/// @return
/// \return
/// \b true if \a module passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool ModulePasses(const lldb::ModuleSP &module_sp);
@ -150,10 +150,10 @@ public:
//------------------------------------------------------------------
/// Call this method with a Address to see if \a address passes the filter.
///
/// @param[in] addr
/// \param[in] addr
/// The address to check against the filter.
///
/// @return
/// \return
/// \b true if \a address passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool AddressPasses(Address &addr);
@ -162,10 +162,10 @@ public:
/// Call this method with a FileSpec to see if \a file spec passes the
/// filter as the name of a compilation unit.
///
/// @param[in] fileSpec
/// \param[in] fileSpec
/// The file spec to check against the filter.
///
/// @return
/// \return
/// \b true if \a file spec passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool CompUnitPasses(FileSpec &fileSpec);
@ -174,10 +174,10 @@ public:
/// Call this method with a CompileUnit to see if \a comp unit passes the
/// filter.
///
/// @param[in] compUnit
/// \param[in] compUnit
/// The CompileUnit to check against the filter.
///
/// @return
/// \return
/// \b true if \a Comp Unit passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool CompUnitPasses(CompileUnit &compUnit);
@ -186,10 +186,10 @@ public:
/// Call this method with a Function to see if \a function passes the
/// filter.
///
/// @param[in] function
/// \param[in] function
/// The Functions to check against the filter.
///
/// @return
/// \return
/// \b true if \a function passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool FunctionPasses(Function &function);
@ -197,7 +197,7 @@ public:
//------------------------------------------------------------------
/// Call this method to do the search using the Searcher.
///
/// @param[in] searcher
/// \param[in] searcher
/// The searcher to drive with this search.
///
//------------------------------------------------------------------
@ -207,10 +207,10 @@ public:
/// Call this method to do the search using the Searcher in the module list
/// \a modules.
///
/// @param[in] searcher
/// \param[in] searcher
/// The searcher to drive with this search.
///
/// @param[in] modules
/// \param[in] modules
/// The module list within which to restrict the search.
///
//------------------------------------------------------------------
@ -223,7 +223,7 @@ public:
/// search callbacks can then short cut the search to avoid looking at
/// things that obviously won't pass.
///
/// @return
/// \return
/// The required elements for the search, which is an or'ed together
/// set of lldb:SearchContextItem enum's.
///
@ -233,7 +233,7 @@ public:
//------------------------------------------------------------------
/// Prints a canonical description for the search filter to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// Stream to which the output is copied.
//------------------------------------------------------------------
virtual void GetDescription(Stream *s);
@ -329,7 +329,7 @@ private:
};
//----------------------------------------------------------------------
/// @class SearchFilterForUnconstrainedSearches SearchFilter.h
/// \class SearchFilterForUnconstrainedSearches SearchFilter.h
/// "lldb/Core/SearchFilter.h" This is a SearchFilter that searches through
/// all modules. It also consults the
/// Target::ModuleIsExcludedForUnconstrainedSearches.
@ -357,7 +357,7 @@ protected:
};
//----------------------------------------------------------------------
/// @class SearchFilterByModule SearchFilter.h "lldb/Core/SearchFilter.h" This
/// \class SearchFilterByModule SearchFilter.h "lldb/Core/SearchFilter.h" This
/// is a SearchFilter that restricts the search to a given module.
//----------------------------------------------------------------------
@ -367,10 +367,10 @@ public:
/// The basic constructor takes a Target, which gives the space to search,
/// and the module to restrict the search to.
///
/// @param[in] target
/// \param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// \param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModule(const lldb::TargetSP &targetSP, const FileSpec &module);
@ -419,10 +419,10 @@ public:
/// The basic constructor takes a Target, which gives the space to search,
/// and the module list to restrict the search to.
///
/// @param[in] target
/// \param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// \param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModuleList(const lldb::TargetSP &targetSP,
@ -478,10 +478,10 @@ public:
/// The basic constructor takes a Target, which gives the space to search,
/// and the module list to restrict the search to.
///
/// @param[in] target
/// \param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// \param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModuleListAndCU(const lldb::TargetSP &targetSP,

12
lldb/include/lldb/Core/Section.h
View File

@ -206,17 +206,17 @@ public:
/// Read the section data from the object file that the section
/// resides in.
///
/// @param[in] dst
/// \param[in] dst
/// Where to place the data
///
/// @param[in] dst_len
/// \param[in] dst_len
/// How many bytes of section data to read
///
/// @param[in] offset
/// \param[in] offset
/// The offset in bytes within this section's data at which to
/// start copying data from.
///
/// @return
/// \return
/// The number of bytes read from the section, or zero if the
/// section has no data or \a offset is not a valid offset
/// in this section.
@ -231,10 +231,10 @@ public:
/// object file is on disk, it will shared the mmap data for the
/// entire object file.
///
/// @param[in] data
/// \param[in] data
/// Where to place the data, address byte size, and byte order
///
/// @return
/// \return
/// The number of bytes read from the section, or zero if the
/// section has no data or \a offset is not a valid offset
/// in this section.

2
lldb/include/lldb/Core/ValueObject.h
View File

@ -800,7 +800,7 @@ public:
/// pointers, references, arrays and more. Again, it does so without
/// doing any expensive type completion.
///
/// @return
/// \return
/// Returns \b true if the ValueObject might have children, or \b
/// false otherwise.
//------------------------------------------------------------------

86
lldb/include/lldb/Expression/DWARFExpression.h
View File

@ -22,7 +22,7 @@ class DWARFUnit;
namespace lldb_private {
//----------------------------------------------------------------------
/// @class DWARFExpression DWARFExpression.h
/// \class DWARFExpression DWARFExpression.h
/// "lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location
/// expression and interprets it.
///
@ -53,14 +53,14 @@ public:
//------------------------------------------------------------------
/// Constructor
///
/// @param[in] data
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
///
/// @param[in] data_offset
/// \param[in] data_offset
/// The offset of the location expression in the extractor.
///
/// @param[in] data_length
/// \param[in] data_length
/// The byte length of the location expression.
//------------------------------------------------------------------
DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
@ -80,20 +80,20 @@ public:
//------------------------------------------------------------------
/// Print the description of the expression to a stream
///
/// @param[in] s
/// \param[in] s
/// The stream to print to.
///
/// @param[in] level
/// \param[in] level
/// The level of verbosity to use.
///
/// @param[in] location_list_base_addr
/// \param[in] location_list_base_addr
/// If this is a location list based expression, this is the
/// address of the object that owns it. NOTE: this value is
/// different from the DWARF version of the location list base
/// address which is compile unit relative. This base address
/// is the address of the object that owns the location list.
///
/// @param[in] abi
/// \param[in] abi
/// An optional ABI plug-in that can be used to resolve register
/// names.
//------------------------------------------------------------------
@ -113,13 +113,13 @@ public:
//------------------------------------------------------------------
/// Search for a load address in the location list
///
/// @param[in] process
/// \param[in] process
/// The process to use when resolving the load address
///
/// @param[in] addr
/// \param[in] addr
/// The address to resolve
///
/// @return
/// \return
/// True if IsLocationList() is true and the address was found;
/// false otherwise.
//------------------------------------------------------------------
@ -139,15 +139,15 @@ public:
/// static variable since there is no other indication from DWARF debug
/// info.
///
/// @param[in] op_addr_idx
/// \param[in] op_addr_idx
/// The DW_OP_addr index to retrieve in case there is more than
/// one DW_OP_addr opcode in the location byte stream.
///
/// @param[out] error
/// \param[out] error
/// If the location stream contains unknown DW_OP opcodes or the
/// data is missing, \a error will be set to \b true.
///
/// @return
/// \return
/// LLDB_INVALID_ADDRESS if the location doesn't contain a
/// DW_OP_addr for \a op_addr_idx, otherwise a valid file address
//------------------------------------------------------------------
@ -168,7 +168,7 @@ public:
/// Make the expression parser read its location information from a given
/// data source. Does not change the offset and length
///
/// @param[in] data
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
//------------------------------------------------------------------
@ -178,17 +178,17 @@ public:
/// Make the expression parser read its location information from a given
/// data source
///
/// @param[in] module_sp
/// \param[in] module_sp
/// The module that defines the DWARF expression.
///
/// @param[in] data
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
///
/// @param[in] data_offset
/// \param[in] data_offset
/// The offset of the location expression in the extractor.
///
/// @param[in] data_length
/// \param[in] data_length
/// The byte length of the location expression.
//------------------------------------------------------------------
void SetOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
@ -207,17 +207,17 @@ public:
/// though we are copying the data, it shouldn't amount to that much for the
/// variables we end up parsing.
///
/// @param[in] module_sp
/// \param[in] module_sp
/// The module that defines the DWARF expression.
///
/// @param[in] data
/// \param[in] data
/// A data extractor configured to read and copy the DWARF
/// location expression's bytecode.
///
/// @param[in] data_offset
/// \param[in] data_offset
/// The offset of the location expression in the extractor.
///
/// @param[in] data_length
/// \param[in] data_length
/// The byte length of the location expression.
//------------------------------------------------------------------
void CopyOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
@ -233,7 +233,7 @@ public:
//------------------------------------------------------------------
/// Tells the expression that it refers to a location list.
///
/// @param[in] slide
/// \param[in] slide
/// This value should be a slide that is applied to any values
/// in the location list data so the values become zero based
/// offsets into the object that owns the location list. We need
@ -250,7 +250,7 @@ public:
//------------------------------------------------------------------
/// Set the call-frame-info style register kind
///
/// @param[in] reg_kind
/// \param[in] reg_kind
/// The register kind.
//------------------------------------------------------------------
void SetRegisterKind(lldb::RegisterKind reg_kind);
@ -277,59 +277,59 @@ public:
//------------------------------------------------------------------
/// Evaluate a DWARF location expression in a particular context
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context in which to evaluate the location
/// expression. The location expression may access the target's
/// memory, especially if it comes from the expression parser.
///
/// @param[in] opcode_ctx
/// \param[in] opcode_ctx
/// The module which defined the expression.
///
/// @param[in] opcodes
/// \param[in] opcodes
/// This is a static method so the opcodes need to be provided
/// explicitly.
///
/// @param[in] expr_locals
/// \param[in] expr_locals
/// If the location expression was produced by the expression parser,
/// the list of local variables referenced by the DWARF expression.
/// This list should already have been populated during parsing;
/// the DWARF expression refers to variables by index. Can be NULL if
/// the location expression uses no locals.
///
/// @param[in] decl_map
/// \param[in] decl_map
/// If the location expression was produced by the expression parser,
/// the list of external variables referenced by the location
/// expression. Can be NULL if the location expression uses no
/// external variables.
///
/// @param[in] reg_ctx
/// \param[in] reg_ctx
/// An optional parameter which provides a RegisterContext for use
/// when evaluating the expression (i.e. for fetching register values).
/// Normally this will come from the ExecutionContext's StackFrame but
/// in the case where an expression needs to be evaluated while building
/// the stack frame list, this short-cut is available.
///
/// @param[in] offset
/// \param[in] offset
/// The offset of the location expression in the data extractor.
///
/// @param[in] length
/// \param[in] length
/// The length in bytes of the location expression.
///
/// @param[in] reg_set
/// \param[in] reg_set
/// The call-frame-info style register kind.
///
/// @param[in] initial_value_ptr
/// \param[in] initial_value_ptr
/// A value to put on top of the interpreter stack before evaluating
/// the expression, if the expression is parametrized. Can be NULL.
///
/// @param[in] result
/// \param[in] result
/// A value into which the result of evaluating the expression is
/// to be placed.
///
/// @param[in] error_ptr
/// \param[in] error_ptr
/// If non-NULL, used to report errors in expression evaluation.
///
/// @return
/// \return
/// True on success; false otherwise. If error_ptr is non-NULL,
/// details of the failure are provided through it.
//------------------------------------------------------------------
@ -369,19 +369,19 @@ protected:
//------------------------------------------------------------------
/// Pretty-prints the location expression to a stream
///
/// @param[in] stream
/// \param[in] stream
/// The stream to use for pretty-printing.
///
/// @param[in] offset
/// \param[in] offset
/// The offset into the data buffer of the opcodes to be printed.
///
/// @param[in] length
/// \param[in] length
/// The length in bytes of the opcodes to be printed.
///
/// @param[in] level
/// \param[in] level
/// The level of detail to use in pretty-printing.
///
/// @param[in] abi
/// \param[in] abi
/// An optional ABI plug-in that can be used to resolve register
/// names.
//------------------------------------------------------------------

2
lldb/include/lldb/Expression/Expression.h
View File

@ -23,7 +23,7 @@ namespace lldb_private {
class RecordingMemoryManager;
//----------------------------------------------------------------------
/// @class Expression Expression.h "lldb/Expression/Expression.h" Encapsulates
/// \class Expression Expression.h "lldb/Expression/Expression.h" Encapsulates
/// a single expression for use in lldb
///
/// LLDB uses expressions for various purposes, notably to call functions

38
lldb/include/lldb/Expression/ExpressionParser.h
View File

@ -19,7 +19,7 @@ namespace lldb_private {
class IRExecutionUnit;
//----------------------------------------------------------------------
/// @class ExpressionParser ExpressionParser.h
/// \class ExpressionParser ExpressionParser.h
/// "lldb/Expression/ExpressionParser.h" Encapsulates an instance of a
/// compiler that can parse expressions.
///
@ -32,12 +32,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.
//------------------------------------------------------------------
ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
@ -53,23 +53,23 @@ public:
/// Attempts to find possible command line completions for the given
/// expression.
///
/// @param[out] request
/// \param[out] request
/// The completion request to fill out. The completion should be a string
/// that would complete the current token at the cursor position.
/// Note that the string in the list replaces the current token
/// in the command line.
///
/// @param[in] line
/// \param[in] line
/// The line with the completion cursor inside the expression as a string.
/// The first line in the expression has the number 0.
///
/// @param[in] pos
/// \param[in] pos
/// The character position in the line with the completion cursor.
/// If the value is 0, then the cursor is on top of the first character
/// in the line (i.e. the user has requested completion from the start of
/// the expression).
///
/// @param[in] typed_pos
/// \param[in] typed_pos
/// The cursor position in the line as typed by the user. If the user
/// expression has not been transformed in some form (e.g. wrapping it
/// in a function body for C languages), then this is equal to the
@ -77,7 +77,7 @@ public:
/// 'pos' (e.g. a value of 0 means the cursor is at start of the
/// expression).
///
/// @return
/// \return
/// True if we added any completion results to the output;
/// false otherwise.
//------------------------------------------------------------------
@ -88,10 +88,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 in which to store the errors and warnings.
///
/// @return
/// \return
/// The number of errors encountered during parsing. 0 means
/// success.
//------------------------------------------------------------------
@ -102,10 +102,10 @@ public:
/// expression. If successful, the rewritten expression is stored in the
/// diagnostic_manager, get it out with GetFixedExpression.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager containing fixit's to apply.
///
/// @return
/// \return
/// \b true if the rewrite was successful, \b false otherwise.
//------------------------------------------------------------------
virtual bool RewriteExpression(DiagnosticManager &diagnostic_manager) {
@ -116,31 +116,31 @@ 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] can_interpret
/// \param[out] can_interpret
/// Set to true if the expression could be interpreted statically;
/// untouched otherwise.
///
/// @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().
//------------------------------------------------------------------

2
lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h
View File

@ -15,7 +15,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ExpressionTypeSystemHelper ExpressionTypeSystemHelper.h
/// \class ExpressionTypeSystemHelper ExpressionTypeSystemHelper.h
/// "lldb/Expression/ExpressionTypeSystemHelper.h"
/// A helper object that the Expression can pass to its ExpressionParser
/// to provide generic information that

6
lldb/include/lldb/Expression/ExpressionVariable.h
View File

@ -119,7 +119,7 @@ public:
};
//----------------------------------------------------------------------
/// @class ExpressionVariableList ExpressionVariable.h
/// \class ExpressionVariableList ExpressionVariable.h
/// "lldb/Expression/ExpressionVariable.h"
/// A list of variable references.
///
@ -163,10 +163,10 @@ public:
//----------------------------------------------------------------------
/// Finds a variable by name in the list.
///
/// @param[in] name
/// \param[in] name
/// The name of the requested variable.
///
/// @return
/// \return
/// The variable requested, or nullptr if that variable is not in the
/// list.
//----------------------------------------------------------------------

88
lldb/include/lldb/Expression/FunctionCaller.h
View File

@ -23,7 +23,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class FunctionCaller FunctionCaller.h "lldb/Expression/FunctionCaller.h"
/// \class FunctionCaller FunctionCaller.h "lldb/Expression/FunctionCaller.h"
/// Encapsulates a function that can be called.
///
/// A given FunctionCaller object can handle a single function signature.
@ -60,21 +60,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().
//------------------------------------------------------------------
@ -91,15 +91,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.
//------------------------------------------------------------------
virtual unsigned CompileFunction(lldb::ThreadSP thread_to_use_sp,
@ -108,19 +108,19 @@ public:
//------------------------------------------------------------------
/// Insert the default function wrapper and its default argument struct
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in,out] args_addr_ref
/// \param[in,out] args_addr_ref
/// The address of the structure to write the arguments into. May
/// be LLDB_INVALID_ADDRESS; if it is, a new structure is allocated
/// and args_addr_ref is pointed to it.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @return
/// \return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool InsertFunction(ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref,
@ -129,14 +129,14 @@ public:
//------------------------------------------------------------------
/// Insert the default function wrapper (using the JIT)
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @return
/// \return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool WriteFunctionWrapper(ExecutionContext &exe_ctx,
@ -145,19 +145,19 @@ public:
//------------------------------------------------------------------
/// Insert the default function argument struct
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in,out] args_addr_ref
/// \param[in,out] args_addr_ref
/// The address of the structure to write the arguments into. May
/// be LLDB_INVALID_ADDRESS; if it is, a new structure is allocated
/// and args_addr_ref is pointed to it.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @return
/// \return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool WriteFunctionArguments(ExecutionContext &exe_ctx,
@ -168,22 +168,22 @@ public:
/// Insert an argument struct with a non-default function address and non-
/// default argument values
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in,out] args_addr_ref
/// \param[in,out] args_addr_ref
/// The address of the structure to write the arguments into. May
/// be LLDB_INVALID_ADDRESS; if it is, a new structure is allocated
/// and args_addr_ref is pointed at it.
///
/// @param[in] arg_values
/// \param[in] arg_values
/// The values of the function's arguments.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @return
/// \return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool WriteFunctionArguments(ExecutionContext &exe_ctx,
@ -196,10 +196,10 @@ public:
///
/// This is the full version.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The thread & process in which this function will run.
///
/// @param[in] args_addr_ptr
/// \param[in] args_addr_ptr
/// If nullptr, the function will take care of allocating & deallocating
/// the wrapper
/// args structure. Otherwise, if set to LLDB_INVALID_ADDRESS, a new
@ -211,16 +211,16 @@ public:
/// this should point to an already allocated structure with the values
/// already written.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @param[in] options
/// \param[in] options
/// The options for this expression execution.
///
/// @param[out] results
/// \param[out] results
/// The result value will be put here after running the function.
///
/// @return
/// \return
/// Returns one of the ExpressionResults enum indicating function call
/// status.
//------------------------------------------------------------------
@ -233,26 +233,26 @@ public:
/// Get a thread plan to run the function this FunctionCaller was created
/// with.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in] func_addr
/// \param[in] func_addr
/// The address of the function in the target process.
///
/// @param[in] args_addr
/// \param[in] args_addr
/// The address of the argument struct.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// The diagnostic manager to report errors to.
///
/// @param[in] stop_others
/// \param[in] stop_others
/// True if other threads should pause during execution.
///
/// @param[in] unwind_on_error
/// \param[in] unwind_on_error
/// True if the thread plan may simply be discarded if an error occurs.
///
/// @return
/// \return
/// A ThreadPlan shared pointer for executing the function.
//------------------------------------------------------------------
lldb::ThreadPlanSP
@ -263,16 +263,16 @@ public:
//------------------------------------------------------------------
/// Get the result of the function from its struct
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to retrieve the result from.
///
/// @param[in] args_addr
/// \param[in] args_addr
/// The address of the argument struct.
///
/// @param[out] ret_value
/// \param[out] ret_value
/// The value returned by the function.
///
/// @return
/// \return
/// True on success; false otherwise.
//------------------------------------------------------------------
bool FetchFunctionResults(ExecutionContext &exe_ctx, lldb::addr_t args_addr,
@ -281,11 +281,11 @@ public:
//------------------------------------------------------------------
/// Deallocate the arguments structure
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to insert the function and its arguments
/// into.
///
/// @param[in] args_addr
/// \param[in] args_addr
/// The address of the argument struct.
//------------------------------------------------------------------
void DeallocateFunctionResults(ExecutionContext &exe_ctx,

26
lldb/include/lldb/Expression/IRDynamicChecks.h
View File

@ -31,7 +31,7 @@ class ExecutionContext;
class Stream;
//----------------------------------------------------------------------
/// @class DynamicCheckerFunctions IRDynamicChecks.h
/// \class DynamicCheckerFunctions IRDynamicChecks.h
/// "lldb/Expression/IRDynamicChecks.h" Encapsulates dynamic check functions
/// used by expressions.
///
@ -61,13 +61,13 @@ public:
/// Install the utility functions into a process. This binds the instance
/// of DynamicCheckerFunctions to that process.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// A diagnostic manager to report errors to.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to install the functions into.
///
/// @return
/// \return
/// True on success; false on failure, or if the functions have
/// already been installed.
//------------------------------------------------------------------
@ -81,7 +81,7 @@ public:
};
//----------------------------------------------------------------------
/// @class IRDynamicChecks IRDynamicChecks.h
/// \class IRDynamicChecks IRDynamicChecks.h
/// "lldb/Expression/IRDynamicChecks.h" Adds dynamic checks to a user-entered
/// expression to reduce its likelihood of crashing
///
@ -97,13 +97,13 @@ public:
//------------------------------------------------------------------
/// Constructor
///
/// @param[in] checker_functions
/// \param[in] checker_functions
/// The checker functions for the target process.
///
/// @param[in] func_name
/// \param[in] func_name
/// The name of the function to prepare for execution in the target.
///
/// @param[in] decl_map
/// \param[in] decl_map
/// The mapping used to look up entities in the target process. In
/// this case, used to find objc_msgSend
//------------------------------------------------------------------
@ -118,12 +118,12 @@ public:
//------------------------------------------------------------------
/// Run this IR transformer on a single module
///
/// @param[in] M
/// \param[in] M
/// 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.
///
/// @return
/// \return
/// True on success; false otherwise
//------------------------------------------------------------------
bool runOnModule(llvm::Module &M) override;
@ -149,13 +149,13 @@ private:
//------------------------------------------------------------------
/// The top-level pass implementation
///
/// @param[in] M
/// \param[in] M
/// The module currently being processed.
///
/// @param[in] BB
/// \param[in] BB
/// The basic block currently being processed.
///
/// @return
/// \return
/// True on success; false otherwise
//------------------------------------------------------------------
bool FindDataLoads(llvm::Module &M, llvm::BasicBlock &BB);

52
lldb/include/lldb/Expression/IRExecutionUnit.h
View File

@ -37,7 +37,7 @@ namespace lldb_private {
class Status;
//----------------------------------------------------------------------
/// @class IRExecutionUnit IRExecutionUnit.h
/// \class IRExecutionUnit IRExecutionUnit.h
/// "lldb/Expression/IRExecutionUnit.h" Contains the IR and, optionally, JIT-
/// compiled code for a module.
///
@ -116,7 +116,7 @@ public:
void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
//----------------------------------------------------------------------
/// @class JittedFunction IRExecutionUnit.h
/// \class JittedFunction IRExecutionUnit.h
/// "lldb/Expression/IRExecutionUnit.h"
/// Encapsulates a single function that has been generated by the JIT.
///
@ -135,14 +135,14 @@ public:
///
/// Initializes class variabes.
///
/// @param[in] name
/// \param[in] name
/// The name of the function.
///
/// @param[in] local_addr
/// \param[in] local_addr
/// The address of the function in LLDB, or LLDB_INVALID_ADDRESS if
/// it is not present in LLDB's memory.
///
/// @param[in] remote_addr
/// \param[in] remote_addr
/// The address of the function in the target, or LLDB_INVALID_ADDRESS
/// if it is not present in the target's memory.
//------------------------------------------------------------------
@ -181,10 +181,10 @@ private:
/// where it was copied to, and return the remote address at the same offset
/// into the copied entity
///
/// @param[in] local_address
/// \param[in] local_address
/// The address in the debugger.
///
/// @return
/// \return
/// The address in the target process.
//------------------------------------------------------------------
lldb::addr_t GetRemoteAddressForLocal(lldb::addr_t local_address);
@ -194,10 +194,10 @@ private:
/// where it was copied to, and return its address range in the target
/// process
///
/// @param[in] local_address
/// \param[in] local_address
/// The address in the debugger.
///
/// @return
/// \return
/// The range of the containing object in the target process.
//------------------------------------------------------------------
typedef std::pair<lldb::addr_t, uintptr_t> AddrRange;
@ -206,10 +206,10 @@ private:
//------------------------------------------------------------------
/// Commit all allocations to the process and record where they were stored.
///
/// @param[in] process
/// \param[in] process
/// The process to allocate memory in.
///
/// @return
/// \return
/// True <=> all allocations were performed successfully.
/// This method will attempt to free allocated memory if the
/// operation fails.
@ -219,7 +219,7 @@ private:
//------------------------------------------------------------------
/// Report all committed allocations to the execution engine.
///
/// @param[in] engine
/// \param[in] engine
/// The execution engine to notify.
//------------------------------------------------------------------
void ReportAllocations(llvm::ExecutionEngine &engine);
@ -227,10 +227,10 @@ private:
//------------------------------------------------------------------
/// Write the contents of all allocations to the process.
///
/// @param[in] local_address
/// \param[in] local_address
/// The process containing the allocations.
///
/// @return
/// \return
/// True <=> all allocations were performed successfully.
//------------------------------------------------------------------
bool WriteData(lldb::ProcessSP &process_sp);
@ -270,16 +270,16 @@ private:
/// Allocate space for executable code, and add it to the m_spaceBlocks
/// map
///
/// @param[in] Size
/// \param[in] Size
/// The size of the area.
///
/// @param[in] Alignment
/// \param[in] Alignment
/// The required alignment of the area.
///
/// @param[in] SectionID
/// \param[in] SectionID
/// A unique identifier for the section.
///
/// @return
/// \return
/// Allocated space.
//------------------------------------------------------------------
uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
@ -289,19 +289,19 @@ private:
//------------------------------------------------------------------
/// Allocate space for data, and add it to the m_spaceBlocks map
///
/// @param[in] Size
/// \param[in] Size
/// The size of the area.
///
/// @param[in] Alignment
/// \param[in] Alignment
/// The required alignment of the area.
///
/// @param[in] SectionID
/// \param[in] SectionID
/// A unique identifier for the section.
///
/// @param[in] IsReadOnly
/// \param[in] IsReadOnly
/// Flag indicating the section is read-only.
///
/// @return
/// \return
/// Allocated space.
//------------------------------------------------------------------
uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
@ -313,10 +313,10 @@ private:
/// Called when object loading is complete and section page permissions
/// can be applied. Currently unimplemented for LLDB.
///
/// @param[out] ErrMsg
/// \param[out] ErrMsg
/// The error that prevented the page protection from succeeding.
///
/// @return
/// \return
/// True in case of failure, false in case of success.
//------------------------------------------------------------------
bool finalizeMemory(std::string *ErrMsg) override {
@ -349,7 +349,7 @@ private:
static const unsigned eSectionIDInvalid = (unsigned)-1;
//----------------------------------------------------------------------
/// @class AllocationRecord IRExecutionUnit.h
/// \class AllocationRecord IRExecutionUnit.h
/// "lldb/Expression/IRExecutionUnit.h" Encapsulates a single allocation
/// request made by the JIT.
///

2
lldb/include/lldb/Expression/IRInterpreter.h
View File

@ -27,7 +27,7 @@ class IRMemoryMap;
}
//----------------------------------------------------------------------
/// @class IRInterpreter IRInterpreter.h "lldb/Expression/IRInterpreter.h"
/// \class IRInterpreter IRInterpreter.h "lldb/Expression/IRInterpreter.h"
/// Attempt to interpret the function's code if it does not require
/// running the target.
///

2
lldb/include/lldb/Expression/IRMemoryMap.h
View File

@ -18,7 +18,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h"
/// \class IRMemoryMap IRMemoryMap.h "lldb/Expression/IRMemoryMap.h"
/// Encapsulates memory that may exist in the process but must
/// also be available in the host process.
///

2
lldb/include/lldb/Expression/LLVMUserExpression.h
View File

@ -20,7 +20,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class LLVMUserExpression LLVMUserExpression.h
/// \class LLVMUserExpression LLVMUserExpression.h
/// "lldb/Expression/LLVMUserExpression.h" Encapsulates a one-time expression
/// for use in lldb.
///

12
lldb/include/lldb/Expression/REPL.h
View File

@ -35,25 +35,25 @@ public:
/// Get a REPL with an existing target (or, failing that, a debugger to use),
/// and (optional) extra arguments for the compiler.
///
/// @param[out] error
/// \param[out] error
/// If this language is supported but the REPL couldn't be created, this
/// error is populated with the reason.
///
/// @param[in] language
/// \param[in] language
/// The language to create a REPL for.
///
/// @param[in] debugger
/// \param[in] debugger
/// If provided, and target is nullptr, the debugger to use when setting
/// up a top-level REPL.
///
/// @param[in] target
/// \param[in] target
/// If provided, the target to put the REPL inside.
///
/// @param[in] repl_options
/// \param[in] repl_options
/// If provided, additional options for the compiler when parsing REPL
/// expressions.
///
/// @return
/// \return
/// The range of the containing object in the target process.
//------------------------------------------------------------------
static lldb::REPLSP Create(Status &Status, lldb::LanguageType language,

70
lldb/include/lldb/Expression/UserExpression.h
View File

@ -24,7 +24,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class UserExpression UserExpression.h "lldb/Expression/UserExpression.h"
/// \class UserExpression UserExpression.h "lldb/Expression/UserExpression.h"
/// Encapsulates a one-time expression for use in lldb.
///
/// LLDB uses expressions for various purposes, notably to call functions
@ -41,19 +41,19 @@ public:
//------------------------------------------------------------------
/// Constructor
///
/// @param[in] expr
/// \param[in] expr
/// The expression to parse.
///
/// @param[in] expr_prefix
/// \param[in] expr_prefix
/// If non-nullptr, 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.
//------------------------------------------------------------------
@ -70,22 +70,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.
//------------------------------------------------------------------
virtual bool Parse(DiagnosticManager &diagnostic_manager,
@ -97,22 +97,22 @@ public:
/// Attempts to find possible command line completions for the given
/// (possible incomplete) user expression.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to use when looking up entities that
/// are needed for parsing and completing (locations of functions, types
/// of variables, persistent variables, etc.)
///
/// @param[out] request
/// \param[out] request
/// The completion request to fill out. The completion should be a string
/// that would complete the current token at the cursor position.
/// Note that the string in the list replaces the current token
/// in the command line.
///
/// @param[in] complete_pos
/// \param[in] complete_pos
/// The position of the cursor inside the user expression string.
/// The completion process starts on the token that the cursor is in.
///
/// @return
/// \return
/// True if we added any completion results to the output;
/// false otherwise.
//------------------------------------------------------------------
@ -129,28 +129,28 @@ public:
/// Execute the parsed expression by callinng the derived class's DoExecute
/// method.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// A diagnostic manager to report errors 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 variables, etc.)
///
/// @param[in] options
/// \param[in] options
/// Expression evaluation options.
///
/// @param[in] shared_ptr_to_me
/// \param[in] shared_ptr_to_me
/// This is a shared pointer to this UserExpression. This is
/// needed because Execute can push a thread plan that will hold onto
/// the UserExpression for an unbounded period of time. So you
/// need to give the thread plan a reference to this object that can
/// keep it alive.
///
/// @param[in] result
/// \param[in] result
/// A pointer to direct at the persistent variable in which the
/// expression's result is stored.
///
/// @return
/// \return
/// A Process::Execution results value.
//------------------------------------------------------------------
lldb::ExpressionResults Execute(DiagnosticManager &diagnostic_manager,
@ -162,24 +162,24 @@ public:
//------------------------------------------------------------------
/// Apply the side effects of the function to program state.
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// A diagnostic manager to report errors 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 variables, etc.)
///
/// @param[in] result
/// \param[in] result
/// A pointer to direct at the persistent variable in which the
/// expression's result is stored.
///
/// @param[in] function_stack_pointer
/// \param[in] function_stack_pointer
/// A pointer to the base of the function's stack frame. This
/// is used to determine whether the expression result resides in
/// memory that will still be valid, or whether it needs to be
/// treated as homeless for the purpose of future expressions.
///
/// @return
/// \return
/// A Process::Execution results value.
//------------------------------------------------------------------
virtual bool FinalizeJITExecution(
@ -239,36 +239,36 @@ public:
/// Evaluate one expression in the scratch context of the target passed in
/// the exe_ctx and return its result.
///
/// @param[in] exe_ctx
/// \param[in] exe_ctx
/// The execution context to use when evaluating the expression.
///
/// @param[in] options
/// \param[in] options
/// Expression evaluation options. N.B. The language in the
/// evaluation options will be used to determine the language used for
/// expression evaluation.
///
/// @param[in] expr_cstr
/// \param[in] expr_cstr
/// A C string containing the expression to be evaluated.
///
/// @param[in] expr_prefix
/// \param[in] expr_prefix
/// If non-nullptr, a C string containing translation-unit level
/// definitions to be included when the expression is parsed.
///
/// @param[in,out] result_valobj_sp
/// \param[in,out] result_valobj_sp
/// If execution is successful, the result valobj is placed here.
///
/// @param[out] error
/// \param[out] error
/// Filled in with an error in case the expression evaluation
/// fails to parse, run, or evaluated.
///
/// @param[out] fixed_expression
/// \param[out] fixed_expression
/// If non-nullptr, the fixed expression is copied into the provided
/// string.
///
/// @param[out] jit_module_sp_ptr
/// \param[out] jit_module_sp_ptr
/// If non-nullptr, used to persist the generated IR module.
///
/// @param[in] ctx_obj
/// \param[in] ctx_obj
/// If specified, then the expression will be evaluated in the context of
/// this object. It means that the context object's address will be
/// treated as `this` for the expression (the expression will be
@ -278,7 +278,7 @@ public:
/// Currently there is a limitation: the context object must be located
/// in the debuggee process' memory (and have the load address).
///
/// @result
/// \result
/// A Process::ExpressionResults value. eExpressionCompleted for
/// success.
//------------------------------------------------------------------

16
lldb/include/lldb/Expression/UtilityFunction.h
View File

@ -20,7 +20,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class UtilityFunction UtilityFunction.h
/// \class UtilityFunction UtilityFunction.h
/// "lldb/Expression/UtilityFunction.h" Encapsulates a bit of source code that
/// provides a function that is callable
///
@ -34,10 +34,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.
//------------------------------------------------------------------
UtilityFunction(ExecutionContextScope &exe_scope, const char *text,
@ -48,13 +48,13 @@ public:
//------------------------------------------------------------------
/// Install the utility function into a process
///
/// @param[in] diagnostic_manager
/// \param[in] diagnostic_manager
/// A diagnostic manager to print parse 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.
//------------------------------------------------------------------
virtual bool Install(DiagnosticManager &diagnostic_manager,
@ -66,10 +66,10 @@ public:
/// Especially useful if the function dereferences nullptr to indicate a
/// failed assert.
///
/// @param[in] pc
/// \param[in] pc
/// The program counter to check.
///
/// @return
/// \return
/// True if the program counter falls within the function's bounds;
/// false if not (or the function is not JIT compiled)
//------------------------------------------------------------------

92
lldb/include/lldb/Host/File.h
View File

@ -22,7 +22,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class File File.h "lldb/Host/File.h"
/// \class File File.h "lldb/Host/File.h"
/// A file class.
///
/// A file class that divides abstracts the LLDB core from host file
@ -89,13 +89,13 @@ public:
/// This allows code to check a File object to see if it contains anything
/// valid using code such as:
///
/// @code
/// \code
/// File file(...);
/// if (file)
/// { ...
/// @endcode
/// \endcode
///
/// @return
/// \return
/// A pointer to this object if either the directory or filename
/// is valid, nullptr otherwise.
//------------------------------------------------------------------
@ -107,13 +107,13 @@ public:
/// This allows code to check a File object to see if it is invalid using
/// code such as:
///
/// @code
/// \code
/// File file(...);
/// if (!file)
/// { ...
/// @endcode
/// \endcode
///
/// @return
/// \return
/// Returns \b true if the object has an empty directory and
/// filename, \b false otherwise.
//------------------------------------------------------------------
@ -122,7 +122,7 @@ public:
//------------------------------------------------------------------
/// Get the file spec for this file.
///
/// @return
/// \return
/// A reference to the file specification object.
//------------------------------------------------------------------
Status GetFileSpec(FileSpec &file_spec) const;
@ -148,14 +148,14 @@ public:
/// that takes an "off_t &offset" to ensure correct operation in multi-
/// threaded environments.
///
/// @param[in] buf
/// \param[in] buf
/// A buffer where to put the bytes that are read.
///
/// @param[in,out] num_bytes
/// \param[in,out] num_bytes
/// The number of bytes to read form the current file position
/// which gets modified with the number of bytes that were read.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -168,15 +168,15 @@ public:
/// that takes an "off_t &offset" to ensure correct operation in multi-
/// threaded environments.
///
/// @param[in] buf
/// \param[in] buf
/// A buffer where to put the bytes that are read.
///
/// @param[in,out] num_bytes
/// \param[in,out] num_bytes
/// The number of bytes to write to the current file position
/// which gets modified with the number of bytes that were
/// written.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -188,18 +188,18 @@ public:
/// NOTE: This function is NOT thread safe, other threads that
/// access this object might also change the current file position. For
/// thread safe reads and writes see the following functions: @see
/// File::Read (void *, size_t, off_t &) @see File::Write (const void *,
/// File::Read (void *, size_t, off_t &) \see File::Write (const void *,
/// size_t, off_t &)
///
/// @param[in] offset
/// \param[in] offset
/// The offset to seek to within the file relative to the
/// beginning of the file.
///
/// @param[in] error_ptr
/// \param[in] error_ptr
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// \return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromStart(off_t offset, Status *error_ptr = nullptr);
@ -210,18 +210,18 @@ public:
/// NOTE: This function is NOT thread safe, other threads that
/// access this object might also change the current file position. For
/// thread safe reads and writes see the following functions: @see
/// File::Read (void *, size_t, off_t &) @see File::Write (const void *,
/// File::Read (void *, size_t, off_t &) \see File::Write (const void *,
/// size_t, off_t &)
///
/// @param[in] offset
/// \param[in] offset
/// The offset to seek to within the file relative to the
/// current file position.
///
/// @param[in] error_ptr
/// \param[in] error_ptr
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// \return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromCurrent(off_t offset, Status *error_ptr = nullptr);
@ -232,19 +232,19 @@ public:
/// NOTE: This function is NOT thread safe, other threads that
/// access this object might also change the current file position. For
/// thread safe reads and writes see the following functions: @see
/// File::Read (void *, size_t, off_t &) @see File::Write (const void *,
/// File::Read (void *, size_t, off_t &) \see File::Write (const void *,
/// size_t, off_t &)
///
/// @param[in,out] offset
/// \param[in,out] offset
/// The offset to seek to within the file relative to the
/// end of the file which gets filled in with the resulting
/// absolute file offset.
///
/// @param[in] error_ptr
/// \param[in] error_ptr
/// A pointer to a lldb_private::Status object that will be
/// filled in if non-nullptr.
///
/// @return
/// \return
/// The resulting seek offset, or -1 on error.
//------------------------------------------------------------------
off_t SeekFromEnd(off_t offset, Status *error_ptr = nullptr);
@ -256,19 +256,19 @@ public:
/// own file position markers and reads on other threads won't mess up the
/// current read.
///
/// @param[in] dst
/// \param[in] dst
/// A buffer where to put the bytes that are read.
///
/// @param[in,out] num_bytes
/// \param[in,out] num_bytes
/// The number of bytes to read form the current file position
/// which gets modified with the number of bytes that were read.
///
/// @param[in,out] offset
/// \param[in,out] offset
/// The offset within the file from which to read \a num_bytes
/// bytes. This offset gets incremented by the number of bytes
/// that were read.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -281,25 +281,25 @@ public:
/// own file position markers and reads on other threads won't mess up the
/// current read.
///
/// @param[in,out] num_bytes
/// \param[in,out] num_bytes
/// The number of bytes to read form the current file position
/// which gets modified with the number of bytes that were read.
///
/// @param[in,out] offset
/// \param[in,out] offset
/// The offset within the file from which to read \a num_bytes
/// bytes. This offset gets incremented by the number of bytes
/// that were read.
///
/// @param[in] null_terminate
/// \param[in] null_terminate
/// Ensure that the data that is read is terminated with a NULL
/// character so that the data can be used as a C string.
///
/// @param[out] data_buffer_sp
/// \param[out] data_buffer_sp
/// A data buffer to create and fill in that will contain any
/// data that is read from the file. This buffer will be reset
/// if an error occurs.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -314,20 +314,20 @@ public:
/// own locking externally to avoid multiple people writing to the file at
/// the same time.
///
/// @param[in] src
/// \param[in] src
/// A buffer containing the bytes to write.
///
/// @param[in,out] num_bytes
/// \param[in,out] num_bytes
/// The number of bytes to write to the file at offset \a offset.
/// \a num_bytes gets modified with the number of bytes that
/// were read.
///
/// @param[in,out] offset
/// \param[in,out] offset
/// The offset within the file at which to write \a num_bytes
/// bytes. This offset gets incremented by the number of bytes
/// that were written.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -336,7 +336,7 @@ public:
//------------------------------------------------------------------
/// Flush the current stream
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -345,7 +345,7 @@ public:
//------------------------------------------------------------------
/// Sync to disk.
///
/// @return
/// \return
/// An error object that indicates success or the reason for
/// failure.
//------------------------------------------------------------------
@ -354,7 +354,7 @@ public:
//------------------------------------------------------------------
/// Get the permissions for a this file.
///
/// @return
/// \return
/// Bits logical OR'ed together from the permission bits defined
/// in lldb_private::File::Permissions.
//------------------------------------------------------------------
@ -363,7 +363,7 @@ public:
//------------------------------------------------------------------
/// Return true if this file is interactive.
///
/// @return
/// \return
/// True if this file is a terminal (tty or pty), false
/// otherwise.
//------------------------------------------------------------------
@ -376,7 +376,7 @@ public:
/// if the terminal has a width and height so we can do cursor movement and
/// other terminal manipulations by sending escape sequences.
///
/// @return
/// \return
/// True if this file is a terminal (tty, not a pty) that has
/// a non-zero width and height, false otherwise.
//------------------------------------------------------------------
@ -389,10 +389,10 @@ public:
///
/// Print some formatted output to the stream.
///
/// @param[in] format
/// \param[in] format
/// A printf style format string.
///
/// @param[in] ...
/// \param[in] ...
/// Variable arguments that are needed for the printf style
/// format string \a format.
//------------------------------------------------------------------

48
lldb/include/lldb/Host/FileSystem.h
View File

@ -68,87 +68,87 @@ public:
bool should_close_fd = true);
/// Get a directory iterator.
/// @{
/// \{
llvm::vfs::directory_iterator DirBegin(const FileSpec &file_spec,
std::error_code &ec);
llvm::vfs::directory_iterator DirBegin(const llvm::Twine &dir,
std::error_code &ec);
/// @}
/// \}
/// Returns the Status object for the given file.
/// @{
/// \{
llvm::ErrorOr<llvm::vfs::Status> GetStatus(const FileSpec &file_spec) const;
llvm::ErrorOr<llvm::vfs::Status> GetStatus(const llvm::Twine &path) const;
/// @}
/// \}
/// Returns the modification time of the given file.
/// @{
/// \{
llvm::sys::TimePoint<> GetModificationTime(const FileSpec &file_spec) const;
llvm::sys::TimePoint<> GetModificationTime(const llvm::Twine &path) const;
/// @}
/// \}
/// Returns the on-disk size of the given file in bytes.
/// @{
/// \{
uint64_t GetByteSize(const FileSpec &file_spec) const;
uint64_t GetByteSize(const llvm::Twine &path) const;
/// @}
/// \}
/// Return the current permissions of the given file.
///
/// Returns a bitmask for the current permissions of the file (zero or more
/// of the permission bits defined in File::Permissions).
/// @{
/// \{
uint32_t GetPermissions(const FileSpec &file_spec) const;
uint32_t GetPermissions(const llvm::Twine &path) const;
uint32_t GetPermissions(const FileSpec &file_spec, std::error_code &ec) const;
uint32_t GetPermissions(const llvm::Twine &path, std::error_code &ec) const;
/// @}
/// \}
/// Returns whether the given file exists.
/// @{
/// \{
bool Exists(const FileSpec &file_spec) const;
bool Exists(const llvm::Twine &path) const;
/// @}
/// \}
/// Returns whether the given file is readable.
/// @{
/// \{
bool Readable(const FileSpec &file_spec) const;
bool Readable(const llvm::Twine &path) const;
/// @}
/// \}
/// Returns whether the given path is a directory.
/// @{
/// \{
bool IsDirectory(const FileSpec &file_spec) const;
bool IsDirectory(const llvm::Twine &path) const;
/// @}
/// \}
/// Returns whether the given path is local to the file system.
/// @{
/// \{
bool IsLocal(const FileSpec &file_spec) const;
bool IsLocal(const llvm::Twine &path) const;
/// @}
/// \}
/// Make the given file path absolute.
/// @{
/// \{
std::error_code MakeAbsolute(llvm::SmallVectorImpl<char> &path) const;
std::error_code MakeAbsolute(FileSpec &file_spec) const;
/// @}
/// \}
/// Resolve path to make it canonical.
/// @{
/// \{
void Resolve(llvm::SmallVectorImpl<char> &path);
void Resolve(FileSpec &file_spec);
/// @}
/// \}
//// Create memory buffer from path.
/// @{
/// \{
std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const llvm::Twine &path,
uint64_t size = 0,
uint64_t offset = 0);
std::shared_ptr<DataBufferLLVM> CreateDataBuffer(const FileSpec &file_spec,
uint64_t size = 0,
uint64_t offset = 0);
/// @}
/// \}
/// Call into the Host to see if it can help find the file.
bool ResolveExecutableLocation(FileSpec &file_spec);

30
lldb/include/lldb/Host/Host.h
View File

@ -58,7 +58,7 @@ inline bool operator==(WaitStatus a, WaitStatus b) {
inline bool operator!=(WaitStatus a, WaitStatus b) { return !(a == b); }
//----------------------------------------------------------------------
/// @class Host Host.h "lldb/Host/Host.h"
/// \class Host Host.h "lldb/Host/Host.h"
/// A class that provides host computer information.
///
/// Host is a class that answers information about the host operating system.
@ -86,24 +86,24 @@ public:
/// If the child process exits, the monitoring will automatically stop after
/// the callback returned regardless of the callback return value.
///
/// @param[in] callback
/// \param[in] callback
/// A function callback to call when a child receives a signal
/// (if \a monitor_signals is true) or a child exits.
///
/// @param[in] pid
/// \param[in] pid
/// The process ID of a child process to monitor, -1 for all
/// processes.
///
/// @param[in] monitor_signals
/// \param[in] monitor_signals
/// If \b true the callback will get called when the child
/// process gets a signal. If \b false, the callback will only
/// get called if the child process exits.
///
/// @return
/// \return
/// A thread handle that can be used to cancel the thread that
/// was spawned to monitor \a pid.
///
/// @see static void Host::StopMonitoringChildProcess (uint32_t)
/// \see static void Host::StopMonitoringChildProcess (uint32_t)
//------------------------------------------------------------------
static HostThread
StartMonitoringChildProcess(const MonitorChildProcessCallback &callback,
@ -119,7 +119,7 @@ public:
//------------------------------------------------------------------
/// Get the process ID for the calling process.
///
/// @return
/// \return
/// The process ID for the current process.
//------------------------------------------------------------------
static lldb::pid_t GetCurrentProcessID();
@ -130,7 +130,7 @@ public:
/// Get the thread token (the one returned by ThreadCreate when the thread
/// was created) for the calling thread in the current process.
///
/// @return
/// \return
/// The thread token for the calling thread in the current process.
//------------------------------------------------------------------
static lldb::thread_t GetCurrentThread();
@ -144,10 +144,10 @@ public:
/// code is running in for loading resources that are relative to your
/// binary.
///
/// @param[in] host_addr
/// \param[in] host_addr
/// The pointer to some code in the current process.
///
/// @return
/// \return
/// \b A file spec with the module that contains \a host_addr,
/// which may be invalid if \a host_addr doesn't fall into
/// any valid module address range.
@ -159,15 +159,15 @@ public:
/// the bundle directory from the path itself, this function will change a
/// path to a file within a bundle to the bundle directory itself.
///
/// @param[in] file
/// \param[in] file
/// A file spec that might point to a file in a bundle.
///
/// @param[out] bundle_directory
/// \param[out] bundle_directory
/// An object will be filled in with the bundle directory for
/// the bundle when \b true is returned. Otherwise \a file is
/// left untouched and \b false is returned.
///
/// @return
/// \return
/// \b true if \a file was resolved in \a bundle_directory,
/// \b false otherwise.
//------------------------------------------------------------------
@ -179,12 +179,12 @@ public:
/// represents an executable bundle (like the MacOSX app bundles), then
/// locate the executable within the containing bundle.
///
/// @param[in,out] file
/// \param[in,out] file
/// A file spec that currently points to the bundle that will
/// be filled in with the executable path within the bundle
/// if \b true is returned. Otherwise \a file is left untouched.
///
/// @return
/// \return
/// \b true if \a file was resolved, \b false if this function
/// was not able to resolve the path.
//------------------------------------------------------------------

2
lldb/include/lldb/Host/HostInfo.h
View File

@ -10,7 +10,7 @@
#define lldb_Host_HostInfo_h_
//----------------------------------------------------------------------
/// @class HostInfo HostInfo.h "lldb/Host/HostInfo.h"
/// \class HostInfo HostInfo.h "lldb/Host/HostInfo.h"
/// A class that provides host computer information.
///
/// HostInfo is a class that answers information about the host operating

4
lldb/include/lldb/Host/HostInfoBase.h
View File

@ -36,7 +36,7 @@ public:
//------------------------------------------------------------------
/// Gets the host target triple as a const string.
///
/// @return
/// \return
/// A const string object containing the host target triple.
//------------------------------------------------------------------
static llvm::StringRef GetTargetTriple();
@ -44,7 +44,7 @@ public:
//------------------------------------------------------------------
/// Gets the host architecture.
///
/// @return
/// \return
/// A const architecture object that represents the host
/// architecture.
//------------------------------------------------------------------

2
lldb/include/lldb/Host/HostProcess.h
View File

@ -13,7 +13,7 @@
#include "lldb/lldb-types.h"
//----------------------------------------------------------------------
/// @class HostInfo HostInfo.h "lldb/Host/HostProcess.h"
/// \class HostInfo HostInfo.h "lldb/Host/HostProcess.h"
/// A class that represents a running process on the host machine.
///
/// HostProcess allows querying and manipulation of processes running on the

2
lldb/include/lldb/Host/HostThread.h
View File

@ -20,7 +20,7 @@ namespace lldb_private {
class HostNativeThreadBase;
//----------------------------------------------------------------------
/// @class HostInfo HostInfo.h "lldb/Host/HostThread.h"
/// \class HostInfo HostInfo.h "lldb/Host/HostThread.h"
/// A class that represents a thread running inside of a process on the
/// local machine.
///

2
lldb/include/lldb/Host/ProcessRunLock.h
View File

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

52
lldb/include/lldb/Host/PseudoTerminal.h
View File

@ -17,7 +17,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class PseudoTerminal PseudoTerminal.h "lldb/Host/PseudoTerminal.h"
/// \class PseudoTerminal PseudoTerminal.h "lldb/Host/PseudoTerminal.h"
/// A pseudo terminal helper class.
///
/// The pseudo terminal class abstracts the use of pseudo terminals on the
@ -72,14 +72,14 @@ public:
/// PseudoTerminal::ReleaseMasterFileDescriptor() @li
/// PseudoTerminal::ReleaseSaveFileDescriptor()
///
/// @param[out] error
/// \param[out] error
/// An pointer to an error that can describe any errors that
/// occur. This can be NULL if no error status is desired.
///
/// @return
/// @li \b Parent process: a child process ID that is greater
/// \return
/// \li \b Parent process: a child process ID that is greater
/// than zero, or -1 if the fork fails.
/// @li \b Child process: zero.
/// \li \b Child process: zero.
//------------------------------------------------------------------
lldb::pid_t Fork(char *error_str, size_t error_len);
@ -91,11 +91,11 @@ public:
/// PseudoTerminal::ReleaseMasterFileDescriptor() if this object should
/// release ownership of the slave file descriptor.
///
/// @return
/// \return
/// The master file descriptor, or PseudoTerminal::invalid_fd
/// if the master file descriptor is not currently valid.
///
/// @see PseudoTerminal::ReleaseMasterFileDescriptor()
/// \see PseudoTerminal::ReleaseMasterFileDescriptor()
//------------------------------------------------------------------
int GetMasterFileDescriptor() const;
@ -107,11 +107,11 @@ public:
/// PseudoTerminal::ReleaseSlaveFileDescriptor() if this object should
/// release ownership of the slave file descriptor.
///
/// @return
/// \return
/// The slave file descriptor, or PseudoTerminal::invalid_fd
/// if the slave file descriptor is not currently valid.
///
/// @see PseudoTerminal::ReleaseSlaveFileDescriptor()
/// \see PseudoTerminal::ReleaseSlaveFileDescriptor()
//------------------------------------------------------------------
int GetSlaveFileDescriptor() const;
@ -121,11 +121,11 @@ public:
/// A master pseudo terminal should already be valid prior to
/// calling this function.
///
/// @param[out] error
/// \param[out] error
/// An pointer to an error that can describe any errors that
/// occur. This can be NULL if no error status is desired.
///
/// @return
/// \return
/// The name of the slave pseudo terminal as a NULL terminated
/// C. This string that comes from static memory, so a copy of
/// the string should be made as subsequent calls can change
@ -133,7 +133,7 @@ public:
/// a valid master pseudo terminal opened or if the call to
/// \c ptsname() fails.
///
/// @see PseudoTerminal::OpenFirstAvailableMaster()
/// \see PseudoTerminal::OpenFirstAvailableMaster()
//------------------------------------------------------------------
const char *GetSlaveName(char *error_str, size_t error_len) const;
@ -151,20 +151,20 @@ public:
/// If this object still has a valid master file descriptor when its
/// destructor is called, it will close it.
///
/// @param[in] oflag
/// \param[in] oflag
/// Flags to use when calling \c posix_openpt(\a oflag).
/// A value of "O_RDWR|O_NOCTTY" is suggested.
///
/// @param[out] error
/// \param[out] error
/// An pointer to an error that can describe any errors that
/// occur. This can be NULL if no error status is desired.
///
/// @return
/// @li \b true when the master files descriptor is
/// \return
/// \li \b true when the master files descriptor is
/// successfully opened.
/// @li \b false if anything goes wrong.
/// \li \b false if anything goes wrong.
///
/// @see PseudoTerminal::GetMasterFileDescriptor() @see
/// \see PseudoTerminal::GetMasterFileDescriptor() @see
/// PseudoTerminal::ReleaseMasterFileDescriptor()
//------------------------------------------------------------------
bool OpenFirstAvailableMaster(int oflag, char *error_str, size_t error_len);
@ -183,19 +183,19 @@ public:
/// If this object still has a valid slave file descriptor when its
/// destructor is called, it will close it.
///
/// @param[in] oflag
/// \param[in] oflag
/// Flags to use when calling \c open(\a oflag).
///
/// @param[out] error
/// \param[out] error
/// An pointer to an error that can describe any errors that
/// occur. This can be NULL if no error status is desired.
///
/// @return
/// @li \b true when the master files descriptor is
/// \return
/// \li \b true when the master files descriptor is
/// successfully opened.
/// @li \b false if anything goes wrong.
/// \li \b false if anything goes wrong.
///
/// @see PseudoTerminal::OpenFirstAvailableMaster() @see
/// \see PseudoTerminal::OpenFirstAvailableMaster() @see
/// PseudoTerminal::GetSlaveFileDescriptor() @see
/// PseudoTerminal::ReleaseSlaveFileDescriptor()
//------------------------------------------------------------------
@ -209,7 +209,7 @@ public:
/// descriptor if the ownership isn't released using this call and the
/// master file descriptor has been opened.
///
/// @return
/// \return
/// The master file descriptor, or PseudoTerminal::invalid_fd
/// if the mast file descriptor is not currently valid.
//------------------------------------------------------------------
@ -223,7 +223,7 @@ public:
/// descriptor if the ownership isn't released using this call and the slave
/// file descriptor has been opened.
///
/// @return
/// \return
/// The slave file descriptor, or PseudoTerminal::invalid_fd
/// if the slave file descriptor is not currently valid.
//------------------------------------------------------------------

2
lldb/include/lldb/Host/StringConvert.h
View File

@ -18,7 +18,7 @@ namespace lldb_private {
namespace StringConvert {
//----------------------------------------------------------------------
/// @namespace StringConvert StringConvert.h "lldb/Host/StringConvert.h"
/// \namespace StringConvert StringConvert.h "lldb/Host/StringConvert.h"
/// Utility classes for converting strings into Integers
//----------------------------------------------------------------------

32
lldb/include/lldb/Host/Terminal.h
View File

@ -42,7 +42,7 @@ protected:
};
//----------------------------------------------------------------------
/// @class State Terminal.h "lldb/Host/Terminal.h"
/// \class State Terminal.h "lldb/Host/Terminal.h"
/// A terminal state saving/restoring class.
///
/// This class can be used to remember the terminal state for a file
@ -67,14 +67,14 @@ public:
/// "save_process_group" is true, attempt to save the process group info for
/// the TTY.
///
/// @param[in] fd
/// \param[in] fd
/// The file descriptor to save the state of.
///
/// @param[in] save_process_group
/// \param[in] save_process_group
/// If \b true, save the process group settings, else do not
/// save the process group settings for a TTY.
///
/// @return
/// \return
/// Returns \b true if \a fd describes a TTY and if the state
/// was able to be saved, \b false otherwise.
//------------------------------------------------------------------
@ -86,7 +86,7 @@ public:
/// Restore the state of the TTY using the cached values from a previous
/// call to TerminalState::Save(int,bool).
///
/// @return
/// \return
/// Returns \b true if the TTY state was successfully restored,
/// \b false otherwise.
//------------------------------------------------------------------
@ -95,7 +95,7 @@ public:
//------------------------------------------------------------------
/// Test for valid cached TTY state information.
///
/// @return
/// \return
/// Returns \b true if this object has valid saved TTY state
/// settings that can be used to restore a previous state,
/// \b false otherwise.
@ -108,7 +108,7 @@ protected:
//------------------------------------------------------------------
/// Test if tflags is valid.
///
/// @return
/// \return
/// Returns \b true if \a m_tflags is valid and can be restored,
/// \b false otherwise.
//------------------------------------------------------------------
@ -117,7 +117,7 @@ protected:
//------------------------------------------------------------------
/// Test if ttystate is valid.
///
/// @return
/// \return
/// Returns \b true if \a m_ttystate is valid and can be
/// restored, \b false otherwise.
//------------------------------------------------------------------
@ -126,7 +126,7 @@ protected:
//------------------------------------------------------------------
/// Test if the process group information is valid.
///
/// @return
/// \return
/// Returns \b true if \a m_process_group is valid and can be
/// restored, \b false otherwise.
//------------------------------------------------------------------
@ -145,7 +145,7 @@ protected:
};
//----------------------------------------------------------------------
/// @class TerminalStateSwitcher Terminal.h "lldb/Host/Terminal.h"
/// \class TerminalStateSwitcher Terminal.h "lldb/Host/Terminal.h"
/// A TTY state switching class.
///
/// This class can be used to remember 2 TTY states for a given file
@ -166,7 +166,7 @@ public:
//------------------------------------------------------------------
/// Get the number of possible states to save.
///
/// @return
/// \return
/// The number of states that this TTY switcher object contains.
//------------------------------------------------------------------
uint32_t GetNumberOfStates() const;
@ -174,7 +174,7 @@ public:
//------------------------------------------------------------------
/// Restore the TTY state for state at index \a idx.
///
/// @return
/// \return
/// Returns \b true if the TTY state was successfully restored,
/// \b false otherwise.
//------------------------------------------------------------------
@ -185,17 +185,17 @@ public:
/// state is saved for the file descriptor \a fd and the process group
/// information will also be saved if requested by \a save_process_group.
///
/// @param[in] idx
/// \param[in] idx
/// The index into the state array where the state should be
/// saved.
///
/// @param[in] fd
/// \param[in] fd
/// The file descriptor for which to save the settings.
///
/// @param[in] save_process_group
/// \param[in] save_process_group
/// If \b true, save the process group information for the TTY.
///
/// @return
/// \return
/// Returns \b true if the save was successful, \b false
/// otherwise.
//------------------------------------------------------------------

60
lldb/include/lldb/Host/common/NativeProcessProtocol.h
View File

@ -48,7 +48,7 @@ public:
//------------------------------------------------------------------
/// Sends a process a UNIX signal \a signal.
///
/// @return
/// \return
/// Returns an error object.
//------------------------------------------------------------------
virtual Status Signal(int signo) = 0;
@ -60,7 +60,7 @@ public:
/// a SIGSTOP to the process via the NativeProcessProtocol::Signal()
/// operation.
///
/// @return
/// \return
/// Returns an error object.
//------------------------------------------------------------------
virtual Status Interrupt();
@ -211,28 +211,28 @@ public:
/// Note: it is required that the lifetime of the
/// native_delegate outlive the NativeProcessProtocol.
///
/// @param[in] native_delegate
/// \param[in] native_delegate
/// A NativeDelegate impl to be called when certain events
/// happen within the NativeProcessProtocol or related threads.
///
/// @return
/// \return
/// true if the delegate was registered successfully;
/// false if the delegate was already registered.
///
/// @see NativeProcessProtocol::NativeDelegate.
/// \see NativeProcessProtocol::NativeDelegate.
//------------------------------------------------------------------
bool RegisterNativeDelegate(NativeDelegate &native_delegate);
//------------------------------------------------------------------
/// Unregister a native delegate previously registered.
///
/// @param[in] native_delegate
/// \param[in] native_delegate
/// A NativeDelegate impl previously registered with this process.
///
/// @return Returns \b true if the NativeDelegate was
/// \return Returns \b true if the NativeDelegate was
/// successfully removed from the process, \b false otherwise.
///
/// @see NativeProcessProtocol::NativeDelegate
/// \see NativeProcessProtocol::NativeDelegate
//------------------------------------------------------------------
bool UnregisterNativeDelegate(NativeDelegate &native_delegate);
@ -248,20 +248,20 @@ public:
//------------------------------------------------------------------
/// Launch a process for debugging.
///
/// @param[in] launch_info
/// \param[in] launch_info
/// Information required to launch the process.
///
/// @param[in] native_delegate
/// \param[in] native_delegate
/// The delegate that will receive messages regarding the
/// inferior. Must outlive the NativeProcessProtocol
/// instance.
///
/// @param[in] mainloop
/// \param[in] mainloop
/// The mainloop instance with which the process can register
/// callbacks. Must outlive the NativeProcessProtocol
/// instance.
///
/// @return
/// \return
/// A NativeProcessProtocol shared pointer if the operation succeeded or
/// an error object if it failed.
//------------------------------------------------------------------
@ -272,20 +272,20 @@ public:
//------------------------------------------------------------------
/// Attach to an existing process.
///
/// @param[in] pid
/// \param[in] pid
/// pid of the process locatable
///
/// @param[in] native_delegate
/// \param[in] native_delegate
/// The delegate that will receive messages regarding the
/// inferior. Must outlive the NativeProcessProtocol
/// instance.
///
/// @param[in] mainloop
/// \param[in] mainloop
/// The mainloop instance with which the process can register
/// callbacks. Must outlive the NativeProcessProtocol
/// instance.
///
/// @return
/// \return
/// A NativeProcessProtocol shared pointer if the operation succeeded or
/// an error object if it failed.
//------------------------------------------------------------------
@ -298,13 +298,13 @@ public:
/// StartTracing API for starting a tracing instance with the
/// TraceOptions on a specific thread or process.
///
/// @param[in] config
/// \param[in] config
/// The configuration to use when starting tracing.
///
/// @param[out] error
/// \param[out] error
/// Status indicates what went wrong.
///
/// @return
/// \return
/// The API returns a user_id which can be used to get trace
/// data, trace configuration or stopping the trace instance.
/// The user_id is a key to identify and operate with a tracing
@ -320,17 +320,17 @@ public:
//------------------------------------------------------------------
/// StopTracing API as the name suggests stops a tracing instance.
///
/// @param[in] traceid
/// \param[in] traceid
/// The user id of the trace intended to be stopped. Now a
/// user_id may map to multiple threads in which case this API
/// could be used to stop the tracing for a specific thread by
/// supplying its thread id.
///
/// @param[in] thread
/// \param[in] thread
/// Thread is needed when the complete process is being traced
/// and the user wishes to stop tracing on a particular thread.
///
/// @return
/// \return
/// Status indicating what went wrong.
//------------------------------------------------------------------
virtual Status StopTrace(lldb::user_id_t traceid,
@ -342,21 +342,21 @@ public:
/// This API provides the trace data collected in the form of raw
/// data.
///
/// @param[in] traceid thread
/// \param[in] traceid thread
/// The traceid and thread provide the context for the trace
/// instance.
///
/// @param[in] buffer
/// \param[in] buffer
/// The buffer provides the destination buffer where the trace
/// data would be read to. The buffer should be truncated to the
/// filled length by this function.
///
/// @param[in] offset
/// \param[in] offset
/// There is possibility to read partially the trace data from
/// a specified offset where in such cases the buffer provided
/// may be smaller than the internal trace collection container.
///
/// @return
/// \return
/// The size of the data actually read.
//------------------------------------------------------------------
virtual Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
@ -378,18 +378,18 @@ public:
//------------------------------------------------------------------
/// API to query the TraceOptions for a given user id
///
/// @param[in] traceid
/// \param[in] traceid
/// The user id of the tracing instance.
///
/// @param[in] config
/// \param[in] config
/// The thread id of the tracing instance, in case configuration
/// for a specific thread is needed should be specified in the
/// config.
///
/// @param[out] error
/// \param[out] error
/// Status indicates what went wrong.
///
/// @param[out] config
/// \param[out] config
/// The actual configuration being used for tracing.
//------------------------------------------------------------------
virtual Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) {

2
lldb/include/lldb/Host/posix/PipePosix.h
View File

@ -15,7 +15,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class PipePosix PipePosix.h "lldb/Host/posix/PipePosix.h"
/// \class PipePosix PipePosix.h "lldb/Host/posix/PipePosix.h"
/// A posix-based implementation of Pipe, a class that abtracts
/// unix style pipes.
///

2
lldb/include/lldb/Host/windows/PipeWindows.h
View File

@ -15,7 +15,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Pipe PipeWindows.h "lldb/Host/windows/PipeWindows.h"
/// \class Pipe PipeWindows.h "lldb/Host/windows/PipeWindows.h"
/// A windows-based implementation of Pipe, a class that abtracts
/// unix style pipes.
///

38
lldb/include/lldb/Interpreter/CommandInterpreter.h
View File

@ -36,27 +36,27 @@ public:
///
/// The meanings of the options in this object are:
///
/// @param[in] stop_on_continue
/// \param[in] stop_on_continue
/// If \b true, execution will end on the first command that causes the
/// process in the execution context to continue. If \b false, we won't
/// check the execution status.
/// @param[in] stop_on_error
/// \param[in] stop_on_error
/// If \b true, execution will end on the first command that causes an
/// error.
/// @param[in] stop_on_crash
/// \param[in] stop_on_crash
/// If \b true, when a command causes the target to run, and the end of the
/// run is a signal or exception, stop executing the commands.
/// @param[in] echo_commands
/// \param[in] echo_commands
/// If \b true, echo the command before executing it. If \b false, execute
/// silently.
/// @param[in] echo_comments
/// \param[in] echo_comments
/// If \b true, echo command even if it is a pure comment line. If
/// \b false, print no ouput in this case. This setting has an effect only
/// if \param echo_commands is \b true.
/// @param[in] print_results
/// \param[in] print_results
/// If \b true print the results of the command after executing it. If
/// \b false, execute silently.
/// @param[in] add_to_history
/// \param[in] add_to_history
/// If \b true add the commands to the command history. If \b false, don't
/// add them.
//------------------------------------------------------------------
@ -257,17 +257,17 @@ public:
//------------------------------------------------------------------
/// Execute a list of commands in sequence.
///
/// @param[in] commands
/// \param[in] commands
/// The list of commands to execute.
/// @param[in,out] context
/// \param[in,out] context
/// The execution context in which to run the commands. Can be nullptr in
/// which case the default
/// context will be used.
/// @param[in] options
/// \param[in] options
/// This object holds the options used to control when to stop, whether to
/// execute commands,
/// etc.
/// @param[out] result
/// \param[out] result
/// This is marked as succeeding with no output if all commands execute
/// safely,
/// and failed with some explanation if we aborted executing the commands
@ -280,17 +280,17 @@ public:
//------------------------------------------------------------------
/// Execute a list of commands from a file.
///
/// @param[in] file
/// \param[in] file
/// The file from which to read in commands.
/// @param[in,out] context
/// \param[in,out] context
/// The execution context in which to run the commands. Can be nullptr in
/// which case the default
/// context will be used.
/// @param[in] options
/// \param[in] options
/// This object holds the options used to control when to stop, whether to
/// execute commands,
/// etc.
/// @param[out] result
/// \param[out] result
/// This is marked as succeeding with no output if all commands execute
/// safely,
/// and failed with some explanation if we aborted executing the commands
@ -482,18 +482,18 @@ public:
//------------------------------------------------------------------
/// Sets the exit code for the quit command.
/// @param[in] exit_code
/// \param[in] exit_code
/// The exit code that the driver should return on exit.
/// @return True if the exit code was successfully set; false if the
/// \return True if the exit code was successfully set; false if the
/// interpreter doesn't allow custom exit codes.
/// @see AllowExitCodeOnQuit
/// \see AllowExitCodeOnQuit
//------------------------------------------------------------------
LLVM_NODISCARD bool SetQuitExitCode(int exit_code);
//------------------------------------------------------------------
/// Returns the exit code that the user has specified when running the
/// 'quit' command.
/// @param[out] exited
/// \param[out] exited
/// Set to true if the user has called quit with a custom exit code.
//------------------------------------------------------------------
int GetQuitExitCode(bool &exited) const;

20
lldb/include/lldb/Interpreter/CommandObject.h
View File

@ -226,14 +226,14 @@ public:
/// option. Don't override this method, override HandleArgumentCompletion
/// instead unless you have special reasons.
///
/// @param[in/out] request
/// \param[in/out] request
/// The completion request that needs to be answered.
///
/// FIXME: This is the wrong return value, since we also need to make a
/// distinction between
/// total number of matches, and the window the user wants returned.
///
/// @return
/// \return
/// \btrue if we were in an option, \bfalse otherwise.
//------------------------------------------------------------------
virtual int HandleCompletion(CompletionRequest &request);
@ -246,14 +246,14 @@ public:
/// We've constructed the map of options and their arguments as well if that
/// is helpful for the completion.
///
/// @param[in/out] request
/// \param[in/out] request
/// The completion request that needs to be answered.
///
/// FIXME: This is the wrong return value, since we also need to make a
/// distinction between
/// total number of matches, and the window the user wants returned.
///
/// @return
/// \return
/// The number of completions.
//------------------------------------------------------------------
virtual int
@ -271,7 +271,7 @@ public:
//------------------------------------------------------------------
/// The flags accessor.
///
/// @return
/// \return
/// A reference to the Flags member variable.
//------------------------------------------------------------------
Flags &GetFlags() { return m_flags; }
@ -279,7 +279,7 @@ public:
//------------------------------------------------------------------
/// The flags const accessor.
///
/// @return
/// \return
/// A const reference to the Flags member variable.
//------------------------------------------------------------------
const Flags &GetFlags() const { return m_flags; }
@ -287,10 +287,10 @@ public:
//------------------------------------------------------------------
/// Get the command that appropriate for a "repeat" of the current command.
///
/// @param[in] current_command_line
/// \param[in] current_command_line
/// The complete current command line.
///
/// @return
/// \return
/// nullptr if there is no special repeat command - it will use the
/// current command line.
/// Otherwise a pointer to the command to be repeated.
@ -371,11 +371,11 @@ protected:
/// Check the command to make sure anything required by this
/// command is available.
///
/// @param[out] result
/// \param[out] result
/// A command result object, if it is not okay to run the command
/// this will be filled in with a suitable error.
///
/// @return
/// \return
/// \b true if it is okay to run this command, \b false otherwise.
//------------------------------------------------------------------
bool CheckRequirements(CommandReturnObject &result);

6
lldb/include/lldb/Interpreter/OptionValueBoolean.h
View File

@ -57,13 +57,13 @@ public:
///
/// This allows code to check a OptionValueBoolean in conditions.
///
/// @code
/// \code
/// OptionValueBoolean bool_value(...);
/// if (bool_value)
/// { ...
/// @endcode
/// \endcode
///
/// @return
/// \return
/// /b True this object contains a valid namespace decl, \b
/// false otherwise.
//------------------------------------------------------------------

36
lldb/include/lldb/Interpreter/Options.h
View File

@ -47,7 +47,7 @@ static inline bool isprint8(int ch) {
}
//----------------------------------------------------------------------
/// @class Options Options.h "lldb/Interpreter/Options.h"
/// \class Options Options.h "lldb/Interpreter/Options.h"
/// A command line option parsing protocol class.
///
/// Options is designed to be subclassed to contain all needed options for a
@ -76,8 +76,8 @@ public:
//------------------------------------------------------------------
/// Get the option definitions to use when parsing Args options.
///
/// @see Args::ParseOptions (Options&)
/// @see man getopt_long_only
/// \see Args::ParseOptions (Options&)
/// \see man getopt_long_only
//------------------------------------------------------------------
Option *GetLongOptions();
@ -149,21 +149,21 @@ public:
//------------------------------------------------------------------
/// Set the value of an option.
///
/// @param[in] option_idx
/// \param[in] option_idx
/// The index into the "struct option" array that was returned
/// by Options::GetLongOptions().
///
/// @param[in] option_arg
/// \param[in] option_arg
/// The argument value for the option that the user entered, or
/// nullptr if there is no argument for the current option.
///
/// @param[in] execution_context
/// \param[in] execution_context
/// The execution context to use for evaluating the option.
/// May be nullptr if the option is to be evaluated outside any
/// particular context.
///
/// @see Args::ParseOptions (Options&)
/// @see man getopt_long_only
/// \see Args::ParseOptions (Options&)
/// \see man getopt_long_only
//------------------------------------------------------------------
virtual Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) = 0;
@ -172,17 +172,17 @@ public:
/// Handles the generic bits of figuring out whether we are in an option,
/// and if so completing it.
///
/// @param[in/out] request
/// \param[in/out] request
/// The completion request that we need to act upon.
///
/// @param[in] interpreter
/// \param[in] interpreter
/// The interpreter that's doing the completing.
///
/// FIXME: This is the wrong return value, since we also need to
/// make a distinction between total number of matches, and the window the
/// user wants returned.
///
/// @return
/// \return
/// \btrue if we were in an option, \bfalse otherwise.
//------------------------------------------------------------------
bool HandleOptionCompletion(lldb_private::CompletionRequest &request,
@ -193,17 +193,17 @@ public:
/// Handles the generic bits of figuring out whether we are in an option,
/// and if so completing it.
///
/// @param[in/out] request
/// \param[in/out] request
/// The completion request that we need to act upon.
///
/// @param[in] interpreter
/// \param[in] interpreter
/// The command interpreter doing the completion.
///
/// FIXME: This is the wrong return value, since we also need to
/// make a distinction between total number of matches, and the window the
/// user wants returned.
///
/// @return
/// \return
/// \btrue if we were in an option, \bfalse otherwise.
//------------------------------------------------------------------
virtual bool
@ -289,7 +289,7 @@ public:
/// Append all options from \a group using the exact same option groups that
/// each option is defined with.
///
/// @param[in] group
/// \param[in] group
/// A group of options to take option values from and copy their
/// definitions into this class.
//----------------------------------------------------------------------
@ -302,18 +302,18 @@ public:
/// "src_mask" set. After the option definition is copied into the options
/// definitions in this class, set the usage_mask to "dst_mask".
///
/// @param[in] group
/// \param[in] group
/// A group of options to take option values from and copy their
/// definitions into this class.
///
/// @param[in] src_mask
/// \param[in] src_mask
/// When copying options from \a group, you might only want some of
/// the options to be appended to this group. This mask allows you
/// to control which options from \a group get added. It also allows
/// you to specify the same options from \a group multiple times
/// for different option sets.
///
/// @param[in] dst_mask
/// \param[in] dst_mask
/// Set the usage mask for any copied options to \a dst_mask after
/// copying the option definition.
//----------------------------------------------------------------------

92
lldb/include/lldb/Symbol/Block.h
View File

@ -23,7 +23,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Block Block.h "lldb/Symbol/Block.h"
/// \class Block Block.h "lldb/Symbol/Block.h"
/// A class that describes a single lexical block.
///
/// A Function object owns a BlockList object which owns one or more
@ -52,7 +52,7 @@ public:
/// \a block_list is used to represent the parent, sibling, and child block
/// information and also allows for partial parsing at the block level.
///
/// @param[in] uid
/// \param[in] uid
/// The UID for a given block. This value is given by the
/// SymbolFile plug-in and can be any value that helps the
/// SymbolFile plug-in to match this block back to the debug
@ -60,13 +60,13 @@ public:
/// depth parsing. Common values would be the index into a
/// table, or an offset into the debug information.
///
/// @param[in] depth
/// \param[in] depth
/// The integer depth of this block in the block list hierarchy.
///
/// @param[in] block_list
/// \param[in] block_list
/// The block list that this object belongs to.
///
/// @see BlockList
/// \see BlockList
//------------------------------------------------------------------
Block(lldb::user_id_t uid);
@ -78,7 +78,7 @@ public:
//------------------------------------------------------------------
/// Add a child to this object.
///
/// @param[in] child_block_sp
/// \param[in] child_block_sp
/// A shared pointer to a child block that will get added to
/// this block.
//------------------------------------------------------------------
@ -87,11 +87,11 @@ public:
//------------------------------------------------------------------
/// Add a new offset range to this block.
///
/// @param[in] start_offset
/// \param[in] start_offset
/// An offset into this Function's address range that
/// describes the start address of a range for this block.
///
/// @param[in] end_offset
/// \param[in] end_offset
/// An offset into this Function's address range that
/// describes the end address of a range for this block.
//------------------------------------------------------------------
@ -100,9 +100,9 @@ public:
void FinalizeRanges();
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
/// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void CalculateSymbolContext(SymbolContext *sc) override;
@ -117,10 +117,10 @@ public:
//------------------------------------------------------------------
/// Check if an offset is in one of the block offset ranges.
///
/// @param[in] range_offset
/// \param[in] range_offset
/// An offset into the Function's address range.
///
/// @return
/// \return
/// Returns \b true if \a range_offset falls in one of this
/// block's ranges, \b false otherwise.
//------------------------------------------------------------------
@ -129,10 +129,10 @@ public:
//------------------------------------------------------------------
/// Check if a offset range is in one of the block offset ranges.
///
/// @param[in] range
/// \param[in] range
/// An offset range into the Function's address range.
///
/// @return
/// \return
/// Returns \b true if \a range falls in one of this
/// block's ranges, \b false otherwise.
//------------------------------------------------------------------
@ -141,10 +141,10 @@ public:
//------------------------------------------------------------------
/// Check if this object contains "block" as a child block at any depth.
///
/// @param[in] block
/// \param[in] block
/// A potential child block.
///
/// @return
/// \return
/// Returns \b true if \a block is a child of this block, \b
/// false otherwise.
//------------------------------------------------------------------
@ -153,29 +153,29 @@ public:
//------------------------------------------------------------------
/// Dump the block contents.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] base_addr
/// \param[in] base_addr
/// The resolved start address of the Function's address
/// range. This should be resolved as the file or load address
/// prior to passing the value into this function for dumping.
///
/// @param[in] depth
/// \param[in] depth
/// Limit the number of levels deep that this function should
/// print as this block can contain child blocks. Specify
/// INT_MAX to dump all child blocks.
///
/// @param[in] show_context
/// \param[in] show_context
/// If \b true, variables will dump their context information.
//------------------------------------------------------------------
void Dump(Stream *s, lldb::addr_t base_addr, int32_t depth,
bool show_context) const;
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
/// \copydoc SymbolContextScope::DumpSymbolContext(Stream*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void DumpSymbolContext(Stream *s) override;
@ -187,7 +187,7 @@ public:
//------------------------------------------------------------------
/// Get the parent block.
///
/// @return
/// \return
/// The parent block pointer, or nullptr if this block has no
/// parent.
//------------------------------------------------------------------
@ -196,7 +196,7 @@ public:
//------------------------------------------------------------------
/// Get the inlined block that contains this block.
///
/// @return
/// \return
/// If this block contains inlined function info, it will return
/// this block, else parent blocks will be searched to see if
/// any contain this block. nullptr will be returned if this block
@ -207,7 +207,7 @@ public:
//------------------------------------------------------------------
/// Get the inlined parent block for this block.
///
/// @return
/// \return
/// The parent block pointer, or nullptr if this block has no
/// parent.
//------------------------------------------------------------------
@ -216,7 +216,7 @@ public:
//------------------------------------------------------------------
/// Get the sibling block for this block.
///
/// @return
/// \return
/// The sibling block pointer, or nullptr if this block has no
/// sibling.
//------------------------------------------------------------------
@ -225,7 +225,7 @@ public:
//------------------------------------------------------------------
/// Get the first child block.
///
/// @return
/// \return
/// The first child block pointer, or nullptr if this block has no
/// children.
//------------------------------------------------------------------
@ -236,12 +236,12 @@ public:
//------------------------------------------------------------------
/// Get the variable list for this block only.
///
/// @param[in] can_create
/// \param[in] can_create
/// If \b true, the variables can be parsed if they already
/// haven't been, else the current state of the block will be
/// returned.
///
/// @return
/// \return
/// A variable list shared pointer that contains all variables
/// for this block.
//------------------------------------------------------------------
@ -251,24 +251,24 @@ public:
/// Get the variable list for this block and optionally all child blocks if
/// \a get_child_variables is \b true.
///
/// @param[in] get_child_variables
/// \param[in] get_child_variables
/// If \b true, all variables from all child blocks will be
/// added to the variable list.
///
/// @param[in] can_create
/// \param[in] can_create
/// If \b true, the variables can be parsed if they already
/// haven't been, else the current state of the block will be
/// returned. Passing \b true for this parameter can be used
/// to see the current state of what has been parsed up to this
/// point.
///
/// @param[in] add_inline_child_block_variables
/// \param[in] add_inline_child_block_variables
/// If this is \b false, no child variables of child blocks
/// that are inlined functions will be gotten. If \b true then
/// all child variables will be added regardless of whether they
/// come from inlined functions or not.
///
/// @return
/// \return
/// A variable list shared pointer that contains all variables
/// for this block.
//------------------------------------------------------------------
@ -281,27 +281,27 @@ public:
/// Appends the variables from this block, and optionally from all parent
/// blocks, to \a variable_list.
///
/// @param[in] can_create
/// \param[in] can_create
/// If \b true, the variables can be parsed if they already
/// haven't been, else the current state of the block will be
/// returned. Passing \b true for this parameter can be used
/// to see the current state of what has been parsed up to this
/// point.
///
/// @param[in] get_parent_variables
/// \param[in] get_parent_variables
/// If \b true, all variables from all parent blocks will be
/// added to the variable list.
///
/// @param[in] stop_if_block_is_inlined_function
/// \param[in] stop_if_block_is_inlined_function
/// If \b true, all variables from all parent blocks will be
/// added to the variable list until there are no parent blocks
/// or the parent block has inlined function info.
///
/// @param[in,out] variable_list
/// \param[in,out] variable_list
/// All variables in this block, and optionally all parent
/// blocks will be added to this list.
///
/// @return
/// \return
/// The number of variable that were appended to \a
/// variable_list.
//------------------------------------------------------------------
@ -313,7 +313,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for any inlined function information.
///
/// @return
/// \return
/// A const pointer to any inlined function information, or nullptr
/// if this is a regular block.
//------------------------------------------------------------------
@ -325,7 +325,7 @@ public:
/// Get the symbol file which contains debug info for this block's
/// symbol context module.
///
/// @return A pointer to the symbol file or nullptr.
/// \return A pointer to the symbol file or nullptr.
//------------------------------------------------------------------
SymbolFile *GetSymbolFile();
@ -337,7 +337,7 @@ public:
/// Returns the cost of this object plus any owned objects from the ranges,
/// variables, and inline function information.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
//------------------------------------------------------------------
size_t MemorySize() const;
@ -345,21 +345,21 @@ public:
//------------------------------------------------------------------
/// Set accessor for any inlined function information.
///
/// @param[in] name
/// \param[in] name
/// The method name for the inlined function. This value should
/// not be nullptr.
///
/// @param[in] mangled
/// \param[in] mangled
/// The mangled method name for the inlined function. This can
/// be nullptr if there is no mangled name for an inlined function
/// or if the name is the same as \a name.
///
/// @param[in] decl_ptr
/// \param[in] decl_ptr
/// A optional pointer to declaration information for the
/// inlined function information. This value can be nullptr to
/// indicate that no declaration information is available.
///
/// @param[in] call_decl_ptr
/// \param[in] call_decl_ptr
/// Optional calling location declaration information that
/// describes from where this inlined function was called.
//------------------------------------------------------------------
@ -377,7 +377,7 @@ public:
/// Called by the SymbolFile plug-ins after they have parsed the variable
/// lists and are ready to hand ownership of the list over to this object.
///
/// @param[in] variable_list_sp
/// \param[in] variable_list_sp
/// A shared pointer to a VariableList.
//------------------------------------------------------------------
void SetVariableList(lldb::VariableListSP &variable_list_sp) {

98
lldb/include/lldb/Symbol/CompileUnit.h
View File

@ -22,7 +22,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h"
/// \class CompileUnit CompileUnit.h "lldb/Symbol/CompileUnit.h"
/// A class that describes a compilation unit.
///
/// A representation of a compilation unit, or compiled source file.
@ -47,34 +47,34 @@ public:
/// convert into a FileSpec, the SymbolFile plug-in supplied \a uid, and the
/// source language type.
///
/// @param[in] module
/// \param[in] module
/// The parent module that owns this compile unit. This value
/// must be a valid pointer value.
///
/// @param[in] user_data
/// \param[in] user_data
/// User data where the SymbolFile parser can store data.
///
/// @param[in] pathname
/// \param[in] pathname
/// The path to the source file for this compile unit.
///
/// @param[in] uid
/// \param[in] uid
/// The user ID of the compile unit. This value is supplied by
/// the SymbolFile plug-in and should be a value that allows
/// the SymbolFile plug-in to easily locate and parse additional
/// information for the compile unit.
///
/// @param[in] language
/// \param[in] language
/// A language enumeration type that describes the main language
/// of this compile unit.
///
/// @param[in] is_optimized
/// \param[in] is_optimized
/// A value that can initialized with eLazyBoolYes, eLazyBoolNo
/// or eLazyBoolCalculate. If set to eLazyBoolCalculate, then
/// an extra call into SymbolVendor will be made to calculate if
/// the compile unit is optimized will be made when
/// CompileUnit::GetIsOptimized() is called.
///
/// @see lldb::LanguageType
/// \see lldb::LanguageType
//------------------------------------------------------------------
CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
const char *pathname, lldb::user_id_t uid,
@ -87,35 +87,35 @@ public:
/// convert into a FileSpec, the SymbolFile plug-in supplied \a uid, and the
/// source language type.
///
/// @param[in] module
/// \param[in] module
/// The parent module that owns this compile unit. This value
/// must be a valid pointer value.
///
/// @param[in] user_data
/// \param[in] user_data
/// User data where the SymbolFile parser can store data.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// The file specification for the source file of this compile
/// unit.
///
/// @param[in] uid
/// \param[in] uid
/// The user ID of the compile unit. This value is supplied by
/// the SymbolFile plug-in and should be a value that allows
/// the plug-in to easily locate and parse
/// additional information for the compile unit.
///
/// @param[in] language
/// \param[in] language
/// A language enumeration type that describes the main language
/// of this compile unit.
///
/// @param[in] is_optimized
/// \param[in] is_optimized
/// A value that can initialized with eLazyBoolYes, eLazyBoolNo
/// or eLazyBoolCalculate. If set to eLazyBoolCalculate, then
/// an extra call into SymbolVendor will be made to calculate if
/// the compile unit is optimized will be made when
/// CompileUnit::GetIsOptimized() is called.
///
/// @see lldb::LanguageType
/// \see lldb::LanguageType
//------------------------------------------------------------------
CompileUnit(const lldb::ModuleSP &module_sp, void *user_data,
const FileSpec &file_spec, lldb::user_id_t uid,
@ -132,15 +132,15 @@ public:
/// Typically called by the SymbolFile plug-ins as they partially parse the
/// debug information.
///
/// @param[in] function_sp
/// \param[in] function_sp
/// A shared pointer to the Function object.
//------------------------------------------------------------------
void AddFunction(lldb::FunctionSP &function_sp);
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
/// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void CalculateSymbolContext(SymbolContext *sc) override;
@ -149,9 +149,9 @@ public:
CompileUnit *CalculateSymbolContextCompileUnit() override;
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
/// \copydoc SymbolContextScope::DumpSymbolContext(Stream*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void DumpSymbolContext(Stream *s) override;
@ -170,9 +170,9 @@ public:
/// This provides raw access to the function shared pointer list and will not
/// cause the SymbolFile plug-in to parse any unparsed functions.
///
/// @note Prefer using FindFunctionByUID over this if possible.
/// \note Prefer using FindFunctionByUID over this if possible.
///
/// @param[in] lambda
/// \param[in] lambda
/// The lambda that should be applied to every function. The lambda can
/// return true if the iteration should be aborted earlier.
//------------------------------------------------------------------
@ -182,10 +182,10 @@ public:
//------------------------------------------------------------------
/// Dump the compile unit contents to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] show_context
/// \param[in] show_context
/// If \b true, variables will dump their symbol context
/// information.
//------------------------------------------------------------------
@ -204,27 +204,27 @@ public:
/// file and line by starting with \a start_idx equal to zero, and calling
/// this function back with the return value + 1.
///
/// @param[in] start_idx
/// \param[in] start_idx
/// The zero based index at which to start looking for matches.
///
/// @param[in] line
/// \param[in] line
/// The line number to search for.
///
/// @param[in] file_spec_ptr
/// \param[in] file_spec_ptr
/// If non-NULL search for entries that match this file spec,
/// else if NULL, search for line entries that match the compile
/// unit file.
///
/// @param[in] exact
/// \param[in] exact
/// If \btrue match only if there is a line table entry for this line
/// number.
/// If \bfalse, find the line table entry equal to or after this line
/// number.
///
/// @param[out] line_entry
/// \param[out] line_entry
/// If non-NULL, a copy of the line entry that was found.
///
/// @return
/// \return
/// The zero based index of a matching line entry, or UINT32_MAX
/// if no matching line entry is found.
//------------------------------------------------------------------
@ -239,7 +239,7 @@ public:
/// use this function to determine if the line table has be parsed yet.
/// Clients use this function to get the line table from a compile unit.
///
/// @return
/// \return
/// The line table object pointer, or NULL if this line table
/// hasn't been parsed yet.
//------------------------------------------------------------------
@ -253,7 +253,7 @@ public:
/// The support file list is used by the line table, and any objects that
/// have valid Declaration objects.
///
/// @return
/// \return
/// A support file list object.
//------------------------------------------------------------------
FileSpecList &GetSupportFiles();
@ -264,7 +264,7 @@ public:
/// This reports all the imports that the compile unit made, including the
/// current module.
///
/// @return
/// \return
/// A list of imported module names.
//------------------------------------------------------------------
const std::vector<SourceModule> &GetImportedModules();
@ -275,7 +275,7 @@ public:
/// SymbolFile plug-ins can store user data to internal state or objects to
/// quickly allow them to parse more information for a given object.
///
/// @return
/// \return
/// The user data stored with the CompileUnit when it was
/// constructed.
//------------------------------------------------------------------
@ -288,14 +288,14 @@ public:
/// variable list will contain all global and static variables that were
/// defined at the compile unit level.
///
/// @param[in] can_create
/// \param[in] can_create
/// If \b true, the variable list will be parsed on demand. If
/// \b false, the current variable list will be returned even
/// if it contains a NULL VariableList object (typically
/// called by dumping routines that want to display only what
/// has currently been parsed).
///
/// @return
/// \return
/// A shared pointer to a variable list, that can contain NULL
/// VariableList pointer if there are no global or static
/// variables.
@ -308,13 +308,13 @@ public:
/// Typically used by SymbolFile plug-ins when partially parsing the debug
/// information to see if the function has been parsed yet.
///
/// @param[in] uid
/// \param[in] uid
/// The user ID of the function to find. This value is supplied
/// by the SymbolFile plug-in and should be a value that
/// allows the plug-in to easily locate and parse additional
/// information in the function.
///
/// @return
/// \return
/// A shared pointer to the function object that might contain
/// a NULL Function pointer.
//------------------------------------------------------------------
@ -327,7 +327,7 @@ public:
/// hands ownership of the line table to this object. The compile unit owns
/// the line table object and will delete the object when it is deleted.
///
/// @param[in] line_table
/// \param[in] line_table
/// A line table object pointer that this object now owns.
//------------------------------------------------------------------
void SetLineTable(LineTable *line_table);
@ -340,7 +340,7 @@ public:
/// Called by the SymbolFile plug-ins after they have parsed the variable
/// lists and are ready to hand ownership of the list over to this object.
///
/// @param[in] variable_list_sp
/// \param[in] variable_list_sp
/// A shared pointer to a VariableList.
//------------------------------------------------------------------
void SetVariableList(lldb::VariableListSP &variable_list_sp);
@ -351,28 +351,28 @@ public:
/// Given a file in \a file_spec, and a line number, find all instances and
/// append them to the supplied symbol context list \a sc_list.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// A file specification. If \a file_spec contains no directory
/// information, only the basename will be used when matching
/// contexts. If the directory in \a file_spec is valid, a
/// complete file specification match will be performed.
///
/// @param[in] line
/// \param[in] line
/// The line number to match against the compile unit's line
/// tables.
///
/// @param[in] check_inlines
/// \param[in] check_inlines
/// If \b true this function will also match any inline
/// file and line matches. If \b false, the compile unit's
/// file specification must match \a file_spec for any matches
/// to be returned.
///
/// @param[in] exact
/// \param[in] exact
/// If true, only resolve the context if \a line exists in the line table.
/// If false, resolve the context to the closest line greater than \a line
/// in the line table.
///
/// @param[in] resolve_scope
/// \param[in] resolve_scope
/// For each matching line entry, this bitfield indicates what
/// values within each SymbolContext that gets added to \a
/// sc_list will be resolved. See the SymbolContext::Scope
@ -380,14 +380,14 @@ public:
/// resolved. Only SymbolContext entries that can be resolved
/// using a LineEntry base address will be able to be resolved.
///
/// @param[out] sc_list
/// \param[out] sc_list
/// A SymbolContext list class that will get any matching
/// entries appended to.
///
/// @return
/// \return
/// The number of new matches that were added to \a sc_list.
///
/// @see enum SymbolContext::Scope
/// \see enum SymbolContext::Scope
//------------------------------------------------------------------
uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
bool check_inlines, bool exact,
@ -402,7 +402,7 @@ public:
/// would expect them, stepping through the source lines in the function may
/// appear strange, etc.
///
/// @return
/// \return
/// Returns 'true' if this compile unit was compiled with
/// optimization. 'false' indicates that either the optimization
/// is unknown, or this compile unit was built without optimization.

8
lldb/include/lldb/Symbol/CompilerDeclContext.h
View File

@ -52,22 +52,22 @@ public:
//----------------------------------------------------------------------
/// Checks if this decl context represents a method of a class.
///
/// @param[out] language_ptr
/// \param[out] language_ptr
/// If non NULL and \b true is returned from this function,
/// this will indicate if the language that respresents the method.
///
/// @param[out] is_instance_method_ptr
/// \param[out] is_instance_method_ptr
/// If non NULL and \b true is returned from this function,
/// this will indicate if the method is an instance function (true)
/// or a class method (false indicating the function is static, or
/// doesn't require an instance of the class to be called).
///
/// @param[out] language_object_name_ptr
/// \param[out] language_object_name_ptr
/// If non NULL and \b true is returned from this function,
/// this will indicate if implicit object name for the language
/// like "this" for C++, and "self" for Objective C.
///
/// @return
/// \return
/// Returns true if this is a decl context that represents a method
/// in a struct, union or class.
//----------------------------------------------------------------------

2
lldb/include/lldb/Symbol/DWARFCallFrameInfo.h
View File

@ -59,7 +59,7 @@ public:
// functions in the Module. But the eh_frame can help to give the addresses
// of these stripped symbols, at least.
//
// @param[out] function_info
// \param[out] function_info
// A vector provided by the caller is filled out. May be empty if no
// FDEs/no eh_frame
// is present in this Module.

10
lldb/include/lldb/Symbol/DeclVendor.h
View File

@ -35,17 +35,17 @@ public:
/// Look up the set of Decls that the DeclVendor currently knows about
/// matching a given name.
///
/// @param[in] name
/// \param[in] name
/// The name to look for.
///
/// @param[in] append
/// \param[in] append
/// If true, FindDecls will clear "decls" when it starts.
///
/// @param[in] max_matches
/// \param[in] max_matches
/// The maximum number of Decls to return. UINT32_MAX means "as
/// many as possible."
///
/// @return
/// \return
/// The number of Decls added to decls; will not exceed
/// max_matches.
//------------------------------------------------------------------
@ -57,7 +57,7 @@ public:
/// Interface for ExternalASTMerger. Returns an ImporterSource
/// allowing type completion.
///
/// @return
/// \return
/// An ImporterSource for this DeclVendor.
//------------------------------------------------------------------
virtual clang::ExternalASTMerger::ImporterSource GetImporterSource() = 0;

40
lldb/include/lldb/Symbol/Declaration.h
View File

@ -15,7 +15,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Declaration Declaration.h "lldb/Symbol/Declaration.h"
/// \class Declaration Declaration.h "lldb/Symbol/Declaration.h"
/// A class that describes the declaration location of a
/// lldb object.
///
@ -40,15 +40,15 @@ public:
//------------------------------------------------------------------
/// Construct with file specification, and optional line and column.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// The file specification that describes where this was
/// declared.
///
/// @param[in] line
/// \param[in] line
/// The line number that describes where this was declared. Set
/// to zero if there is no line number information.
///
/// @param[in] column
/// \param[in] column
/// The column number that describes where this was declared.
/// Set to zero if there is no column number information.
//------------------------------------------------------------------
@ -108,16 +108,16 @@ public:
/// specifications are equal, then continue to compare the line number and
/// column numbers respectively.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const Declaration object reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const Declaration object reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
/// \return
/// \li -1 if lhs < rhs
/// \li 0 if lhs == rhs
/// \li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const Declaration &lhs, const Declaration &rhs);
@ -127,7 +127,7 @@ public:
/// Dump a description of the contents of this object to the supplied stream
/// \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void Dump(Stream *s, bool show_fullpaths) const;
@ -136,7 +136,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the declaration column number.
///
/// @return
/// \return
/// Non-zero indicates a valid column number, zero indicates no
/// column information is available.
//------------------------------------------------------------------
@ -151,7 +151,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for file specification.
///
/// @return
/// \return
/// A reference to the file specification object.
//------------------------------------------------------------------
FileSpec &GetFile() { return m_file; }
@ -159,7 +159,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for file specification.
///
/// @return
/// \return
/// A const reference to the file specification object.
//------------------------------------------------------------------
const FileSpec &GetFile() const { return m_file; }
@ -167,7 +167,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the declaration line number.
///
/// @return
/// \return
/// Non-zero indicates a valid line number, zero indicates no
/// line information is available.
//------------------------------------------------------------------
@ -178,19 +178,19 @@ public:
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
/// The returned value does not include the bytes for any
/// shared string values.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const;
//------------------------------------------------------------------
/// Set accessor for the declaration column number.
///
/// @param[in] column
/// \param[in] column
/// Non-zero indicates a valid column number, zero indicates no
/// column information is available.
//------------------------------------------------------------------
@ -203,7 +203,7 @@ public:
//------------------------------------------------------------------
/// Set accessor for the declaration file specification.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// The new declaration file specification.
//------------------------------------------------------------------
void SetFile(const FileSpec &file_spec) { m_file = file_spec; }
@ -211,7 +211,7 @@ public:
//------------------------------------------------------------------
/// Set accessor for the declaration line number.
///
/// @param[in] line
/// \param[in] line
/// Non-zero indicates a valid line number, zero indicates no
/// line information is available.
//------------------------------------------------------------------

146
lldb/include/lldb/Symbol/Function.h
View File

@ -20,7 +20,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class FunctionInfo Function.h "lldb/Symbol/Function.h"
/// \class FunctionInfo Function.h "lldb/Symbol/Function.h"
/// A class that contains generic function information.
///
/// This provides generic function information that gets reused between inline
@ -32,12 +32,12 @@ public:
/// Construct with the function method name and optional declaration
/// information.
///
/// @param[in] name
/// \param[in] name
/// A C string name for the method name for this function. This
/// value should not be the mangled named, but the simple method
/// name.
///
/// @param[in] decl_ptr
/// \param[in] decl_ptr
/// Optional declaration information that describes where the
/// function was declared. This can be NULL.
//------------------------------------------------------------------
@ -47,11 +47,11 @@ public:
/// Construct with the function method name and optional declaration
/// information.
///
/// @param[in] name
/// \param[in] name
/// A name for the method name for this function. This value
/// should not be the mangled named, but the simple method name.
///
/// @param[in] decl_ptr
/// \param[in] decl_ptr
/// Optional declaration information that describes where the
/// function was declared. This can be NULL.
//------------------------------------------------------------------
@ -70,16 +70,16 @@ public:
/// First compares the method names, and if equal, then compares the
/// declaration information.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const FunctionInfo object reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const FunctionInfo object reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
/// \return
/// \li -1 if lhs < rhs
/// \li 0 if lhs == rhs
/// \li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const FunctionInfo &lhs, const FunctionInfo &rhs);
@ -89,7 +89,7 @@ public:
/// Dump a description of the contents of this object to the supplied stream
/// \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void Dump(Stream *s, bool show_fullpaths) const;
@ -97,7 +97,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the declaration information.
///
/// @return
/// \return
/// A reference to the declaration object.
//------------------------------------------------------------------
Declaration &GetDeclaration();
@ -105,7 +105,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the declaration information.
///
/// @return
/// \return
/// A const reference to the declaration object.
//------------------------------------------------------------------
const Declaration &GetDeclaration() const;
@ -113,7 +113,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the method name.
///
/// @return
/// \return
/// A const reference to the method name object.
//------------------------------------------------------------------
ConstString GetName() const;
@ -121,12 +121,12 @@ public:
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
/// The returned value does not include the bytes for any
/// shared string values.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
virtual size_t MemorySize() const;
@ -140,7 +140,7 @@ protected:
};
//----------------------------------------------------------------------
/// @class InlineFunctionInfo Function.h "lldb/Symbol/Function.h"
/// \class InlineFunctionInfo Function.h "lldb/Symbol/Function.h"
/// A class that describes information for an inlined function.
//----------------------------------------------------------------------
class InlineFunctionInfo : public FunctionInfo {
@ -149,20 +149,20 @@ public:
/// Construct with the function method name, mangled name, and optional
/// declaration information.
///
/// @param[in] name
/// \param[in] name
/// A C string name for the method name for this function. This
/// value should not be the mangled named, but the simple method
/// name.
///
/// @param[in] mangled
/// \param[in] mangled
/// A C string name for the mangled name for this function. This
/// value can be NULL if there is no mangled information.
///
/// @param[in] decl_ptr
/// \param[in] decl_ptr
/// Optional declaration information that describes where the
/// function was declared. This can be NULL.
///
/// @param[in] call_decl_ptr
/// \param[in] call_decl_ptr
/// Optional calling location declaration information that
/// describes from where this inlined function was called.
//------------------------------------------------------------------
@ -174,19 +174,19 @@ public:
/// Construct with the function method name, mangled name, and optional
/// declaration information.
///
/// @param[in] name
/// \param[in] name
/// A name for the method name for this function. This value
/// should not be the mangled named, but the simple method name.
///
/// @param[in] mangled
/// \param[in] mangled
/// A name for the mangled name for this function. This value
/// can be empty if there is no mangled information.
///
/// @param[in] decl_ptr
/// \param[in] decl_ptr
/// Optional declaration information that describes where the
/// function was declared. This can be NULL.
///
/// @param[in] call_decl_ptr
/// \param[in] call_decl_ptr
/// Optional calling location declaration information that
/// describes from where this inlined function was called.
//------------------------------------------------------------------
@ -205,18 +205,18 @@ public:
/// First compares the FunctionInfo objects, and if equal, compares the
/// mangled names.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const InlineFunctionInfo object
/// reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const InlineFunctionInfo object
/// reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
/// \return
/// \li -1 if lhs < rhs
/// \li 0 if lhs == rhs
/// \li 1 if lhs > rhs
//------------------------------------------------------------------
int Compare(const InlineFunctionInfo &lhs, const InlineFunctionInfo &rhs);
@ -226,7 +226,7 @@ public:
/// Dump a description of the contents of this object to the supplied stream
/// \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
void Dump(Stream *s, bool show_fullpaths) const;
@ -240,7 +240,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the call site declaration information.
///
/// @return
/// \return
/// A reference to the declaration object.
//------------------------------------------------------------------
Declaration &GetCallSite();
@ -248,7 +248,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the call site declaration information.
///
/// @return
/// \return
/// A const reference to the declaration object.
//------------------------------------------------------------------
const Declaration &GetCallSite() const;
@ -256,7 +256,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the mangled name object.
///
/// @return
/// \return
/// A reference to the mangled name object.
//------------------------------------------------------------------
Mangled &GetMangled();
@ -264,7 +264,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the mangled name object.
///
/// @return
/// \return
/// A const reference to the mangled name object.
//------------------------------------------------------------------
const Mangled &GetMangled() const;
@ -272,12 +272,12 @@ public:
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
/// The returned value does not include the bytes for any
/// shared string values.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const override;
@ -293,7 +293,7 @@ private:
class Function;
//----------------------------------------------------------------------
/// @class CallEdge Function.h "lldb/Symbol/Function.h"
/// \class CallEdge Function.h "lldb/Symbol/Function.h"
///
/// Represent a call made within a Function. This can be used to find a path
/// in the call graph between two functions.
@ -349,7 +349,7 @@ private:
};
//----------------------------------------------------------------------
/// @class Function Function.h "lldb/Symbol/Function.h"
/// \class Function Function.h "lldb/Symbol/Function.h"
/// A class that describes a function.
///
/// Functions belong to CompileUnit objects (Function::m_comp_unit), have
@ -361,8 +361,8 @@ private:
/// (Function::m_type), and contains lexical blocks (Function::m_blocks).
///
/// The function information is split into a few pieces:
/// @li The concrete instance information
/// @li The abstract information
/// \li The concrete instance information
/// \li The abstract information
///
/// The abstract information is found in the function type (Type) that
/// describes a function information, return type and parameter types.
@ -376,30 +376,30 @@ public:
/// Construct with a compile unit, function UID, function type UID, optional
/// mangled name, function type, and a section offset based address range.
///
/// @param[in] comp_unit
/// \param[in] comp_unit
/// The compile unit to which this function belongs.
///
/// @param[in] func_uid
/// \param[in] func_uid
/// The UID for this function. This value is provided by the
/// SymbolFile plug-in and can be any value that allows
/// the plug-in to quickly find and parse more detailed
/// information when and if more information is needed.
///
/// @param[in] func_type_uid
/// \param[in] func_type_uid
/// The type UID for the function Type to allow for lazy type
/// parsing from the debug information.
///
/// @param[in] mangled
/// \param[in] mangled
/// The optional mangled name for this function. If empty, there
/// is no mangled information.
///
/// @param[in] func_type
/// \param[in] func_type
/// The optional function type. If NULL, the function type will
/// be parsed on demand when accessed using the
/// Function::GetType() function by asking the SymbolFile
/// plug-in to get the type for \a func_type_uid.
///
/// @param[in] range
/// \param[in] range
/// The section offset based address for this function.
//------------------------------------------------------------------
Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
@ -412,9 +412,9 @@ public:
~Function() override;
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
/// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void CalculateSymbolContext(SymbolContext *sc) override;
@ -433,10 +433,10 @@ public:
/// line table if that fails. So there may NOT be a line table entry for
/// this source file/line combo.
///
/// @param[out] source_file
/// \param[out] source_file
/// The source file.
///
/// @param[out] line_no
/// \param[out] line_no
/// The line number.
//------------------------------------------------------------------
void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no);
@ -446,10 +446,10 @@ public:
/// function.
///
///
/// @param[out] source_file
/// \param[out] source_file
/// The source file.
///
/// @param[out] line_no
/// \param[out] line_no
/// The line number.
//------------------------------------------------------------------
void GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no);
@ -469,18 +469,18 @@ public:
//------------------------------------------------------------------
/// Get accessor for the block list.
///
/// @return
/// \return
/// The block list object that describes all lexical blocks
/// in the function.
///
/// @see BlockList
/// \see BlockList
//------------------------------------------------------------------
Block &GetBlock(bool can_create);
//------------------------------------------------------------------
/// Get accessor for the compile unit that owns this function.
///
/// @return
/// \return
/// A compile unit object pointer.
//------------------------------------------------------------------
CompileUnit *GetCompileUnit();
@ -488,7 +488,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the compile unit that owns this function.
///
/// @return
/// \return
/// A const compile unit object pointer.
//------------------------------------------------------------------
const CompileUnit *GetCompileUnit() const;
@ -498,7 +498,7 @@ public:
//------------------------------------------------------------------
/// Get accessor for the frame base location.
///
/// @return
/// \return
/// A location expression that describes the function frame
/// base.
//------------------------------------------------------------------
@ -507,7 +507,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor for the frame base location.
///
/// @return
/// \return
/// A const compile unit object pointer.
//------------------------------------------------------------------
const DWARFExpression &GetFrameBaseExpression() const { return m_frame_base; }
@ -523,7 +523,7 @@ public:
//------------------------------------------------------------------
/// Get the DeclContext for this function, if available.
///
/// @return
/// \return
/// The DeclContext, or NULL if none exists.
//------------------------------------------------------------------
CompilerDeclContext GetDeclContext();
@ -532,7 +532,7 @@ public:
/// Get accessor for the type that describes the function return value type,
/// and parameter types.
///
/// @return
/// \return
/// A type object pointer.
//------------------------------------------------------------------
Type *GetType();
@ -541,7 +541,7 @@ public:
/// Get const accessor for the type that describes the function return value
/// type, and parameter types.
///
/// @return
/// \return
/// A const type object pointer.
//------------------------------------------------------------------
const Type *GetType() const;
@ -553,7 +553,7 @@ public:
/// "prologue" instructions include any instructions given line number 0
/// immediately following the prologue end.
///
/// @return
/// \return
/// The size of the prologue.
//------------------------------------------------------------------
uint32_t GetPrologueByteSize();
@ -564,31 +564,31 @@ public:
/// Dump a description of the contents of this object to the supplied stream
/// \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] show_context
/// \param[in] show_context
/// If \b true, variables will dump their symbol context
/// information.
//------------------------------------------------------------------
void Dump(Stream *s, bool show_context) const;
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
/// \copydoc SymbolContextScope::DumpSymbolContext(Stream*)
///
/// @see SymbolContextScope
/// \see SymbolContextScope
//------------------------------------------------------------------
void DumpSymbolContext(Stream *s) override;
//------------------------------------------------------------------
/// Get the memory cost of this object.
///
/// @return
/// \return
/// The number of bytes that this object occupies in memory.
/// The returned value does not include the bytes for any
/// shared string values.
///
/// @see ConstString::StaticMemorySize ()
/// \see ConstString::StaticMemorySize ()
//------------------------------------------------------------------
size_t MemorySize() const;
@ -602,7 +602,7 @@ public:
/// would expect them, stepping through the source lines in the function may
/// appear strange, etc.
///
/// @return
/// \return
/// Returns 'true' if this function was compiled with
/// optimization. 'false' indicates that either the optimization
/// is unknown, or this function was built without optimization.
@ -620,7 +620,7 @@ public:
/// If stopped in a top-level function, LLDB will expose global variables
/// as-if locals in the 'frame variable' command
///
/// @return
/// \return
/// Returns 'true' if this function is a top-level function,
/// 'false' otherwise.
//------------------------------------------------------------------

44
lldb/include/lldb/Symbol/LineEntry.h
View File

@ -16,7 +16,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h"
/// \class LineEntry LineEntry.h "lldb/Symbol/LineEntry.h"
/// A line table entry class.
//----------------------------------------------------------------------
struct LineEntry {
@ -46,30 +46,30 @@ struct LineEntry {
/// Dump a description of the contents of this object to the supplied stream
/// \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// \param[in] comp_unit
/// The compile unit object that contains the support file
/// list so the line entry can dump the file name (since this
/// object contains a file index into the support file list).
///
/// @param[in] show_file
/// \param[in] show_file
/// If \b true, display the filename with the line entry which
/// requires that the compile unit object \a comp_unit be a
/// valid pointer.
///
/// @param[in] style
/// \param[in] style
/// The display style for the section offset address.
///
/// @return
/// \return
/// Returns \b true if the address was able to be displayed
/// using \a style. File and load addresses may be unresolved
/// and it may not be possible to display a valid address value.
/// Returns \b false if the address was not able to be properly
/// dumped.
///
/// @see Address::DumpStyle
/// \see Address::DumpStyle
//------------------------------------------------------------------
bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style,
Address::DumpStyle fallback_style, bool show_range) const;
@ -81,15 +81,15 @@ struct LineEntry {
/// Dumps information specific to a process that stops at this line entry to
/// the supplied stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// \param[in] comp_unit
/// The compile unit object that contains the support file
/// list so the line entry can dump the file name (since this
/// object contains a file index into the support file list).
///
/// @return
/// \return
/// Returns \b true if the file and line were properly dumped,
/// \b false otherwise.
//------------------------------------------------------------------
@ -98,7 +98,7 @@ struct LineEntry {
//------------------------------------------------------------------
/// Check if a line entry object is valid.
///
/// @return
/// \return
/// Returns \b true if the line entry contains a valid section
/// offset address, file index, and line number, \b false
/// otherwise.
@ -108,16 +108,16 @@ struct LineEntry {
//------------------------------------------------------------------
/// Compare two LineEntry objects.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const LineEntry object reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const LineEntry object reference.
///
/// @return
/// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs
/// \return
/// \li -1 if lhs < rhs
/// \li 0 if lhs == rhs
/// \li 1 if lhs > rhs
//------------------------------------------------------------------
static int Compare(const LineEntry &lhs, const LineEntry &rhs);
@ -142,7 +142,7 @@ struct LineEntry {
/// range of contiuous LineEntries with line #0 will be included in the
/// complete range.
///
/// @return
/// \return
/// The contiguous AddressRange for this source line.
//------------------------------------------------------------------
AddressRange GetSameLineContiguousAddressRange() const;
@ -150,7 +150,7 @@ struct LineEntry {
//------------------------------------------------------------------
/// Apply file mappings from target.source-map to the LineEntry's file.
///
/// @param[in] target_sp
/// \param[in] target_sp
/// Shared pointer to the target this LineEntry belongs to.
//------------------------------------------------------------------
@ -185,13 +185,13 @@ struct LineEntry {
//------------------------------------------------------------------
/// Less than operator.
///
/// @param[in] lhs
/// \param[in] lhs
/// The Left Hand Side const LineEntry object reference.
///
/// @param[in] rhs
/// \param[in] rhs
/// The Right Hand Side const LineEntry object reference.
///
/// @return
/// \return
/// Returns \b true if lhs < rhs, false otherwise.
//------------------------------------------------------------------
bool operator<(const LineEntry &lhs, const LineEntry &rhs);

60
lldb/include/lldb/Symbol/LineTable.h
View File

@ -19,7 +19,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base
/// \class LineSequence LineTable.h "lldb/Symbol/LineTable.h" An abstract base
/// class used during symbol table creation.
//----------------------------------------------------------------------
class LineSequence {
@ -35,7 +35,7 @@ private:
};
//----------------------------------------------------------------------
/// @class LineTable LineTable.h "lldb/Symbol/LineTable.h"
/// \class LineTable LineTable.h "lldb/Symbol/LineTable.h"
/// A line table class.
//----------------------------------------------------------------------
class LineTable {
@ -43,7 +43,7 @@ public:
//------------------------------------------------------------------
/// Construct with compile unit.
///
/// @param[in] comp_unit
/// \param[in] comp_unit
/// The compile unit to which this line table belongs.
//------------------------------------------------------------------
LineTable(CompileUnit *comp_unit);
@ -58,11 +58,11 @@ public:
///
/// All line entries are maintained in file address order.
///
/// @param[in] line_entry
/// \param[in] line_entry
/// A const reference to a new line_entry to add to this line
/// table.
///
/// @see Address::DumpStyle
/// \see Address::DumpStyle
//------------------------------------------------------------------
// void
// AddLineEntry (const LineEntry& line_entry);
@ -91,13 +91,13 @@ public:
//------------------------------------------------------------------
/// Dump all line entries in this line table to the stream \a s.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
///
/// @param[in] style
/// \param[in] style
/// The display style for the address.
///
/// @see Address::DumpStyle
/// \see Address::DumpStyle
//------------------------------------------------------------------
void Dump(Stream *s, Target *target, Address::DumpStyle style,
Address::DumpStyle fallback_style, bool show_line_ranges);
@ -107,19 +107,19 @@ public:
//------------------------------------------------------------------
/// Find a line entry that contains the section offset address \a so_addr.
///
/// @param[in] so_addr
/// \param[in] so_addr
/// A section offset address object containing the address we
/// are searching for.
///
/// @param[out] line_entry
/// \param[out] line_entry
/// A copy of the line entry that was found if \b true is
/// returned, otherwise \a entry is left unmodified.
///
/// @param[out] index_ptr
/// \param[out] index_ptr
/// A pointer to a 32 bit integer that will get the actual line
/// entry index if it is not nullptr.
///
/// @return
/// \return
/// Returns \b true if \a so_addr is contained in a line entry
/// in this line table, \b false otherwise.
//------------------------------------------------------------------
@ -134,33 +134,33 @@ public:
/// line number \a line starting at the \a start_idx entries into the line
/// entry collection.
///
/// @param[in] start_idx
/// \param[in] start_idx
/// The number of entries to skip when starting the search.
///
/// @param[out] file_idx
/// \param[out] file_idx
/// The file index to search for that should be found prior
/// to calling this function using the following functions:
/// CompileUnit::GetSupportFiles()
/// FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
///
/// @param[in] line
/// \param[in] line
/// The source line to match.
///
/// @param[in] exact
/// \param[in] exact
/// If true, match only if you find a line entry exactly matching \a line.
/// If false, return the closest line entry greater than \a line.
///
/// @param[out] line_entry
/// \param[out] line_entry
/// A reference to a line entry object that will get a copy of
/// the line entry if \b true is returned, otherwise \a
/// line_entry is left untouched.
///
/// @return
/// \return
/// Returns \b true if a matching line entry is found in this
/// line table, \b false otherwise.
///
/// @see CompileUnit::GetSupportFiles()
/// @see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
/// \see CompileUnit::GetSupportFiles()
/// \see FileSpecList::FindFileIndex (uint32_t, const FileSpec &) const
//------------------------------------------------------------------
uint32_t FindLineEntryIndexByFileIndex(uint32_t start_idx, uint32_t file_idx,
uint32_t line, bool exact,
@ -176,22 +176,22 @@ public:
//------------------------------------------------------------------
/// Get the line entry from the line table at index \a idx.
///
/// @param[in] idx
/// \param[in] idx
/// An index into the line table entry collection.
///
/// @return
/// \return
/// A valid line entry if \a idx is a valid index, or an invalid
/// line entry if \a idx is not valid.
///
/// @see LineTable::GetSize()
/// @see LineEntry::IsValid() const
/// \see LineTable::GetSize()
/// \see LineEntry::IsValid() const
//------------------------------------------------------------------
bool GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry);
//------------------------------------------------------------------
/// Gets the size of the line table in number of line table entries.
///
/// @return
/// \return
/// The number of line table entries in this line table.
//------------------------------------------------------------------
uint32_t GetSize() const;
@ -202,15 +202,15 @@ public:
//------------------------------------------------------------------
/// Gets all contiguous file address ranges for the entire line table.
///
/// @param[out] file_ranges
/// \param[out] file_ranges
/// A collection of file address ranges that will be filled in
/// by this function.
///
/// @param[out] append
/// \param[out] append
/// If \b true, then append to \a file_ranges, otherwise clear
/// \a file_ranges prior to adding any ranges.
///
/// @return
/// \return
/// The number of address ranges added to \a file_ranges
//------------------------------------------------------------------
size_t GetContiguousFileAddressRanges(FileAddressRanges &file_ranges,
@ -220,11 +220,11 @@ public:
/// Given a file range link map, relink the current line table and return a
/// fixed up line table.
///
/// @param[out] file_range_map
/// \param[out] file_range_map
/// A collection of file ranges that maps to new file ranges
/// that will be used when linking the line table.
///
/// @return
/// \return
/// A new line table if at least one line table entry was able
/// to be mapped.
//------------------------------------------------------------------

22
lldb/include/lldb/Symbol/ObjectContainer.h
View File

@ -19,7 +19,7 @@
namespace lldb_private {
//----------------------------------------------------------------------
/// @class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h"
/// \class ObjectContainer ObjectContainer.h "lldb/Symbol/ObjectContainer.h"
/// A plug-in interface definition class for object containers.
///
/// Object containers contain object files from one or more architectures, and
@ -65,7 +65,7 @@ public:
/// supplied stream \a s. The dumping should include the section list if it
/// has been parsed, and the symbol table if it has been parsed.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void Dump(Stream *s) const = 0;
@ -75,18 +75,18 @@ public:
///
/// Copies the architecture specification for index \a idx.
///
/// @param[in] idx
/// \param[in] idx
/// The architecture index to extract.
///
/// @param[out] arch
/// \param[out] arch
/// A architecture object that will be filled in if \a idx is a
/// architecture valid index.
///
/// @return
/// \return
/// Returns \b true if \a idx is valid and \a arch has been
/// filled in, \b false otherwise.
///
/// @see ObjectContainer::GetNumArchitectures() const
/// \see ObjectContainer::GetNumArchitectures() const
//------------------------------------------------------------------
virtual bool GetArchitectureAtIndex(uint32_t idx, ArchSpec &arch) const {
return false;
@ -98,7 +98,7 @@ public:
/// Some files contain many object files, and this function allows access to
/// an object's offset within the file.
///
/// @return
/// \return
/// The offset in bytes into the file. Defaults to zero for
/// simple object files that a represented by an entire file.
//------------------------------------------------------------------
@ -109,7 +109,7 @@ public:
//------------------------------------------------------------------
/// Get the number of objects within this object file (archives).
///
/// @return
/// \return
/// Zero for object files that are not archives, or the number
/// of objects contained in the archive.
//------------------------------------------------------------------
@ -123,7 +123,7 @@ public:
/// one architecture should override this function and return an appropriate
/// value.
///
/// @return
/// \return
/// The number of architectures contained in this object file.
//------------------------------------------------------------------
virtual size_t GetNumArchitectures() const { return 0; }
@ -137,7 +137,7 @@ public:
/// false should be returned and the next plug-in can attempt to parse an
/// object file.
///
/// @return
/// \return
/// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
@ -155,7 +155,7 @@ public:
/// state from any previously selected architecture and prepare to return
/// information for the new architecture.
///
/// @return
/// \return
/// Returns a pointer to the object file of the requested \a
/// arch and optional \a name. Returns nullptr of no such object
/// file exists in the container.

102
lldb/include/lldb/Symbol/ObjectFile.h
View File

@ -43,7 +43,7 @@ public:
};
//----------------------------------------------------------------------
/// @class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h"
/// \class ObjectFile ObjectFile.h "lldb/Symbol/ObjectFile.h"
/// A plug-in interface definition class for object file parsers.
///
/// Object files belong to Module objects and know how to extract information
@ -121,7 +121,7 @@ public:
/// supplied stream \a s. The dumping should include the section list if it
/// has been parsed, and the symbol table if it has been parsed.
///
/// @param[in] s
/// \param[in] s
/// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void Dump(Stream *s) = 0;
@ -133,23 +133,23 @@ public:
/// ObjectFile plug-in interface and returns the first instance that can
/// parse the file.
///
/// @param[in] module
/// \param[in] module
/// The parent module that owns this object file.
///
/// @param[in] file_spec
/// \param[in] file_spec
/// A file specification that indicates which file to use as the
/// object file.
///
/// @param[in] file_offset
/// \param[in] file_offset
/// The offset into the file at which to start parsing the
/// object. This is for files that contain multiple
/// architectures or objects.
///
/// @param[in] file_size
/// \param[in] file_size
/// The size of the current object file if it can be determined
/// or if it is known. This can be zero.
///
/// @see ObjectFile::ParseHeader()
/// \see ObjectFile::ParseHeader()
//------------------------------------------------------------------
static lldb::ObjectFileSP
FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file_spec,
@ -163,14 +163,14 @@ public:
/// ObjectFile plug-in interface and returns the first instance that can
/// parse the file.
///
/// @param[in] module
/// \param[in] module
/// The parent module that owns this object file.
///
/// @param[in] process_sp
/// \param[in] process_sp
/// A shared pointer to the process whose memory space contains
/// an object file. This will be stored as a std::weak_ptr.
///
/// @param[in] header_addr
/// \param[in] header_addr
/// The address of the header for the object file in memory.
//------------------------------------------------------------------
static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp,
@ -196,19 +196,19 @@ public:
/// the actual path name and into the object name so we can make a valid
/// object file from it.
///
/// @param[in] path_with_object
/// \param[in] path_with_object
/// A path that might contain an archive path with a .o file
/// specified in parens in the basename of the path.
///
/// @param[out] archive_file
/// \param[out] archive_file
/// If \b true is returned, \a file_spec will be filled in with
/// the path to the archive.
///
/// @param[out] archive_object
/// \param[out] archive_object
/// If \b true is returned, \a object will be filled in with
/// the name of the object inside the archive.
///
/// @return
/// \return
/// \b true if the path matches the pattern of archive + object
/// and \a archive_file and \a archive_object are modified,
/// \b false otherwise and \a archive_file and \a archive_object
@ -221,7 +221,7 @@ public:
//------------------------------------------------------------------
/// Gets the address size in bytes for the current object file.
///
/// @return
/// \return
/// The size of an address in bytes for the currently selected
/// architecture (and object for archives). Returns zero if no
/// architecture or object has been selected.
@ -235,7 +235,7 @@ public:
/// binaries, though it can be applied to any executable file format that
/// supports different opcode types within the same binary. ARM binaries
/// support having both ARM and Thumb within the same executable container.
/// We need to be able to get @return
/// We need to be able to get \return
/// The size of an address in bytes for the currently selected
/// architecture (and object for archives). Returns zero if no
/// architecture or object has been selected.
@ -251,14 +251,14 @@ public:
/// FileSpecList::AppendIfUnique(const FileSpec &) should be used to make
/// sure any files that are added are not already in the list.
///
/// @param[out] file_list
/// \param[out] file_list
/// A list of file specification objects that gets dependent
/// files appended to.
///
/// @return
/// \return
/// The number of new files that were appended to \a file_list.
///
/// @see FileSpecList::AppendIfUnique(const FileSpec &)
/// \see FileSpecList::AppendIfUnique(const FileSpec &)
//------------------------------------------------------------------
virtual uint32_t GetDependentModules(FileSpecList &file_list) = 0;
@ -266,7 +266,7 @@ public:
/// Tells whether this object file is capable of being the main executable
/// for a process.
///
/// @return
/// \return
/// \b true if it is, \b false otherwise.
//------------------------------------------------------------------
virtual bool IsExecutable() const = 0;
@ -277,7 +277,7 @@ public:
/// Some files contain many object files, and this function allows access to
/// an object's offset within the file.
///
/// @return
/// \return
/// The offset in bytes into the file. Defaults to zero for
/// simple object files that a represented by an entire file.
//------------------------------------------------------------------
@ -288,7 +288,7 @@ public:
//------------------------------------------------------------------
/// Get accessor to the object file specification.
///
/// @return
/// \return
/// The file specification object pointer if there is one, or
/// NULL if this object is only from memory.
//------------------------------------------------------------------
@ -297,7 +297,7 @@ public:
//------------------------------------------------------------------
/// Get const accessor to the object file specification.
///
/// @return
/// \return
/// The const file specification object pointer if there is one,
/// or NULL if this object is only from memory.
//------------------------------------------------------------------
@ -306,7 +306,7 @@ public:
//------------------------------------------------------------------
/// Get the ArchSpec for this object file.
///
/// @return
/// \return
/// The ArchSpec of this object file. In case of error, an invalid
/// ArchSpec object is returned.
//------------------------------------------------------------------
@ -319,7 +319,7 @@ public:
/// Section list parsing can be deferred by ObjectFile instances until this
/// accessor is called the first time.
///
/// @return
/// \return
/// The list of sections contained in this object file.
//------------------------------------------------------------------
virtual SectionList *GetSectionList(bool update_module_section_list = true);
@ -339,7 +339,7 @@ public:
/// Symbol table parsing can be deferred by ObjectFile instances until this
/// accessor is called the first time.
///
/// @return
/// \return
/// The symbol table for this object file.
//------------------------------------------------------------------
virtual Symtab *GetSymtab() = 0;
@ -359,7 +359,7 @@ public:
/// the first match in the SymbolTable and appends a Symbol only if
/// required/found.
///
/// @return
/// \return
/// The resolved symbol or nullptr. Returns nullptr if a
/// a Symbol could not be found for the specified so_addr.
//------------------------------------------------------------------
@ -380,7 +380,7 @@ public:
//------------------------------------------------------------------
/// Detect if this object file has been stripped of local symbols.
///
/// @return
/// \return
/// Return \b true if the object file has been stripped of local
/// symbols.
//------------------------------------------------------------------
@ -391,11 +391,11 @@ public:
///
/// This function should only be used when an object file is
///
/// @param[in] flags
/// \param[in] flags
/// eSymtabFromUnifiedSectionList: Whether to clear symbol table
/// for unified module section list, or object file.
///
/// @return
/// \return
/// The symbol table for this object file.
//------------------------------------------------------------------
virtual void ClearSymtab();
@ -407,7 +407,7 @@ public:
/// Else ObjectFile instances should return the MD5 checksum of all of the
/// bytes for the object file (or memory for memory based object files).
///
/// @return
/// \return
/// The object file's UUID. In case of an error, an empty UUID is
/// returned.
//------------------------------------------------------------------
@ -419,7 +419,7 @@ public:
/// If the object file format contains a debug symbol file link, the values
/// will be returned in the FileSpecList.
///
/// @return
/// \return
/// Returns filespeclist.
//------------------------------------------------------------------
virtual lldb_private::FileSpecList GetDebugSymbolFilePaths() {
@ -433,7 +433,7 @@ public:
/// symbols from another, the re-exported libraries will be returned in the
/// FileSpecList.
///
/// @return
/// \return
/// Returns filespeclist.
//------------------------------------------------------------------
virtual lldb_private::FileSpecList GetReExportedLibraries() {
@ -444,7 +444,7 @@ public:
/// Sets the load address for an entire module, assuming a rigid slide of
/// sections, if possible in the implementation.
///
/// @return
/// \return
/// Returns true iff any section's load address changed.
//------------------------------------------------------------------
virtual bool SetLoadAddress(Target &target, lldb::addr_t value,
@ -456,7 +456,7 @@ public:
/// Gets whether endian swapping should occur when extracting data from this
/// object file.
///
/// @return
/// \return
/// Returns \b true if endian swapping is needed, \b false
/// otherwise.
//------------------------------------------------------------------
@ -471,7 +471,7 @@ public:
/// false should be returned and the next plug-in can attempt to parse an
/// object file.
///
/// @return
/// \return
/// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
@ -494,7 +494,7 @@ public:
/// that symbol start addresses are unavailable before false is returned.
/// If it is unclear, this should return true.
///
/// @return
/// \return
/// Returns true if assembly emulation should be used for this
/// module.
/// Only returns false if the ObjectFile is sure that symbol
@ -512,7 +512,7 @@ public:
/// runtime linker so that a debugger may monitor the loading and unloading
/// of shared libraries.
///
/// @return
/// \return
/// The address of any auxiliary tables, or an invalid address if this
/// object file format does not support or contain such information.
virtual lldb_private::Address GetImageInfoAddress(Target *target) {
@ -524,7 +524,7 @@ public:
/// object file doesn't have an entry point (because it is not an executable
/// file) then an invalid address is returned.
///
/// @return
/// \return
/// Returns the entry address for this module.
//------------------------------------------------------------------
virtual lldb_private::Address GetEntryPointAddress() { return Address(); }
@ -550,7 +550,7 @@ public:
/// in a Mach-O core file using the LC_IDENT load command (which is
/// obsolete, but can still be found in some old files)
///
/// @return
/// \return
/// Returns the identifier string if one exists, else an empty
/// string.
//------------------------------------------------------------------
@ -565,17 +565,17 @@ public:
/// binary is exactly which removes ambiguity when there are multiple
/// binaries present in the captured memory pages.
///
/// @param[out] address
/// \param[out] address
/// If the address of the binary is specified, this will be set.
/// This is an address is the virtual address space of the core file
/// memory segments; it is not an offset into the object file.
/// If no address is available, will be set to LLDB_INVALID_ADDRESS.
///
/// @param[out] uuid
/// \param[out] uuid
/// If the uuid of the binary is specified, this will be set.
/// If no UUID is available, will be cleared.
///
/// @return
/// \return
/// Returns true if either address or uuid has been set.
//------------------------------------------------------------------
virtual bool GetCorefileMainBinaryInfo (lldb::addr_t &address, UUID &uuid) {
@ -597,7 +597,7 @@ public:
/// eTypeXXX definitions do not match up with the type of file you are
/// loading, please feel free to add a new enumeration value.
///
/// @return
/// \return
/// The calculated file type for the current object file.
//------------------------------------------------------------------
virtual Type CalculateType() = 0;
@ -617,7 +617,7 @@ public:
/// out, it will help with debugger plug-in selection when it comes time to
/// debug.
///
/// @return
/// \return
/// The calculated object file strata for the current object
/// file.
//------------------------------------------------------------------
@ -631,7 +631,7 @@ public:
/// minor and build, but there may be more. This function will extract the
/// versions from object files if they are available.
///
/// @return
/// \return
/// This function returns extracted version numbers as a
/// llvm::VersionTuple. In case of error an empty VersionTuple is
/// returned.
@ -644,7 +644,7 @@ public:
/// Some object files have information that specifies the minimum OS version
/// that they can be used on.
///
/// @return
/// \return
/// This function returns extracted version numbers as a
/// llvm::VersionTuple. In case of error an empty VersionTuple is
/// returned.
@ -739,10 +739,10 @@ public:
/// useful with bare-metal targets where target does not have the ability to
/// start a process itself.
///
/// @param[in] target
/// \param[in] target
/// Target where to load.
///
/// @return
/// \return
//------------------------------------------------------------------
virtual std::vector<LoadableData> GetLoadableData(Target &target);
@ -771,10 +771,10 @@ protected:
/// only be set if it is invalid. It is not allowed to switch from one
/// concrete architecture to another.
///
/// @param[in] new_arch
/// \param[in] new_arch
/// The architecture this module will be set to.
///
/// @return
/// \return
/// Returns \b true if the architecture was changed, \b
/// false otherwise.
//------------------------------------------------------------------

Some files were not shown because too many files have changed in this diff Show More