diff options
Diffstat (limited to 'gdb/solib.h')
| -rw-r--r-- | gdb/solib.h | 272 |
1 files changed, 251 insertions, 21 deletions
diff --git a/gdb/solib.h b/gdb/solib.h index f7a93c0..b9465e1 100644 --- a/gdb/solib.h +++ b/gdb/solib.h @@ -1,6 +1,6 @@ /* Shared library declarations for GDB, the GNU Debugger. - Copyright (C) 1992-2024 Free Software Foundation, Inc. + Copyright (C) 1992-2025 Free Software Foundation, Inc. This file is part of GDB. @@ -17,18 +17,17 @@ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#ifndef SOLIB_H -#define SOLIB_H - -/* Forward decl's for prototypes */ -struct solib; -struct target_ops; -struct solib_ops; -struct program_space; +#ifndef GDB_SOLIB_H +#define GDB_SOLIB_H #include "gdb_bfd.h" -#include "symfile-add-flags.h" #include "gdbsupport/function-view.h" +#include "gdbsupport/intrusive_list.h" +#include "gdbsupport/owning_intrusive_list.h" +#include "symfile-add-flags.h" +#include "target-section.h" + +struct program_space; /* Value of the 'set debug solib' configuration variable. */ @@ -42,6 +41,243 @@ extern bool debug_solib; #define SOLIB_SCOPED_DEBUG_START_END(fmt, ...) \ scoped_debug_start_end (debug_solib, "solib", fmt, ##__VA_ARGS__) +#define SO_NAME_MAX_PATH_SIZE 512 /* FIXME: Should be dynamic */ + +/* Base class for target-specific link map information. */ + +struct lm_info +{ + lm_info () = default; + lm_info (const lm_info &) = default; + virtual ~lm_info () = 0; +}; + +using lm_info_up = std::unique_ptr<lm_info>; + +struct solib_ops; + +struct solib : intrusive_list_node<solib> +{ + /* Constructor + + OPS is the solib_ops implementation providing this solib. */ + explicit solib (const solib_ops &ops) : m_ops (&ops) {} + + /* Return the solib_ops implementation providing this solib. */ + const solib_ops &ops () const + { return *m_ops; } + + /* Free symbol-file related contents of SO and reset for possible reloading + of SO. If we have opened a BFD for SO, close it. If we have placed SO's + sections in some target's section table, the caller is responsible for + removing them. + + This function doesn't mess with objfiles at all. If there is an + objfile associated with SO that needs to be removed, the caller is + responsible for taking care of that. */ + void clear () ; + + /* The following fields of the structure come directly from the + dynamic linker's tables in the inferior, and are initialized by + current_sos. */ + + /* A pointer to target specific link map information. Often this + will be a copy of struct link_map from the user process, but + it need not be; it can be any collection of data needed to + traverse the dynamic linker's data structures. */ + lm_info_up lm_info; + + /* Shared object file name, exactly as it appears in the + inferior's link map. This may be a relative path, or something + which needs to be looked up in LD_LIBRARY_PATH, etc. We use it + to tell which entries in the inferior's dynamic linker's link + map we've already loaded. */ + std::string original_name; + + /* Shared object file name, expanded to something GDB can open. */ + std::string name; + + /* The following fields of the structure are built from + information gathered from the shared object file itself, and + are set when we actually add it to our symbol tables. + + current_sos must initialize these fields to 0. */ + + gdb_bfd_ref_ptr abfd; + + /* True if symbols have been read in. */ + bool symbols_loaded = false; + + /* objfile with symbols for a loaded library. Target memory is read from + ABFD. OBJFILE may be NULL either before symbols have been loaded, if + the file cannot be found or after the command "nosharedlibrary". */ + struct objfile *objfile = nullptr; + + std::vector<target_section> sections; + + /* Record the range of addresses belonging to this shared library. + There may not be just one (e.g. if two segments are relocated + differently). This is used for "info sharedlibrary" and + the MI command "-file-list-shared-libraries". The latter has a format + that supports outputting multiple segments once the related code + supports them. */ + CORE_ADDR addr_low = 0, addr_high = 0; + +private: + /* The solib_ops responsible for this solib. */ + const solib_ops *m_ops; +}; + +/* A unique pointer to an solib. */ +using solib_up = std::unique_ptr<solib>; + +struct solib_ops +{ + virtual ~solib_ops () = default; + + /* Adjust the section binding addresses by the base address at + which the object was actually mapped. */ + virtual void relocate_section_addresses (solib &so, target_section *) const + = 0; + + /* Reset private data structures associated with SO. + This is called when SO is about to be reloaded. + It is also called when SO is about to be freed. + + Defaults to no-op. */ + virtual void clear_so (const solib &so) const {} + + /* Free private data structures associated to PSPACE. This method + should not free resources associated to individual solib entries, + those are cleared by the clear_so method. + + Defaults to no-op. */ + virtual void clear_solib (program_space *pspace) const {} + + /* Target dependent code to run after child process fork. + + Defaults to no-op. */ + virtual void create_inferior_hook (int from_tty) const {}; + + /* Construct a list of the currently loaded shared objects. This + list does not include an entry for the main executable file. + + Note that we only gather information directly available from the + inferior --- we don't examine any of the shared library files + themselves. The declaration of `struct solib' says which fields + we provide values for. */ + virtual owning_intrusive_list<solib> current_sos () const = 0; + + /* Find, open, and read the symbols for the main executable. If + FROM_TTY is non-zero, allow messages to be printed. + + Return true if this was done successfully. Defaults to false. */ + virtual bool open_symbol_file_object (int from_tty) const { return false; } + + /* Determine if PC lies in the dynamic symbol resolution code of + the run time loader. + + Defaults to false. */ + virtual bool in_dynsym_resolve_code (CORE_ADDR pc) const + { return false; }; + + /* Find and open shared library binary file. */ + virtual gdb_bfd_ref_ptr bfd_open (const char *pathname) const; + + /* Given two solib objects, GDB from the GDB thread list and INFERIOR from the + list returned by current_sos, return true if they represent the same library. + + Defaults to comparing the solib original names using filename_cmp. */ + virtual bool same (const solib &gdb, const solib &inferior) const; + + /* Return whether a region of memory must be kept in a core file + for shared libraries loaded before "gcore" is used to be + handled correctly when the core file is loaded. This only + applies when the section would otherwise not be kept in the + core file (in particular, for readonly sections). + + Defaults to false. */ + virtual bool keep_data_in_core (CORE_ADDR vaddr, unsigned long size) const + { return false; }; + + /* Enable or disable optional solib event breakpoints as appropriate. This + should be called whenever stop_on_solib_events is changed. + + Defaults to no-op. */ + virtual void update_breakpoints () const {}; + + /* Target-specific processing of solib events that will be performed before + solib_add is called. + + Defaults to no-op. */ + virtual void handle_event () const {}; + + /* Return an address within the inferior's address space which is known + to be part of SO. If there is no such address, or GDB doesn't know + how to figure out such an address then an empty optional is + returned. + + The returned address can be used when loading the shared libraries + for a core file. GDB knows the build-ids for (some) files mapped + into the inferior's address space, and knows the address ranges which + those mapped files cover. If GDB can figure out a representative + address for the library then this can be used to match a library to a + mapped file, and thus to a build-id. GDB can then use this + information to help locate the shared library objfile, if the objfile + is not in the expected place (as defined by the shared libraries file + name). + + The default implementation of returns an empty option, indicating GDB is + unable to find an address within the library SO. */ + virtual std::optional<CORE_ADDR> find_solib_addr (solib &so) const + { return {}; }; + + /* Return true if the linker or libc supports linkage namespaces. + + Defaults to false. */ + virtual bool supports_namespaces () const { return false; } + + /* Return which linker namespace contains SO. + + The supports_namespaces method must return true for this to be + called. + + Throw an error if the namespace can not be determined (such as when we're + stepping though the dynamic linker). */ + virtual int find_solib_ns (const solib &so) const + { gdb_assert_not_reached ("namespaces not supported"); } + + /* Returns the number of active namespaces in the inferior. + + The supports_namespaces method must return true for this to be called. */ + virtual int num_active_namespaces () const + { gdb_assert_not_reached ("namespaces not supported"); } + + /* Returns all solibs for a given namespace. If the namespace is not + active, returns an empty vector. + + The supports_namespaces method must return true for this to be called. */ + virtual std::vector<const solib *> get_solibs_in_ns (int ns) const + { gdb_assert_not_reached ("namespaces not supported"); } +}; + +/* A unique pointer to an solib_ops. */ +using solib_ops_up = std::unique_ptr<solib_ops>; + +/* Find main executable binary file. */ +extern gdb::unique_xmalloc_ptr<char> exec_file_find (const char *in_pathname, + int *fd); + +/* Find shared library binary file. */ +extern gdb::unique_xmalloc_ptr<char> solib_find (const char *in_pathname, + int *fd); + +/* Open BFD for shared library file. */ +extern gdb_bfd_ref_ptr solib_bfd_fopen (const char *pathname, int fd); + +/* Find solib binary file and open it. */ +extern gdb_bfd_ref_ptr solib_bfd_open (const char *in_pathname); + /* Called when we free all symtabs of PSPACE, to free the shared library information as well. */ @@ -80,16 +316,17 @@ extern bool solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size); extern bool in_solib_dynsym_resolve_code (CORE_ADDR); -/* Discard symbols that were auto-loaded from shared libraries. */ +/* Discard symbols that were auto-loaded from shared libraries in PSPACE. */ -extern void no_shared_libraries (const char *ignored, int from_tty); +extern void no_shared_libraries (program_space *pspace); /* Synchronize GDB's shared object list with inferior's. Extract the list of currently loaded shared objects from the inferior, and compare it with the list of shared objects in the current program space's list of shared libraries. Edit - so_list_head to bring it in sync with the inferior's new list. + the current program space's solib list to bring it in sync with the + inferior's new list. If we notice that the inferior has unloaded some shared objects, free any symbolic info GDB had read about those shared objects. @@ -136,11 +373,4 @@ extern void update_solib_breakpoints (void); extern void handle_solib_event (void); -/* Associate SONAME with BUILD_ID in ABFD's registry so that it can be - retrieved with get_cbfd_soname_build_id. */ - -extern void set_cbfd_soname_build_id (gdb_bfd_ref_ptr abfd, - const char *soname, - const bfd_build_id *build_id); - -#endif /* SOLIB_H */ +#endif /* GDB_SOLIB_H */ |