aboutsummaryrefslogtreecommitdiffstats
path: root/include/lldb/Target/DynamicLoader.h
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2019-08-20 20:51:52 +0000
committerDimitry Andric <dim@FreeBSD.org>2019-08-20 20:51:52 +0000
commit5f29bb8a675e8f96452b632e7129113f7dec850e (patch)
tree3d3f2a0d3ad10872a4dcaba8ec8d1d20c87ab147 /include/lldb/Target/DynamicLoader.h
parent88c643b6fec27eec436c8d138fee6346e92337d6 (diff)
downloadsrc-5f29bb8a675e8f96452b632e7129113f7dec850e.tar.gz
src-5f29bb8a675e8f96452b632e7129113f7dec850e.zip
Vendor import of stripped lldb trunk r366426 (just before the release_90
Notes
Notes: svn path=/vendor/lldb/dist/; revision=351290
Diffstat (limited to 'include/lldb/Target/DynamicLoader.h')
-rw-r--r--include/lldb/Target/DynamicLoader.h113
1 files changed, 33 insertions, 80 deletions
diff --git a/include/lldb/Target/DynamicLoader.h b/include/lldb/Target/DynamicLoader.h
index fe04f94aa31b..2bf3f32b5eef 100644
--- a/include/lldb/Target/DynamicLoader.h
+++ b/include/lldb/Target/DynamicLoader.h
@@ -1,9 +1,8 @@
//===-- DynamicLoader.h -----------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
@@ -23,30 +22,17 @@
#include <stdint.h>
namespace lldb_private {
class ModuleList;
-}
-namespace lldb_private {
class Process;
-}
-namespace lldb_private {
class SectionList;
-}
-namespace lldb_private {
class Symbol;
-}
-namespace lldb_private {
class SymbolContext;
-}
-namespace lldb_private {
class SymbolContextList;
-}
-namespace lldb_private {
class Thread;
}
namespace lldb_private {
-//----------------------------------------------------------------------
-/// @class DynamicLoader DynamicLoader.h "lldb/Target/DynamicLoader.h"
+/// \class DynamicLoader DynamicLoader.h "lldb/Target/DynamicLoader.h"
/// A plug-in interface definition class for dynamic loaders.
///
/// Dynamic loader plug-ins track image (shared library) loading and
@@ -63,64 +49,50 @@ namespace lldb_private {
/// boolean value that indicates if the process should continue or halt and
/// should return the global setting for this using:
/// DynamicLoader::StopWhenImagesChange() const.
-//----------------------------------------------------------------------
class DynamicLoader : public PluginInterface {
public:
- //------------------------------------------------------------------
/// Find a dynamic loader plugin for a given process.
///
/// Scans the installed DynamicLoader plug-ins and tries to find an instance
/// that can be used to track image changes in \a process.
///
- /// @param[in] process
+ /// \param[in] process
/// The process for which to try and locate a dynamic loader
/// plug-in instance.
///
- /// @param[in] plugin_name
+ /// \param[in] plugin_name
/// An optional name of a specific dynamic loader plug-in that
/// should be used. If NULL, pick the best plug-in.
- //------------------------------------------------------------------
static DynamicLoader *FindPlugin(Process *process, const char *plugin_name);
- //------------------------------------------------------------------
/// Construct with a process.
- //------------------------------------------------------------------
DynamicLoader(Process *process);
- //------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class is designed to be inherited
/// from by the plug-in instance.
- //------------------------------------------------------------------
- virtual ~DynamicLoader() override;
+ ~DynamicLoader() override;
- //------------------------------------------------------------------
/// Called after attaching a process.
///
/// Allow DynamicLoader plug-ins to execute some code after attaching to a
/// process.
- //------------------------------------------------------------------
virtual void DidAttach() = 0;
- //------------------------------------------------------------------
/// Called after launching a process.
///
/// Allow DynamicLoader plug-ins to execute some code after the process has
/// stopped for the first time on launch.
- //------------------------------------------------------------------
virtual void DidLaunch() = 0;
- //------------------------------------------------------------------
/// Helper function that can be used to detect when a process has called
/// exec and is now a new and different process. This can be called when
/// necessary to try and detect the exec. The process might be able to
/// answer this question, but sometimes it might not be able and the dynamic
/// loader often knows what the program entry point is. So the process and
/// the dynamic loader can work together to detect this.
- //------------------------------------------------------------------
virtual bool ProcessDidExec() { return false; }
- //------------------------------------------------------------------
/// Get whether the process should stop when images change.
///
/// When images (executables and shared libraries) get loaded or unloaded,
@@ -129,13 +101,11 @@ public:
/// DynamicLoader plug-in instances should return this value to ensure
/// consistent debug session behaviour.
///
- /// @return
+ /// \return
/// Returns \b true if the process should stop when images
/// change, \b false if the process should resume.
- //------------------------------------------------------------------
bool GetStopWhenImagesChange() const;
- //------------------------------------------------------------------
/// Set whether the process should stop when images change.
///
/// When images (executables and shared libraries) get loaded or unloaded,
@@ -144,54 +114,48 @@ public:
/// process stops when images change, but this can be overridden using this
/// function callback.
///
- /// @param[in] stop
+ /// \param[in] stop
/// Boolean value that indicates whether the process should stop
/// when images change.
- //------------------------------------------------------------------
void SetStopWhenImagesChange(bool stop);
- //------------------------------------------------------------------
/// Provides a plan to step through the dynamic loader trampoline for the
/// current state of \a thread.
///
///
- /// @param[in] stop_others
+ /// \param[in] stop_others
/// Whether the plan should be set to stop other threads.
///
- /// @return
+ /// \return
/// A pointer to the plan (caller owned) or NULL if we are not at such
/// a trampoline.
- //------------------------------------------------------------------
virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
bool stop_others) = 0;
- //------------------------------------------------------------------
/// Some dynamic loaders provide features where there are a group of symbols
/// "equivalent to" a given symbol one of which will be chosen when the
/// symbol is bound. If you want to set a breakpoint on one of these
/// symbols, you really need to set it on all the equivalent symbols.
///
///
- /// @param[in] original_symbol
+ /// \param[in] original_symbol
/// The symbol for which we are finding equivalences.
///
- /// @param[in] module_list
+ /// \param[in] module_list
/// The set of modules in which to search.
///
- /// @param[out] equivalent_symbols
+ /// \param[out] equivalent_symbols
/// The equivalent symbol list - any equivalent symbols found are appended
/// to this list.
///
- /// @return
+ /// \return
/// Number of equivalent symbols found.
- //------------------------------------------------------------------
virtual size_t FindEquivalentSymbols(Symbol *original_symbol,
ModuleList &module_list,
SymbolContextList &equivalent_symbols) {
return 0;
}
- //------------------------------------------------------------------
/// Ask if it is ok to try and load or unload an shared library (image).
///
/// The dynamic loader often knows when it would be ok to try and load or
@@ -199,13 +163,11 @@ public:
/// plug-ins to check any current dyld state to make sure it is an ok time
/// to load a shared library.
///
- /// @return
+ /// \return
/// \b true if it is currently ok to try and load a shared
/// library into the process, \b false otherwise.
- //------------------------------------------------------------------
virtual Status CanLoadImage() = 0;
- //------------------------------------------------------------------
/// Ask if the eh_frame information for the given SymbolContext should be
/// relied on even when it's the first frame in a stack unwind.
///
@@ -221,44 +183,40 @@ public:
/// not reliable enough -- we need to consult those function's hand-written
/// eh_frame information.
///
- /// @return
+ /// \return
/// \b True if the symbol context should use eh_frame instructions
/// unconditionally when unwinding from this frame. Else \b false,
/// the normal lldb unwind behavior of only using eh_frame when the
/// function appears in the middle of the stack.
- //------------------------------------------------------------------
virtual bool AlwaysRelyOnEHUnwindInfo(SymbolContext &sym_ctx) {
return false;
}
- //------------------------------------------------------------------
/// Retrieves the per-module TLS block for a given thread.
///
- /// @param[in] module
+ /// \param[in] module
/// The module to query TLS data for.
///
- /// @param[in] thread
+ /// \param[in] thread
/// The specific thread to query TLS data for.
///
- /// @return
+ /// \return
/// If the given thread has TLS data allocated for the
/// module, the address of the TLS block. Otherwise
/// LLDB_INVALID_ADDRESS is returned.
- //------------------------------------------------------------------
virtual lldb::addr_t GetThreadLocalData(const lldb::ModuleSP module,
const lldb::ThreadSP thread,
lldb::addr_t tls_file_addr) {
return LLDB_INVALID_ADDRESS;
}
- /// Locates or creates a module given by @p file and updates/loads the
- /// resulting module at the virtual base address @p base_addr.
+ /// Locates or creates a module given by \p file and updates/loads the
+ /// resulting module at the virtual base address \p base_addr.
virtual lldb::ModuleSP LoadModuleAtAddress(const lldb_private::FileSpec &file,
lldb::addr_t link_map_addr,
lldb::addr_t base_addr,
bool base_addr_is_offset);
- //------------------------------------------------------------------
/// Get information about the shared cache for a process, if possible.
///
/// On some systems (e.g. Darwin based systems), a set of libraries that are
@@ -273,27 +231,26 @@ public:
/// of the cache - or it may be able to return additional information about
/// the cache.
///
- /// @param[out] base_address
+ /// \param[out] base_address
/// The base address (load address) of the shared cache.
/// LLDB_INVALID_ADDRESS if it cannot be determined.
///
- /// @param[out] uuid
+ /// \param[out] uuid
/// The UUID of the shared cache, if it can be determined.
/// If the UUID cannot be fetched, IsValid() will be false.
///
- /// @param[out] using_shared_cache
+ /// \param[out] using_shared_cache
/// If this process is using a shared cache.
/// If unknown, eLazyBoolCalculate is returned.
///
- /// @param[out] private_shared_cache
+ /// \param[out] private_shared_cache
/// A LazyBool indicating whether this process is using a
/// private shared cache.
/// If this information cannot be fetched, eLazyBoolCalculate.
///
- /// @return
+ /// \return
/// Returns false if this DynamicLoader cannot gather information
/// about the shared cache / has no concept of a shared cache.
- //------------------------------------------------------------------
virtual bool GetSharedCacheInformation(lldb::addr_t &base_address, UUID &uuid,
LazyBool &using_shared_cache,
LazyBool &private_shared_cache) {
@@ -305,22 +262,20 @@ public:
}
protected:
- //------------------------------------------------------------------
// Utility methods for derived classes
- //------------------------------------------------------------------
/// Checks to see if the target module has changed, updates the target
/// accordingly and returns the target executable module.
lldb::ModuleSP GetTargetExecutable();
- /// Updates the load address of every allocatable section in @p module.
+ /// Updates the load address of every allocatable section in \p module.
///
- /// @param module The module to traverse.
+ /// \param module The module to traverse.
///
- /// @param link_map_addr The virtual address of the link map for the @p
+ /// \param link_map_addr The virtual address of the link map for the @p
/// module.
///
- /// @param base_addr The virtual base address @p module is loaded at.
+ /// \param base_addr The virtual base address \p module is loaded at.
virtual void UpdateLoadedSections(lldb::ModuleSP module,
lldb::addr_t link_map_addr,
lldb::addr_t base_addr,
@@ -331,9 +286,9 @@ protected:
void UpdateLoadedSectionsCommon(lldb::ModuleSP module, lldb::addr_t base_addr,
bool base_addr_is_offset);
- /// Removes the loaded sections from the target in @p module.
+ /// Removes the loaded sections from the target in \p module.
///
- /// @param module The module to traverse.
+ /// \param module The module to traverse.
virtual void UnloadSections(const lldb::ModuleSP module);
// Utility method so base classes can share implementation of UnloadSections
@@ -354,9 +309,7 @@ protected:
void LoadOperatingSystemPlugin(bool flush);
- //------------------------------------------------------------------
// Member variables.
- //------------------------------------------------------------------
Process
*m_process; ///< The process that this dynamic loader plug-in is tracking.