* [PATCH v2 03/10] gdb/solib-rocm: add cached_target_fd to manage cached fd lifetime
[not found] <20260608193520.652569-1-simon.marchi@efficios.com>
@ 2026-06-08 19:34 ` Simon Marchi
2026-06-08 19:34 ` [PATCH v2 04/10] gdb: de-constify some methods of solib_ops Simon Marchi
2026-06-08 19:34 ` [PATCH v2 10/10] gdb: multiple solib_ops per program space Simon Marchi
2 siblings, 0 replies; 3+ messages in thread
From: Simon Marchi @ 2026-06-08 19:34 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
Make the management of the cached fds automatic.
Change rocm_solib_fd_cache::open to return a cached_target_fd, an RAII
type that calls rocm_solib_fd_cache::close on destruction.
cached_target_fd holds the actual fd and a reference to the cache it
comes from.
Change rocm_code_object_stream_file to hold a cached_target_fd and
remove the explicit destructor.
This is not essential, I just thought it would be nice.
Change-Id: I2529ac1caebbe6b7e6e60d228a403064f6f38d06
---
gdb/solib-rocm.c | 90 +++++++++++++++++++++++++++++++-----------------
1 file changed, 59 insertions(+), 31 deletions(-)
diff --git a/gdb/solib-rocm.c b/gdb/solib-rocm.c
index f96f0823200e..60e64c494f88 100644
--- a/gdb/solib-rocm.c
+++ b/gdb/solib-rocm.c
@@ -40,22 +40,63 @@ struct rocm_solib_fd_cache
explicit rocm_solib_fd_cache (inferior *inf) : m_inferior (inf) {}
DISABLE_COPY_AND_ASSIGN (rocm_solib_fd_cache);
+ /* The open method returns an object of this type.
+
+ On destruction, automatically call close to indicate the caller no longer
+ uses the fd. */
+ struct cached_target_fd
+ {
+ cached_target_fd (target_fd fd, rocm_solib_fd_cache &cache)
+ : m_fd (fd),
+ m_cache (cache)
+ {
+ }
+
+ cached_target_fd (cached_target_fd &&other)
+ : m_fd (other.m_fd),
+ m_cache (other.m_cache)
+ {
+ other.m_fd = target_fd::INVALID;
+ }
+
+ ~cached_target_fd ()
+ {
+ if (m_fd == target_fd::INVALID)
+ return;
+
+ fileio_error target_errno;
+ if (m_cache.close (m_fd, &target_errno) != 0)
+ warning (_("Failed to close solib: %s"),
+ strerror (fileio_error_to_host (target_errno)));
+ }
+
+ DISABLE_COPY_AND_ASSIGN (cached_target_fd);
+
+ target_fd fd () const { return m_fd; }
+
+private:
+ target_fd m_fd;
+ rocm_solib_fd_cache &m_cache;
+ };
+
/* Return a read-only file descriptor to FILENAME and increment the
associated reference count.
Open the file FILENAME if it is not already opened, reuse the existing file
descriptor otherwise.
- On error target_fd::INVALID is returned, and TARGET_ERRNO is set. */
- target_fd open (const std::string &filename, fileio_error *target_errno);
+ On error, return a cached_target_fd with target_fd::INVALID and set
+ *TARGET_ERRNO. */
+ cached_target_fd open (const std::string &filename,
+ fileio_error *target_errno);
+private:
/* Decrement the reference count to FD and close FD if the reference count
reaches 0.
On success, return 0. On error, return -1 and set TARGET_ERRNO. */
int close (target_fd fd, fileio_error *target_errno);
-private:
struct refcnt_fd
{
refcnt_fd (target_fd fd, int refcnt) : fd (fd), refcnt (refcnt) {}
@@ -73,7 +114,7 @@ struct rocm_solib_fd_cache
gdb::unordered_string_map<refcnt_fd> m_cache;
};
-target_fd
+rocm_solib_fd_cache::cached_target_fd
rocm_solib_fd_cache::open (const std::string &filename,
fileio_error *target_errno)
{
@@ -88,7 +129,7 @@ rocm_solib_fd_cache::open (const std::string &filename,
m_cache.emplace (std::piecewise_construct,
std::forward_as_tuple (filename),
std::forward_as_tuple (fd, 1));
- return fd;
+ return cached_target_fd { fd, *this };;
}
else
{
@@ -96,7 +137,7 @@ rocm_solib_fd_cache::open (const std::string &filename,
already opened FD. */
it->second.refcnt++;
gdb_assert (it->second.fd != target_fd::INVALID);
- return it->second.fd;
+ return cached_target_fd { it->second.fd, *this };
}
}
@@ -356,7 +397,7 @@ struct rocm_code_object_stream_file final : rocm_code_object_stream
{
DISABLE_COPY_AND_ASSIGN (rocm_code_object_stream_file);
- rocm_code_object_stream_file (rocm_solib_fd_cache &fd_cache, target_fd fd,
+ rocm_code_object_stream_file (rocm_solib_fd_cache::cached_target_fd fd,
ULONGEST offset, ULONGEST size);
file_ptr read (bfd *abfd, void *buf, file_ptr size,
@@ -364,14 +405,9 @@ struct rocm_code_object_stream_file final : rocm_code_object_stream
LONGEST size () override;
- ~rocm_code_object_stream_file () override;
-
protected:
- /* The fd cache owning this code object stream. */
- rocm_solib_fd_cache &m_fd_cache;
-
/* The target file descriptor for this stream. */
- target_fd m_fd;
+ rocm_solib_fd_cache::cached_target_fd m_fd;
/* The offset of the ELF file image in the target file. */
ULONGEST m_offset;
@@ -382,9 +418,8 @@ struct rocm_code_object_stream_file final : rocm_code_object_stream
};
rocm_code_object_stream_file::rocm_code_object_stream_file
- (rocm_solib_fd_cache &fd_cache, target_fd fd, ULONGEST offset,
- ULONGEST size)
- : m_fd_cache (fd_cache), m_fd (fd), m_offset (offset), m_size (size)
+ (rocm_solib_fd_cache::cached_target_fd fd, ULONGEST offset, ULONGEST size)
+ : m_fd (std::move (fd)), m_offset (offset), m_size (size)
{
}
@@ -399,9 +434,9 @@ rocm_code_object_stream_file::read (bfd *, void *buf, file_ptr size,
QUIT;
file_ptr bytes_read
- = target_fileio_pread (m_fd, static_cast<gdb_byte *> (buf) + nbytes,
- size, m_offset + offset + nbytes,
- &target_errno);
+ = target_fileio_pread (m_fd.fd (),
+ static_cast<gdb_byte *> (buf) + nbytes, size,
+ m_offset + offset + nbytes, &target_errno);
if (bytes_read == 0)
break;
@@ -427,7 +462,7 @@ rocm_code_object_stream_file::size ()
{
fileio_error target_errno;
struct stat stat;
- if (target_fileio_fstat (m_fd, &stat, &target_errno) < 0)
+ if (target_fileio_fstat (m_fd.fd (), &stat, &target_errno) < 0)
{
errno = fileio_error_to_host (target_errno);
bfd_set_error (bfd_error_system_call);
@@ -447,14 +482,6 @@ rocm_code_object_stream_file::size ()
return m_size;
}
-rocm_code_object_stream_file::~rocm_code_object_stream_file ()
-{
- fileio_error target_errno;
- if (m_fd_cache.close (m_fd, &target_errno) != 0)
- warning (_("Failed to close solib: %s"),
- strerror (fileio_error_to_host (target_errno)));
-}
-
/* Interface to a code object which lives in the inferior's memory. */
struct rocm_code_object_stream_memory final : public rocm_code_object_stream
@@ -610,16 +637,17 @@ rocm_bfd_iovec_open (bfd *abfd, inferior *inferior)
auto info = get_solib_info (inferior);
fileio_error target_errno;
- target_fd fd = info->fd_cache.open (decoded_path, &target_errno);
+ rocm_solib_fd_cache::cached_target_fd fd
+ = info->fd_cache.open (decoded_path, &target_errno);
- if (fd == target_fd::INVALID)
+ if (fd.fd () == target_fd::INVALID)
{
errno = fileio_error_to_host (target_errno);
bfd_set_error (bfd_error_system_call);
return nullptr;
}
- return new rocm_code_object_stream_file (info->fd_cache, fd, offset,
+ return new rocm_code_object_stream_file (std::move (fd), offset,
size);
}
--
2.54.0
^ permalink raw reply [flat|nested] 3+ messages in thread* [PATCH v2 04/10] gdb: de-constify some methods of solib_ops
[not found] <20260608193520.652569-1-simon.marchi@efficios.com>
2026-06-08 19:34 ` [PATCH v2 03/10] gdb/solib-rocm: add cached_target_fd to manage cached fd lifetime Simon Marchi
@ 2026-06-08 19:34 ` Simon Marchi
2026-06-08 19:34 ` [PATCH v2 10/10] gdb: multiple solib_ops per program space Simon Marchi
2 siblings, 0 replies; 3+ messages in thread
From: Simon Marchi @ 2026-06-08 19:34 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
The following commit moves the ROCm solib data from a registry to the
rocm_solib_ops object itself. This requires making some methods
non-const, and it then cascades to a bunch of things. This will have to
be done one day or another, when (I suspect) we'll move more solib_ops
data out of registries and into the solib_ops objects themselves. Do it
in this separate patch to avoid polluting that patch.
No behavior change expected.
Change-Id: Icb5e921a82e235817f8817a3aa3c20b2c9dc959f
---
gdb/progspace.h | 2 +-
gdb/solib-aix.c | 12 ++++++------
gdb/solib-darwin.c | 12 ++++++------
gdb/solib-dsbt.c | 8 ++++----
gdb/solib-frv.c | 8 ++++----
gdb/solib-rocm.c | 20 ++++++++++----------
gdb/solib-svr4.c | 14 +++++++-------
gdb/solib-svr4.h | 14 +++++++-------
gdb/solib-target.c | 2 +-
gdb/solib-target.h | 2 +-
gdb/solib.c | 8 ++++----
gdb/solib.h | 14 +++++++-------
gdb/windows-tdep.c | 4 ++--
13 files changed, 60 insertions(+), 60 deletions(-)
diff --git a/gdb/progspace.h b/gdb/progspace.h
index e9261ff8590d..21977747cb94 100644
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -260,7 +260,7 @@ struct program_space
{ return std::move (m_solib_ops); }
/* Get this program space's solib provider. */
- const struct solib_ops *solib_ops () const
+ struct solib_ops *solib_ops () const
{ return m_solib_ops.get (); }
/* Return the list of all the solibs in this program space. */
diff --git a/gdb/solib-aix.c b/gdb/solib-aix.c
index 705760651217..28f69ed9cbb4 100644
--- a/gdb/solib-aix.c
+++ b/gdb/solib-aix.c
@@ -32,9 +32,9 @@ struct aix_solib_ops : public solib_ops
using solib_ops::solib_ops;
void relocate_section_addresses (solib &so, target_section *) const override;
- void create_inferior_hook (int from_tty) const override;
- owning_intrusive_list<solib> current_sos () const override;
- gdb_bfd_ref_ptr bfd_open (const char *pathname) const override;
+ void create_inferior_hook (int from_tty) override;
+ owning_intrusive_list<solib> current_sos () override;
+ gdb_bfd_ref_ptr bfd_open (const char *pathname) override;
};
/* See solib-aix.h. */
@@ -425,7 +425,7 @@ solib_aix_get_section_offsets (struct objfile *objfile,
}
void
-aix_solib_ops::create_inferior_hook (int from_tty) const
+aix_solib_ops::create_inferior_hook (int from_tty)
{
const char *warning_msg = "unable to relocate main executable";
@@ -454,7 +454,7 @@ aix_solib_ops::create_inferior_hook (int from_tty) const
}
owning_intrusive_list<solib>
-aix_solib_ops::current_sos () const
+aix_solib_ops::current_sos ()
{
std::optional<std::vector<lm_info_aix>> &library_list
= solib_aix_get_library_list (current_inferior (), NULL);
@@ -498,7 +498,7 @@ aix_solib_ops::current_sos () const
}
gdb_bfd_ref_ptr
-aix_solib_ops::bfd_open (const char *pathname) const
+aix_solib_ops::bfd_open (const char *pathname)
{
/* The pathname is actually a synthetic filename with the following
form: "/path/to/sharedlib(member.o)" (double-quotes excluded).
diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c
index 6e2535ca427f..07cd88d0e0c6 100644
--- a/gdb/solib-darwin.c
+++ b/gdb/solib-darwin.c
@@ -42,9 +42,9 @@ struct darwin_solib_ops : public solib_ops
void relocate_section_addresses (solib &so, target_section *) const override;
void clear_solib (program_space *pspace) const override;
- void create_inferior_hook (int from_tty) const override;
- owning_intrusive_list<solib> current_sos () const override;
- gdb_bfd_ref_ptr bfd_open (const char *pathname) const override;
+ void create_inferior_hook (int from_tty) override;
+ owning_intrusive_list<solib> current_sos () override;
+ gdb_bfd_ref_ptr bfd_open (const char *pathname) override;
};
/* See solib-darwin.h. */
@@ -211,7 +211,7 @@ find_program_interpreter (void)
}
owning_intrusive_list<solib>
-darwin_solib_ops::current_sos () const
+darwin_solib_ops::current_sos ()
{
type *ptr_type
= builtin_type (current_inferior ()->arch ())->builtin_data_ptr;
@@ -471,7 +471,7 @@ darwin_solib_read_all_image_info_addr (struct darwin_info *info)
}
void
-darwin_solib_ops::create_inferior_hook (int from_tty) const
+darwin_solib_ops::create_inferior_hook (int from_tty)
{
/* Everything below only makes sense if we have a running inferior. */
if (!target_has_execution ())
@@ -606,7 +606,7 @@ darwin_solib_ops::relocate_section_addresses (solib &so,
}
gdb_bfd_ref_ptr
-darwin_solib_ops::bfd_open (const char *pathname) const
+darwin_solib_ops::bfd_open (const char *pathname)
{
int found_file;
diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
index 052b170fd9a6..22b9a581546a 100644
--- a/gdb/solib-dsbt.c
+++ b/gdb/solib-dsbt.c
@@ -128,8 +128,8 @@ struct dsbt_solib_ops : public solib_ops
void relocate_section_addresses (solib &so, target_section *) const override;
void clear_solib (program_space *pspace) const override;
- void create_inferior_hook (int from_tty) const override;
- owning_intrusive_list<solib> current_sos () const override;
+ void create_inferior_hook (int from_tty) override;
+ owning_intrusive_list<solib> current_sos () override;
bool in_dynsym_resolve_code (CORE_ADDR pc) const override;
};
@@ -526,7 +526,7 @@ lm_base (void)
we provide values for. */
owning_intrusive_list<solib>
-dsbt_solib_ops::current_sos () const
+dsbt_solib_ops::current_sos ()
{
bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
CORE_ADDR lm_addr;
@@ -860,7 +860,7 @@ dsbt_relocate_main_executable (void)
The shared library breakpoints also need to be enabled. */
void
-dsbt_solib_ops::create_inferior_hook (int from_tty) const
+dsbt_solib_ops::create_inferior_hook (int from_tty)
{
/* Relocate main executable. */
dsbt_relocate_main_executable ();
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index 4f0aac31e733..cff3c3ca0193 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -36,8 +36,8 @@ struct frv_solib_ops : public solib_ops
void relocate_section_addresses (solib &so, target_section *) const override;
void clear_solib (program_space *pspace) const override;
- void create_inferior_hook (int from_tty) const override;
- owning_intrusive_list<solib> current_sos () const override;
+ void create_inferior_hook (int from_tty) override;
+ owning_intrusive_list<solib> current_sos () override;
bool in_dynsym_resolve_code (CORE_ADDR pc) const override;
};
@@ -321,7 +321,7 @@ lm_base (void)
}
owning_intrusive_list<solib>
-frv_solib_ops::current_sos () const
+frv_solib_ops::current_sos ()
{
bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
CORE_ADDR lm_addr, mgot;
@@ -789,7 +789,7 @@ frv_relocate_main_executable (void)
enabled. */
void
-frv_solib_ops::create_inferior_hook (int from_tty) const
+frv_solib_ops::create_inferior_hook (int from_tty)
{
/* Relocate main executable. */
frv_relocate_main_executable ();
diff --git a/gdb/solib-rocm.c b/gdb/solib-rocm.c
index 60e64c494f88..4032ada28a0f 100644
--- a/gdb/solib-rocm.c
+++ b/gdb/solib-rocm.c
@@ -215,11 +215,11 @@ struct rocm_solib_ops : public solib_ops
{ return std::move (m_host_ops); }
/* The methods implemented by rocm_solib_ops. */
- owning_intrusive_list<solib> current_sos () const override;
- void create_inferior_hook (int from_tty) const override;
- gdb_bfd_ref_ptr bfd_open (const char *pathname) const override;
+ owning_intrusive_list<solib> current_sos () override;
+ void create_inferior_hook (int from_tty) override;
+ gdb_bfd_ref_ptr bfd_open (const char *pathname) override;
void relocate_section_addresses (solib &so, target_section *) const override;
- void handle_event () const override;
+ void handle_event () override;
/* Implement the following methods just to forward the calls to the host
solib_ops. We currently need to implement all the methods that
@@ -270,7 +270,7 @@ struct rocm_solib_ops : public solib_ops
private:
owning_intrusive_list<solib>
- solibs_from_rocm_sos (const std::vector<rocm_so> &sos) const;
+ solibs_from_rocm_sos (const std::vector<rocm_so> &sos);
solib_ops_up m_host_ops;
};
@@ -303,7 +303,7 @@ rocm_solib_ops::relocate_section_addresses (solib &so,
static void rocm_update_solib_list ();
void
-rocm_solib_ops::handle_event () const
+rocm_solib_ops::handle_event ()
{
/* Since we sit on top of a host solib_ops, we might get called following an
event concerning host libraries. We must therefore forward the call. If
@@ -319,7 +319,7 @@ rocm_solib_ops::handle_event () const
/* Create solib objects from rocm_so objects in SOS. */
owning_intrusive_list<solib>
-rocm_solib_ops::solibs_from_rocm_sos (const std::vector<rocm_so> &sos) const
+rocm_solib_ops::solibs_from_rocm_sos (const std::vector<rocm_so> &sos)
{
owning_intrusive_list<solib> dst;
@@ -334,7 +334,7 @@ rocm_solib_ops::solibs_from_rocm_sos (const std::vector<rocm_so> &sos) const
objects currently loaded in the inferior. */
owning_intrusive_list<solib>
-rocm_solib_ops::current_sos () const
+rocm_solib_ops::current_sos ()
{
/* First, retrieve the host-side shared library list. */
owning_intrusive_list<solib> sos = m_host_ops->current_sos ();
@@ -692,7 +692,7 @@ rocm_bfd_iovec_open (bfd *abfd, inferior *inferior)
}
gdb_bfd_ref_ptr
-rocm_solib_ops::bfd_open (const char *pathname) const
+rocm_solib_ops::bfd_open (const char *pathname)
{
/* Handle regular files with SVR4 open. */
if (strstr (pathname, "://") == nullptr)
@@ -780,7 +780,7 @@ rocm_solib_ops::bfd_open (const char *pathname) const
}
void
-rocm_solib_ops::create_inferior_hook (int from_tty) const
+rocm_solib_ops::create_inferior_hook (int from_tty)
{
get_solib_info (current_inferior ())->solib_list.clear ();
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 8e3de4d3ea1a..35c81000b10a 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -1059,7 +1059,7 @@ svr4_solib_ops::clear_so (const solib &so) const
/* Create the solib objects equivalent to the svr4_sos in SOS. */
owning_intrusive_list<solib>
-svr4_solib_ops::solibs_from_svr4_sos (const std::vector<svr4_so> &sos) const
+svr4_solib_ops::solibs_from_svr4_sos (const std::vector<svr4_so> &sos)
{
owning_intrusive_list<solib> dst;
@@ -1253,7 +1253,7 @@ svr4_current_sos_via_xfer_libraries (struct svr4_library_list *list,
linker, build a fallback list from other sources. */
owning_intrusive_list<solib>
-svr4_solib_ops::default_sos (svr4_info *info) const
+svr4_solib_ops::default_sos (svr4_info *info)
{
if (!info->debug_loader_offset_p)
return {};
@@ -1452,7 +1452,7 @@ svr4_solib_ops::current_sos_direct (svr4_info *info) const
/* Collect sos read and stored by the probes interface. */
owning_intrusive_list<solib>
-svr4_solib_ops::collect_probes_sos (svr4_info *info) const
+svr4_solib_ops::collect_probes_sos (svr4_info *info)
{
owning_intrusive_list<solib> res;
@@ -1469,7 +1469,7 @@ svr4_solib_ops::collect_probes_sos (svr4_info *info) const
method. */
owning_intrusive_list<solib>
-svr4_solib_ops::current_sos_1 (svr4_info *info) const
+svr4_solib_ops::current_sos_1 (svr4_info *info)
{
owning_intrusive_list<solib> sos;
@@ -1496,7 +1496,7 @@ svr4_solib_ops::current_sos_1 (svr4_info *info) const
/* Implement the "current_sos" solib_ops method. */
owning_intrusive_list<solib>
-svr4_solib_ops::current_sos () const
+svr4_solib_ops::current_sos ()
{
svr4_info *info = get_svr4_info (current_program_space);
@@ -2143,7 +2143,7 @@ svr4_solib_ops::disable_probes_interface (svr4_info *info) const
standard interface. */
void
-svr4_solib_ops::handle_event () const
+svr4_solib_ops::handle_event ()
{
struct svr4_info *info = get_svr4_info (current_program_space);
struct probe_and_action *pa;
@@ -3318,7 +3318,7 @@ svr4_relocate_main_executable (void)
their symbols to be read at a later time. */
void
-svr4_solib_ops::create_inferior_hook (int from_tty) const
+svr4_solib_ops::create_inferior_hook (int from_tty)
{
struct svr4_info *info;
diff --git a/gdb/solib-svr4.h b/gdb/solib-svr4.h
index 3078a092778c..d7f58a76224d 100644
--- a/gdb/solib-svr4.h
+++ b/gdb/solib-svr4.h
@@ -99,14 +99,14 @@ struct svr4_solib_ops : public solib_ops
void relocate_section_addresses (solib &so, target_section *) const override;
void clear_so (const solib &so) const override;
void clear_solib (program_space *pspace) const override;
- void create_inferior_hook (int from_tty) const override;
- owning_intrusive_list<solib> current_sos () const override;
+ void create_inferior_hook (int from_tty) override;
+ owning_intrusive_list<solib> current_sos () override;
bool open_symbol_file_object (int from_tty) const override;
bool in_dynsym_resolve_code (CORE_ADDR pc) const override;
bool same (const solib &gdb, const solib &inferior) const override;
bool keep_data_in_core (CORE_ADDR vaddr, unsigned long size) const override;
void update_breakpoints () const override;
- void handle_event () const override;
+ void handle_event () override;
std::optional<CORE_ADDR> find_solib_addr (solib &so) const override;
bool supports_namespaces () const override { return true; }
int find_solib_ns (const solib &so) const override;
@@ -135,7 +135,7 @@ struct svr4_solib_ops : public solib_ops
void free_probes_table (svr4_info *info) const;
CORE_ADDR find_r_brk (svr4_info *info) const;
CORE_ADDR find_r_ldsomap (svr4_info *info) const;
- owning_intrusive_list<solib> default_sos (svr4_info *info) const;
+ owning_intrusive_list<solib> default_sos (svr4_info *info);
int read_so_list (svr4_info *info, CORE_ADDR lm, CORE_ADDR prev_lm,
CORE_ADDR debug_base, std::vector<svr4_so> &sos,
int ignore_first) const;
@@ -144,10 +144,10 @@ struct svr4_solib_ops : public solib_ops
CORE_ADDR lm_addr_check (const solib &so, bfd *abfd) const;
CORE_ADDR read_r_next (CORE_ADDR debug_base) const;
CORE_ADDR read_r_map (CORE_ADDR debug_base) const;
- owning_intrusive_list<solib> collect_probes_sos (svr4_info *info) const;
- owning_intrusive_list<solib> current_sos_1 (svr4_info *info) const;
+ owning_intrusive_list<solib> collect_probes_sos (svr4_info *info);
+ owning_intrusive_list<solib> current_sos_1 (svr4_info *info);
owning_intrusive_list<solib> solibs_from_svr4_sos
- (const std::vector<svr4_so> &sos) const;
+ (const std::vector<svr4_so> &sos);
void disable_probes_interface (svr4_info *info) const;
void update_full (svr4_info *info) const;
int update_incremental (svr4_info *info, CORE_ADDR debug_base,
diff --git a/gdb/solib-target.c b/gdb/solib-target.c
index ac965df20e94..0df8c6048aef 100644
--- a/gdb/solib-target.c
+++ b/gdb/solib-target.c
@@ -232,7 +232,7 @@ solib_target_parse_libraries (const char *library)
#endif
owning_intrusive_list<solib>
-target_solib_ops::current_sos () const
+target_solib_ops::current_sos ()
{
owning_intrusive_list<solib> sos;
diff --git a/gdb/solib-target.h b/gdb/solib-target.h
index 0d2f0840aa63..abfa0b513742 100644
--- a/gdb/solib-target.h
+++ b/gdb/solib-target.h
@@ -29,7 +29,7 @@ struct target_solib_ops : solib_ops
using solib_ops::solib_ops;
void relocate_section_addresses (solib &so, target_section *) const override;
- owning_intrusive_list<solib> current_sos () const override;
+ owning_intrusive_list<solib> current_sos () override;
bool in_dynsym_resolve_code (CORE_ADDR pc) const override;
};
diff --git a/gdb/solib.c b/gdb/solib.c
index d92d0dd9a3dd..ae41572b2b58 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -438,7 +438,7 @@ solib_bfd_open (const char *pathname)
}
gdb_bfd_ref_ptr
-solib_ops::bfd_open (const char *pathname) const
+solib_ops::bfd_open (const char *pathname)
{
return solib_bfd_open (pathname);
}
@@ -689,7 +689,7 @@ notify_solib_unloaded (program_space *pspace, const solib &so,
void
update_solib_list (int from_tty)
{
- const solib_ops *ops = current_program_space->solib_ops ();
+ solib_ops *ops = current_program_space->solib_ops ();
if (ops == nullptr)
return;
@@ -1289,7 +1289,7 @@ clear_solib (program_space *pspace)
void
solib_create_inferior_hook (int from_tty)
{
- if (const solib_ops *ops = current_program_space->solib_ops ();
+ if (solib_ops *ops = current_program_space->solib_ops ();
ops != nullptr)
ops->create_inferior_hook (from_tty);
}
@@ -1354,7 +1354,7 @@ update_solib_breakpoints (void)
void
handle_solib_event (void)
{
- if (const solib_ops *ops = current_program_space->solib_ops ();
+ if (solib_ops *ops = current_program_space->solib_ops ();
ops != nullptr)
ops->handle_event ();
diff --git a/gdb/solib.h b/gdb/solib.h
index 9e6c3f7346ee..5b5049f53435 100644
--- a/gdb/solib.h
+++ b/gdb/solib.h
@@ -62,7 +62,7 @@ struct solib : intrusive_list_node<solib>
OPS is the solib_ops implementation providing this solib. */
explicit solib (lm_info_up lm_info, std::string original_name,
- std::string name, const solib_ops &ops)
+ std::string name, solib_ops &ops)
: lm_info (std::move (lm_info)),
original_name (std::move (original_name)),
name (std::move (name)),
@@ -70,7 +70,7 @@ struct solib : intrusive_list_node<solib>
{}
/* Return the solib_ops implementation providing this solib. */
- const solib_ops &ops () const
+ solib_ops &ops () const
{ return *m_ops; }
/* Free symbol-file related contents of SO and reset for possible reloading
@@ -131,7 +131,7 @@ struct solib : intrusive_list_node<solib>
private:
/* The solib_ops responsible for this solib. */
- const solib_ops *m_ops;
+ solib_ops *m_ops;
};
/* A unique pointer to an solib. */
@@ -173,7 +173,7 @@ struct solib_ops
/* Target dependent code to run after child process fork.
Defaults to no-op. */
- virtual void create_inferior_hook (int from_tty) const {};
+ virtual void create_inferior_hook (int from_tty) {};
/* Construct a list of the currently loaded shared objects. This
list does not include an entry for the main executable file.
@@ -182,7 +182,7 @@ struct solib_ops
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;
+ virtual owning_intrusive_list<solib> current_sos () = 0;
/* Find, open, and read the symbols for the main executable. If
FROM_TTY is non-zero, allow messages to be printed.
@@ -198,7 +198,7 @@ struct solib_ops
{ return false; };
/* Find and open shared library binary file. */
- virtual gdb_bfd_ref_ptr bfd_open (const char *pathname) const;
+ virtual gdb_bfd_ref_ptr bfd_open (const char *pathname);
/* 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.
@@ -226,7 +226,7 @@ struct solib_ops
solib_add is called.
Defaults to no-op. */
- virtual void handle_event () const {};
+ virtual void handle_event () {};
/* 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
diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index 78bf49b9c81f..261c38b35635 100644
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -828,7 +828,7 @@ struct windows_solib_ops : target_solib_ops
{
using target_solib_ops::target_solib_ops;
- void create_inferior_hook (int from_tty) const override;
+ void create_inferior_hook (int from_tty) override;
void iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb,
objfile *current_objfile) const override;
@@ -845,7 +845,7 @@ make_windows_solib_ops (program_space *pspace)
/* Implement the "solib_create_inferior_hook" solib_ops method. */
void
-windows_solib_ops::create_inferior_hook (int from_tty) const
+windows_solib_ops::create_inferior_hook (int from_tty)
{
CORE_ADDR exec_base = 0;
--
2.54.0
^ permalink raw reply [flat|nested] 3+ messages in thread* [PATCH v2 10/10] gdb: multiple solib_ops per program space
[not found] <20260608193520.652569-1-simon.marchi@efficios.com>
2026-06-08 19:34 ` [PATCH v2 03/10] gdb/solib-rocm: add cached_target_fd to manage cached fd lifetime Simon Marchi
2026-06-08 19:34 ` [PATCH v2 04/10] gdb: de-constify some methods of solib_ops Simon Marchi
@ 2026-06-08 19:34 ` Simon Marchi
2 siblings, 0 replies; 3+ messages in thread
From: Simon Marchi @ 2026-06-08 19:34 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi, Tom Tromey
From: Simon Marchi <simon.marchi@polymtl.ca>
This patch adds the possibility for a program space to have multiple
solib_ops. The motivation for this is to support ROCm (GPU) debugging
more cleanly.
Currently, when debugging a ROCm program, in order to be able to list
device code objects (the equivalent of shared libraries but for the
GPU), we install an instance of rocm_solib_ops as the program space's
sole solib_ops. But in order to still be able to list host shared
libraries, the rocm_solib_ops wraps the previously installed solib_ops
(currently always an svr4_solib_ops instance) and forwards method calls
to it.
By allowing program spaces to use multiple solib_ops, each solib_ops can
work side by side and rocm_solib_ops won't need to care about the host
solib_ops.
This change starts by making program_space::m_solib_ops a vector of
solib_ops_up instead of a single solib_ops_up, and it propagates from
there.
program_space::set_solib_ops becomes program_space::add_solib_ops. I
put in the restriction that there can be only one instance of a given
kind of solib_ops in the vector (it wouldn't make sense to have two
svr4_solib_ops instances in there, it would likely be a bug).
Remove program_space::unset_solib_ops, but add
program_space::remove_solib_ops (to remove a single solib_ops) and
program_space::clear_solib_ops (to remove all solib_ops). Removing an
solib_ops now automatically removes all the solibs produced by that
solib_ops, to avoid having solibs with stale solib_ops backlinks.
Add program_space::find_solib_ops, which can be used to find the
instance of a given kind of solib_ops.
Then, the code in solib.c gets adapted to deal with the fact that there
might be multiple solib_ops. The logic is done on a case by case basis:
- update_solib_list: where we call open_symbol_file_object, iterate
over all solib_ops until we find one that knows how to find and open
the main executable
- also update_solib_list: where we fetch the list of current SOs from
the inferior and compare it against the list of SOs know to GDB,
iterate over all solib_ops and fetch current SOs from all of them.
When comparing the SOs fetched from the solib_ops with the SOs
known to GDB, also compare the solib_ops before considering it a
match.
- print_solib_list_table: to determine whether to print the namespace
column, iterate over all solib_ops until we find one for which
supports_namespaces returns true and num_active_namespaces returns
greater than 0. If the namespace column is printed and some solibs
are from an solib_ops that doesn't support namespaces, skip the
column.
- info_linker_namespace_command: iterate over all solib_ops. For each
solib_ops, print all namespaces.
- solib_keep_data_in_core: iterate over all solib_ops until one says
that the given memory range should be kept.
- clear_solib: call clear_solib on all solib_ops
- solib_create_inferior_hook: call create_inferior_hook on all
solib_ops
- in_solib_dynsym_resolve_code: iterate over all solib_ops until one
says that the given PC falls into dynsym resolve code
- update_solib_breakpoints: call update_breakpoints on all solib_ops
- handle_solib_event: call handle_event on all solib_ops. The event
normally concern only one of those solib_ops, but at the moment we
have no way to tell which solib_ops that is. Perhaps, in the future,
we can link bp_shlib_event breakpoints to which solib_ops the event
is for, and call handle_event just for that solib_ops. In the mean
time, it is expected that for solib_ops not concerned by the event,
calling handle_event will have no effect.
- reload_shared_libraries: call clear_solib on all solib_ops
- solib_linker_namespace_count: sum the number of active linker
namespace over all solib_ops. I don't know if this makes sense, but
there is no known case today of two solib_ops supporting namespaces
working side-by-side, so it's a theoretical problem for now.
With multiple solib_ops, the concept of
iterate_over_objfiles_in_search_order becomes a bit more complex. The
implementation is mostly based on suppositions on my part. The idea
implemented in this patch is to give priority to the solib_ops
responsible for an objfile when searching for a symbol. If you're
stopped debugging some GPU code and look up a variable, and there is a
variable by that name both on the host and GPU side, I believe it is
more likely that you are interested in the GPU one.
Since we're going to ask multiple solib_ops to search successively,
change solib_ops::iterate_over_objfiles_in_search_order to return a
bool, to indicate if the search was successful or if we should continue.
Then, change solib_ops::iterate_over_objfiles_in_search_order (the
implementation used by all except svr4_solib_ops) to only search the
objfiles from that solib_ops as well as (optionally) the main objfile
(program_space::symfile_object_file). The idea regarding the main
objfile is that it falls under the "linking domain" of the host-side
solib_ops, even though it wasn't produced by that solib_ops.
svr4_solib_ops has its own implementation of
iterate_over_objfiles_in_search_order, which does check the main
objfile.
Checking the main objfile is predicated by the HANDE_MAIN_OBJFILE
solib_ops constructor parameter, for which rocm_solib_ops passes false.
Then in program_space::iterate_over_objfiles_in_search_order, the search
strategy becomes:
- if there is a current objfile:
- if that objfile was contributed by an solib_ops:
- call that solib_ops' iterate_over_objfiles_in_search_order
- else:
- search the current objfile by itself
If we didn't find anything interesting, we continue the search by asking
other solib_ops to search:
- for all solib_ops except the one searched before (if any):
- call that solib_ops' iterate_over_objfiles_in_search_order
Finally, "orphan" objfiles (not mapped to any solib) haven't been
searched (except possibly the current objfile), so:
- for all objfile without an solib_ops backlink, except the current one (if any):
- search that objfile
Note that if the current objfile is the main one
(program_space::symfile_object_file), then we won't enter the host
solib_ops::iterate_over_objfiles_in_search_order in the first part,
because that objfile is not associated to any solib, and therefore to
any solib_ops. Instead, we will enter it in the first iteration of the
second part. This relies on the fact that the host solib_ops will
always be first in the solib_ops list, with complementary solib_ops
following. This is always true today, given the order in which
solib_ops instances are pushed. Otherwise, we could go look for the
solib_ops for which M_HANDLE_MAIN_OBJFILE is true, but it didn't seem
like it was worth the extra complexity.
I wrote the gdb.rocm/symbol-lookup.exp test to try to exercise this
symbol lookup order thing. The test program loads some shared libraries
and some ROCm code objects, then does some symbol lookups while stopped
in different places.
Finally, the goal of all this, rocm_solib_ops gets changed to not wrap a
host solib_ops anymore! rocm_solib_ops previously had to use
lm_info_svr4, to avoid confusing svr4_solib_ops. It doesn't have to
anymore, so introduce a simpler lm_info_rocm that just holds an address.
rocm_solib_ops no longer needs to implement a bunch of methods just to
forward the call to the host solib_ops, so remove them. In the methods
that rocm_solib_ops actually needs to implement, it no longer needs to
call the host ops, which simplifies things.
Things also get simpler at the points where we push a new
rocm_solib_ops.
Change-Id: I260cdc0dcb9b11f33040059f300719dacac63d69
Approved-By: Tom Tromey <tom@tromey.com>
---
gdb/infcmd.c | 16 +-
gdb/inferior.h | 6 +-
gdb/infrun.c | 4 +-
gdb/progspace.c | 92 ++++++-
gdb/progspace.h | 57 ++--
gdb/solib-aix.c | 2 +-
gdb/solib-darwin.c | 2 +-
gdb/solib-dsbt.c | 2 +-
gdb/solib-frv.c | 2 +-
gdb/solib-rocm.c | 165 +++---------
gdb/solib-svr4.c | 32 ++-
gdb/solib-svr4.h | 6 +-
gdb/solib-target.c | 2 +-
gdb/solib.c | 268 +++++++++++--------
gdb/solib.h | 30 ++-
gdb/target.c | 2 +-
gdb/testsuite/gdb.rocm/symbol-lookup.cpp | 320 +++++++++++++++++++++++
gdb/testsuite/gdb.rocm/symbol-lookup.exp | 243 +++++++++++++++++
gdb/windows-tdep.c | 2 +-
19 files changed, 955 insertions(+), 298 deletions(-)
create mode 100644 gdb/testsuite/gdb.rocm/symbol-lookup.cpp
create mode 100644 gdb/testsuite/gdb.rocm/symbol-lookup.exp
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index bd5dbb02f485..8f7f5eecc669 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -366,7 +366,7 @@ strip_bg_char (const char *args, int *bg_char_p)
/* See inferior.h. */
void
-post_create_inferior (int from_tty, bool set_pspace_solib_ops)
+post_create_inferior (int from_tty, bool push_arch_solib_ops)
{
/* Be sure we own the terminal in case write operations are performed. */
target_terminal::ours_for_output ();
@@ -397,10 +397,16 @@ post_create_inferior (int from_tty, bool set_pspace_solib_ops)
throw;
}
- if (set_pspace_solib_ops)
- current_program_space->set_solib_ops
- (gdbarch_make_solib_ops (current_inferior ()->arch (),
- current_program_space));
+ if (push_arch_solib_ops)
+ {
+ /* This is called when an inferior gains execution. Any solib_ops
+ from previous executions should have been cleared by
+ target_pre_inferior. */
+ gdb_assert (current_program_space->solib_ops ().empty ());
+ current_program_space->add_solib_ops
+ (gdbarch_make_solib_ops (current_inferior ()->arch (),
+ current_program_space));
+ }
{
const unsigned solib_add_generation
diff --git a/gdb/inferior.h b/gdb/inferior.h
index 9c031035a23d..19c5da76ca59 100644
--- a/gdb/inferior.h
+++ b/gdb/inferior.h
@@ -216,10 +216,10 @@ extern void setup_inferior (int from_tty);
means (running, attaching, connecting, et cetera). The target
should be stopped.
- If SET_PSPACE_SOLIB_OPS is true, initialize the program space's solib
- provider using the current inferior's architecture. */
+ If PUSH_ARCH_SOLIB_OPS is true, add an solib_ops to the current inferior's
+ program space provider using the current inferior's architecture. */
-extern void post_create_inferior (int from_tty, bool set_pspace_solib_ops);
+extern void post_create_inferior (int from_tty, bool push_arch_solib_ops);
extern void attach_command (const char *, int);
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 2edd6e0445b3..9dd4f7af3896 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1378,7 +1378,7 @@ follow_exec (ptid_t ptid, const char *exec_file_target)
we don't want those to be satisfied by the libraries of the
previous incarnation of this process. */
no_shared_libraries (current_program_space);
- current_program_space->unset_solib_ops ();
+ current_program_space->clear_solib_ops ();
inferior *execing_inferior = current_inferior ();
inferior *following_inferior;
@@ -1435,7 +1435,7 @@ follow_exec (ptid_t ptid, const char *exec_file_target)
registers. */
target_find_description ();
- following_inferior->pspace->set_solib_ops
+ following_inferior->pspace->add_solib_ops
(gdbarch_make_solib_ops (following_inferior->arch (),
following_inferior->pspace));
gdb::observers::inferior_execd.notify (execing_inferior, following_inferior);
diff --git a/gdb/progspace.c b/gdb/progspace.c
index 7023ccddc546..b513cfd6822a 100644
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -98,6 +98,42 @@ program_space::~program_space ()
/* See progspace.h. */
+void
+program_space::clear_solib_ops ()
+{
+ while (!m_solib_ops.empty ())
+ this->remove_solib_ops (*m_solib_ops.front ());
+}
+
+/* See progspace.h. */
+
+void
+program_space::remove_solib_ops (const struct solib_ops &ops)
+{
+ auto ops_it
+ = std::find_if (m_solib_ops.begin (), m_solib_ops.end (),
+ [&ops] (const auto &up) { return up.get () == &ops; });
+
+ gdb_assert (ops_it != m_solib_ops.end ());
+
+ /* Remove all solibs provided by the solib_ops being removed. */
+ for (auto solibs_it = m_solib_list.begin ();
+ solibs_it != m_solib_list.end ();)
+ {
+ if (&solibs_it->ops () != &ops)
+ {
+ ++solibs_it;
+ continue;
+ }
+
+ solibs_it = remove_solib (this, solibs_it);
+ }
+
+ m_solib_ops.erase (ops_it);
+}
+
+/* See progspace.h. */
+
bool
program_space::multi_objfile_p () const
{
@@ -124,16 +160,58 @@ void
program_space::iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb, objfile *current_objfile)
{
- if (m_solib_ops != nullptr)
- return m_solib_ops->iterate_over_objfiles_in_search_order
- (cb, current_objfile);
+ struct solib_ops *curr_ops = nullptr;
- if (current_objfile != nullptr && cb (current_objfile))
- return;
+ if (current_objfile != nullptr)
+ {
+ if (!current_objfile->solibs ().empty ())
+ {
+ /* If that objfile was created by an solib_ops, give a chance to that
+ solib_ops to iterate the relevant objfiles first.
+ If the objfile is associated to multiple struct solib, assume that
+ they are all from the same solib_ops (so, get the ops from the
+ first solib). */
+ curr_ops = ¤t_objfile->solibs ().front ()->ops ();
+
+ if (curr_ops->iterate_over_objfiles_in_search_order (cb,
+ current_objfile))
+ return;
+ }
+ else
+ {
+ /* Otherwise, search this objfile first. */
+ if (cb (current_objfile))
+ return;
+ }
+ }
+
+ /* We didn't find what we were looking for based on the current objfile's
+ context, so expand the search. Ask the other solib_ops. */
+ for (auto &solib_ops : this->solib_ops ())
+ {
+ if (solib_ops.get () == curr_ops)
+ continue;
+
+ if (solib_ops->iterate_over_objfiles_in_search_order (cb, nullptr))
+ return;
+ }
+
+ /* Finally, look in the orphan objfiles. */
for (auto &objfile : this->objfiles ())
- if (&objfile != current_objfile && cb (&objfile))
- return;
+ {
+ /* The current objfile (if any) was already handled above. */
+ if (&objfile == current_objfile)
+ continue;
+
+ /* If the obfile has any associated solibs, then it is not orphan, it has
+ been handled above. */
+ if (!objfile.solibs ().empty ())
+ continue;
+
+ if (cb (&objfile))
+ return;
+ }
}
/* See progspace.h. */
diff --git a/gdb/progspace.h b/gdb/progspace.h
index 21977747cb94..a5ef3deb337d 100644
--- a/gdb/progspace.h
+++ b/gdb/progspace.h
@@ -242,26 +242,51 @@ struct program_space
is outside all objfiles in this progspace. */
struct objfile *objfile_for_address (CORE_ADDR address);
- /* Set this program space's solib provider.
+ /* Add OPS as an solib provider for this program space.
- The solib provider must be unset prior to calling this method. */
- void set_solib_ops (solib_ops_up ops)
+ There must not be another instance of SOLIB_OPS_TYPE in the solib_ops list
+ of this program space.
+
+ Return a non-owning reference to the ops. */
+ template <typename solib_ops_type>
+ solib_ops_type &add_solib_ops (std::unique_ptr<solib_ops_type> ops)
{
- gdb_assert (m_solib_ops == nullptr);
- m_solib_ops = std::move (ops);
+ gdb_assert (this->find_solib_ops<solib_ops_type> () == nullptr);
+
+ auto &ret = *ops;
+ m_solib_ops.emplace_back (std::move (ops));
+ return ret;
};
- /* Unset and free this program space's solib provider. */
- void unset_solib_ops ()
- { m_solib_ops = nullptr; }
+ /* Clear the list of solib providers for this program space.
- /* Unset and return this program space's solib provider. */
- solib_ops_up release_solib_ops ()
- { return std::move (m_solib_ops); }
+ Remove all solibs from the program space. */
+ void clear_solib_ops ();
- /* Get this program space's solib provider. */
- struct solib_ops *solib_ops () const
- { return m_solib_ops.get (); }
+ /* Remove OPS from the list of solib_ops of this program space.
+
+ OPS must be present in the solib_ops list.
+
+ Remove all solibs created by OPS from the program space. */
+ void remove_solib_ops (const solib_ops &ops);
+
+ /* Return a view of the solib providers for this program space. */
+ std::vector<solib_ops_up> &solib_ops ()
+ { return m_solib_ops; }
+
+ /* Find an solib_ops instance of type SOLIB_OPS_TYPE.
+
+ Return nullptr if not found. */
+ template <typename solib_ops_type>
+ solib_ops_type *find_solib_ops ()
+ {
+ for (auto &ops : this->solib_ops ())
+ if (auto ret = dynamic_cast<solib_ops_type *> (ops.get ());
+ ret != nullptr)
+ return ret;
+
+ return nullptr;
+ }
/* Return the list of all the solibs in this program space. */
owning_intrusive_list<solib> &solibs ()
@@ -401,8 +426,8 @@ struct program_space
/* All known objfiles are kept in a linked list. */
owning_intrusive_list<objfile> m_objfiles_list;
- /* solib_ops implementation used to provide solibs in this program space. */
- solib_ops_up m_solib_ops;
+ /* solib_ops implementations used to provide solibs in this program space. */
+ std::vector<solib_ops_up> m_solib_ops;
/* List of shared objects mapped into this space. Managed by
solib.c. */
diff --git a/gdb/solib-aix.c b/gdb/solib-aix.c
index 28f69ed9cbb4..28bae833efbc 100644
--- a/gdb/solib-aix.c
+++ b/gdb/solib-aix.c
@@ -42,7 +42,7 @@ struct aix_solib_ops : public solib_ops
solib_ops_up
make_aix_solib_ops (program_space *pspace)
{
- return std::make_unique<aix_solib_ops> (pspace);
+ return std::make_unique<aix_solib_ops> (pspace, true);
}
/* Our private data in struct solib. */
diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c
index 07cd88d0e0c6..11ed0bb154e9 100644
--- a/gdb/solib-darwin.c
+++ b/gdb/solib-darwin.c
@@ -52,7 +52,7 @@ struct darwin_solib_ops : public solib_ops
solib_ops_up
make_darwin_solib_ops (program_space *pspace)
{
- return std::make_unique<darwin_solib_ops> (pspace);
+ return std::make_unique<darwin_solib_ops> (pspace, true);
}
struct gdb_dyld_image_info
diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
index 22b9a581546a..54cd4257d555 100644
--- a/gdb/solib-dsbt.c
+++ b/gdb/solib-dsbt.c
@@ -138,7 +138,7 @@ struct dsbt_solib_ops : public solib_ops
solib_ops_up
make_dsbt_solib_ops (program_space *pspace)
{
- return std::make_unique<dsbt_solib_ops> (pspace);
+ return std::make_unique<dsbt_solib_ops> (pspace, true);
}
/* Link map info to include in an allocated solib entry */
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index cff3c3ca0193..7b444ecb3ea3 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -46,7 +46,7 @@ struct frv_solib_ops : public solib_ops
solib_ops_up
make_frv_solib_ops (program_space *pspace)
{
- return std::make_unique<frv_solib_ops> (pspace);
+ return std::make_unique<frv_solib_ops> (pspace, true);
}
/* FR-V pointers are four bytes wide. */
diff --git a/gdb/solib-rocm.c b/gdb/solib-rocm.c
index 0a284dfb0a56..961a9a03f832 100644
--- a/gdb/solib-rocm.c
+++ b/gdb/solib-rocm.c
@@ -28,7 +28,6 @@
#include "linux-tdep.h"
#include "observable.h"
#include "solib.h"
-#include "solib-svr4.h"
#include "symfile.h"
#include "filesystem.h"
@@ -171,33 +170,34 @@ rocm_solib_fd_cache::close (target_fd fd, fileio_error *target_errno)
struct rocm_so
{
- rocm_so (const char *name, std::string unique_name, lm_info_svr4_up lm_info)
- : name (name),
+ rocm_so (std::string name, std::string unique_name, CORE_ADDR load_addr)
+ : name (std::move (name)),
unique_name (std::move (unique_name)),
- lm_info (std::move (lm_info))
+ load_addr (load_addr)
{}
std::string name, unique_name;
- lm_info_svr4_up lm_info;
+ CORE_ADDR load_addr;
+};
+
+/* Private data for ROCm solibs. */
+
+struct lm_info_rocm : public lm_info
+{
+ lm_info_rocm (CORE_ADDR load_addr)
+ : load_addr (load_addr)
+ {}
+
+ CORE_ADDR load_addr;
};
/* solib_ops for ROCm systems. */
struct rocm_solib_ops : public solib_ops
{
- /* HOST_OPS is the host solib_ops that rocm_solib_ops hijacks / wraps,
- in order to provide support for ROCm code objects. */
- explicit rocm_solib_ops (inferior *inf, solib_ops_up host_ops)
- : solib_ops (inf->pspace), m_host_ops (std::move (host_ops)),
- m_inf (inf), m_fd_cache (inf)
- {
- gdb_assert (m_host_ops != nullptr);
- gdb_assert (dynamic_cast<rocm_solib_ops *> (m_host_ops.get ()) == nullptr);
- }
-
- /* Release the host solib_ops. */
- solib_ops_up release_host_ops ()
- { return std::move (m_host_ops); }
+ explicit rocm_solib_ops (inferior *inf)
+ : solib_ops (inf->pspace, false), m_inf (inf), m_fd_cache (inf)
+ { }
/* The methods implemented by rocm_solib_ops. */
owning_intrusive_list<solib> current_sos () override;
@@ -210,60 +210,11 @@ struct rocm_solib_ops : public solib_ops
rocm_solib_target_inferior_created. */
void update_solib_list ();
- /* Implement the following methods just to forward the calls to the host
- solib_ops. We currently need to implement all the methods that
- svr4_solib_ops implements. */
- void clear_so (const solib &so) const override
- { return m_host_ops->clear_so (so); }
-
- void clear_solib (program_space *pspace) const override
- { return m_host_ops->clear_solib (pspace); }
-
- bool open_symbol_file_object (int from_tty) const override
- { return m_host_ops->open_symbol_file_object (from_tty); }
-
- bool in_dynsym_resolve_code (CORE_ADDR pc) const override
- { return m_host_ops->in_dynsym_resolve_code (pc); }
-
- bool same (const solib &gdb, const solib &inferior) const override
- { return m_host_ops->same (gdb, inferior); }
-
- bool keep_data_in_core (CORE_ADDR vaddr, unsigned long size) const override
- { return m_host_ops->keep_data_in_core (vaddr, size); }
-
- void update_breakpoints () const override
- { return m_host_ops->update_breakpoints (); }
-
- std::optional<CORE_ADDR> find_solib_addr (solib &so) const override
- { return m_host_ops->find_solib_addr (so); }
-
- bool supports_namespaces () const override
- { return true; }
-
- int find_solib_ns (const solib &so) const override
- { return m_host_ops->find_solib_ns (so); }
-
- int num_active_namespaces () const override
- { return m_host_ops->num_active_namespaces (); }
-
- std::vector<const solib *> get_solibs_in_ns (int nsid) const override
- { return m_host_ops->get_solibs_in_ns (nsid); }
-
- void iterate_over_objfiles_in_search_order
- (iterate_over_objfiles_in_search_order_cb_ftype cb,
- objfile *current_objfile) const override
- {
- return m_host_ops->iterate_over_objfiles_in_search_order
- (cb, current_objfile);
- }
-
private:
owning_intrusive_list<solib>
solibs_from_rocm_sos (const std::vector<rocm_so> &sos);
gdb_bfd_iovec_base *bfd_iovec_open (bfd *abfd);
- solib_ops_up m_host_ops;
-
/* Inferior this rocm_solib_ops is for. */
inferior *m_inf;
@@ -280,28 +231,16 @@ void
rocm_solib_ops::relocate_section_addresses (solib &so,
struct target_section *sec) const
{
- if (!is_amdgpu_arch (so.abfd.get ()))
- {
- m_host_ops->relocate_section_addresses (so, sec);
- return;
- }
+ gdb_assert (is_amdgpu_arch (so.abfd.get ()));
- auto *li = gdb::checked_static_cast<lm_info_svr4 *> (so.lm_info.get ());
- sec->addr = sec->addr + li->l_addr;
- sec->endaddr = sec->endaddr + li->l_addr;
+ auto &li = gdb::checked_static_cast<lm_info_rocm &> (*so.lm_info);
+ sec->addr = sec->addr + li.load_addr;
+ sec->endaddr = sec->endaddr + li.load_addr;
}
void
rocm_solib_ops::handle_event ()
{
- /* Since we sit on top of a host solib_ops, we might get called following an
- event concerning host libraries. We must therefore forward the call. If
- the event was for a ROCm code object, it will be a no-op. On the other hand
- if the event was for host libraries, rocm_update_solib_list will be
- essentially be a no-op (it will reload the same code object list as was
- previously loaded). */
- m_host_ops->handle_event ();
-
this->update_solib_list ();
}
@@ -313,7 +252,7 @@ rocm_solib_ops::solibs_from_rocm_sos (const std::vector<rocm_so> &sos)
owning_intrusive_list<solib> dst;
for (const rocm_so &so : sos)
- dst.emplace_back (std::make_unique<lm_info_svr4> (*so.lm_info),
+ dst.emplace_back (std::make_unique<lm_info_rocm> (so.load_addr),
so.unique_name, so.name, *this);
return dst;
@@ -325,22 +264,7 @@ rocm_solib_ops::solibs_from_rocm_sos (const std::vector<rocm_so> &sos)
owning_intrusive_list<solib>
rocm_solib_ops::current_sos ()
{
- /* First, retrieve the host-side shared library list. */
- owning_intrusive_list<solib> sos = m_host_ops->current_sos ();
-
- /* Then, the device-side shared library list. */
- if (m_solib_list.empty ())
- return sos;
-
- owning_intrusive_list<solib> dev_solibs = solibs_from_rocm_sos (m_solib_list);
-
- if (sos.empty ())
- return dev_solibs;
-
- /* Append our libraries to the end of the list. */
- sos.splice (std::move (dev_solibs));
-
- return sos;
+ return solibs_from_rocm_sos (m_solib_list);
}
namespace {
@@ -680,9 +604,7 @@ rocm_solib_ops::bfd_iovec_open (bfd *abfd)
gdb_bfd_ref_ptr
rocm_solib_ops::bfd_open (const char *pathname)
{
- /* Handle regular files with SVR4 open. */
- if (strstr (pathname, "://") == nullptr)
- return m_host_ops->bfd_open (pathname);
+ gdb_assert (strstr (pathname, "://") != nullptr);
auto open = [this] (bfd *nbfd)
{
@@ -769,7 +691,6 @@ void
rocm_solib_ops::create_inferior_hook (int from_tty)
{
m_solib_list.clear ();
- m_host_ops->create_inferior_hook (from_tty);
}
void
@@ -816,10 +737,6 @@ rocm_solib_ops::update_solib_list ()
gdb::unique_xmalloc_ptr<char> uri_bytes_holder (uri_bytes);
- /* Pass a dummy debug base. */
- lm_info_svr4_up li = std::make_unique<lm_info_svr4> (-1);
- li->l_addr = l_addr;
-
/* Generate a unique name so that code objects with the same URI but
different load addresses are seen by gdb core as different shared
objects. */
@@ -827,7 +744,7 @@ rocm_solib_ops::update_solib_list ()
= string_printf ("code_object_%ld", code_object_list[i].handle);
m_solib_list.emplace_back (uri_bytes, std::move (unique_name),
- std::move (li));
+ l_addr);
}
}
@@ -838,12 +755,10 @@ rocm_solib_target_inferior_created (inferior *inf)
if (inf->vfork_parent != nullptr)
return;
- auto prev_ops = inf->pspace->release_solib_ops ();
- auto rocm_ops = std::make_unique<rocm_solib_ops> (inf, std::move (prev_ops));
- inf->pspace->set_solib_ops (std::move (rocm_ops));
+ auto &rocm_ops
+ = inf->pspace->add_solib_ops (std::make_unique<rocm_solib_ops> (inf));
- gdb::checked_static_cast<rocm_solib_ops *>
- (inf->pspace->solib_ops ())->update_solib_list ();
+ rocm_ops.update_solib_list ();
/* Force GDB to reload the solibs. */
inf->pspace->clear_solib_cache ();
@@ -858,11 +773,8 @@ rocm_solib_target_inferior_execd (inferior *exec_inf, inferior *follow_inf)
if (get_amd_dbgapi_process_id (follow_inf) == AMD_DBGAPI_PROCESS_NONE)
return;
- auto pspace = follow_inf->pspace;
- auto prev_ops = pspace->release_solib_ops ();
- auto rocm_ops
- = std::make_unique<rocm_solib_ops> (follow_inf, std::move (prev_ops));
- pspace->set_solib_ops (std::move (rocm_ops));
+ follow_inf->pspace->add_solib_ops
+ (std::make_unique<rocm_solib_ops> (follow_inf));
}
static void
@@ -872,14 +784,13 @@ rocm_solib_target_inferior_forked (inferior *parent_inf, inferior *child_inf,
{
if (detach_on_fork && follow_child && fork_kind == TARGET_WAITKIND_FORKED)
{
- /* In this particular configuration, infrun's follow_fork_inferior
- function moves the parent pspace to the child directly. Remove the
- existing rocm_solib_ops from the child and restore the host solib_ops,
- to make it look like a brand new pspace. */
- auto rocm_ops_holder = child_inf->pspace->release_solib_ops ();
- auto rocm_ops
- = gdb::checked_static_cast<rocm_solib_ops *> (rocm_ops_holder.get ());
- child_inf->pspace->set_solib_ops (rocm_ops->release_host_ops ());
+ /* In this particular configuration, infrun's follow_fork_inferior moves
+ the parent pspace to the child directly. Remove the existing rocm_solib_ops
+ from the child and restore the host solib_ops, to make it look like a
+ brand new pspace. */
+ auto rocm_ops = child_inf->pspace->find_solib_ops<rocm_solib_ops> ();
+ gdb_assert (rocm_ops != nullptr);
+ child_inf->pspace->remove_solib_ops (*rocm_ops);
}
}
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index 33fb6e3cd970..04000f6797ed 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -3639,7 +3639,7 @@ find_debug_base_for_solib (const solib *solib)
stay in the same namespace as that file. Otherwise, we only consider
the initial namespace. */
-void
+bool
svr4_solib_ops::iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb,
objfile *current_objfile) const
@@ -3665,7 +3665,7 @@ svr4_solib_ops::iterate_over_objfiles_in_search_order
{
checked_current_objfile = true;
if (cb (current_objfile))
- return;
+ return true;
}
}
@@ -3686,13 +3686,25 @@ svr4_solib_ops::iterate_over_objfiles_in_search_order
if (checked_current_objfile && &objfile == current_objfile)
continue;
- /* Try to determine the namespace into which objfile was loaded.
-
- If we fail, e.g. for manually added symbol files or for the main
- executable, we assume that they were added to the initial
- namespace. */
const solib *solib = find_one_solib_for_objfile (&objfile);
- CORE_ADDR solib_base = find_debug_base_for_solib (solib);
+ CORE_ADDR solib_base = 0;
+
+ if (solib != nullptr)
+ {
+ /* Skip objfiles provided by other solib_ops. */
+ if (&solib->ops () != this)
+ continue;
+
+ solib_base = find_debug_base_for_solib (solib);
+ }
+ else if (&objfile != m_pspace->symfile_object_file)
+ {
+ /* Objfiles not associated to an solib_ops are handled in the
+ program_space method. The main objfile is an exception to this,
+ because it is part of the SVR4 domain. */
+ continue;
+ }
+
if (solib_base == 0)
solib_base = default_debug_base;
@@ -3701,8 +3713,10 @@ svr4_solib_ops::iterate_over_objfiles_in_search_order
continue;
if (cb (&objfile))
- return;
+ return true;
}
+
+ return false;
}
std::optional<CORE_ADDR>
diff --git a/gdb/solib-svr4.h b/gdb/solib-svr4.h
index d7f58a76224d..69b79d051d3f 100644
--- a/gdb/solib-svr4.h
+++ b/gdb/solib-svr4.h
@@ -94,7 +94,9 @@ enum probe_action
struct svr4_solib_ops : public solib_ops
{
- using solib_ops::solib_ops;
+ explicit svr4_solib_ops (program_space *pspace)
+ : solib_ops (pspace, true)
+ {}
void relocate_section_addresses (solib &so, target_section *) const override;
void clear_so (const solib &so) const override;
@@ -112,7 +114,7 @@ struct svr4_solib_ops : public solib_ops
int find_solib_ns (const solib &so) const override;
int num_active_namespaces () const override;
std::vector<const solib *> get_solibs_in_ns (int nsid) const override;
- void iterate_over_objfiles_in_search_order
+ bool iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb,
objfile *current_objfile) const override;
diff --git a/gdb/solib-target.c b/gdb/solib-target.c
index 0df8c6048aef..28558a03f5ba 100644
--- a/gdb/solib-target.c
+++ b/gdb/solib-target.c
@@ -390,5 +390,5 @@ target_solib_ops::in_dynsym_resolve_code (CORE_ADDR pc) const
solib_ops_up
make_target_solib_ops (program_space *pspace)
{
- return std::make_unique<target_solib_ops> (pspace);
+ return std::make_unique<target_solib_ops> (pspace, true);
}
diff --git a/gdb/solib.c b/gdb/solib.c
index d2ae598815a5..3b35a075f45d 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -21,6 +21,7 @@
#include <fcntl.h>
#include "exceptions.h"
#include "extract-store-integer.h"
+#include "progspace.h"
#include "symtab.h"
#include "bfd.h"
#include "build-id.h"
@@ -445,17 +446,38 @@ solib_ops::bfd_open (const char *pathname)
/* See solib.h. */
-void
+bool
solib_ops::iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb,
objfile *current_objfile) const
{
if (current_objfile != nullptr && cb (current_objfile))
- return;
+ return true;
for (objfile &objfile : m_pspace->objfiles ())
- if (&objfile != current_objfile && cb (&objfile))
- return;
+ {
+ /* The current objfile, if any, was handled above. */
+ if (current_objfile == &objfile)
+ continue;
+
+ /* Call CB on OBJFILE if either:
+
+ - OBJFILE was provided by this solib_ops, or
+ - this is the main objfile and M_HANDLE_MAIN_OBJFILE is true
+ */
+ bool is_from_this = (!objfile.solibs ().empty ()
+ && &objfile.solibs ().front ()->ops () == this);
+ bool is_main_handled_by_this = (&objfile == m_pspace->symfile_object_file
+ && m_handle_main_objfile);
+
+ if (!is_from_this && !is_main_handled_by_this)
+ continue;
+
+ if (cb (&objfile))
+ return true;
+ }
+
+ return false;
}
/* Given a pointer to one of the shared objects in our list of mapped
@@ -688,14 +710,9 @@ notify_solib_unloaded (program_space *pspace, const solib &so,
gdb::observers::solib_unloaded.notify (pspace, so, still_in_use, silent);
}
-/* Remove solib *SOLIB_IT from PSPACE.
+/* See solib.h. */
- Remove the corresponding objfiles and target sections.
-
- Return an iterator to the next solib in PSPACE's solib list, helping to
- continue iterating. */
-
-static owning_intrusive_list<solib>::iterator
+owning_intrusive_list<solib>::iterator
remove_solib (program_space *pspace,
owning_intrusive_list<solib>::iterator solib_it)
{
@@ -730,11 +747,6 @@ remove_solib (program_space *pspace,
void
update_solib_list (int from_tty)
{
- solib_ops *ops = current_program_space->solib_ops ();
-
- if (ops == nullptr)
- return;
-
/* We can reach here due to changing solib-search-path or the
sysroot, before having any inferior. */
if (target_has_execution () && inferior_ptid != null_ptid)
@@ -749,7 +761,9 @@ update_solib_list (int from_tty)
{
try
{
- ops->open_symbol_file_object (from_tty);
+ for (const auto &ops : current_program_space->solib_ops ())
+ if (ops->open_symbol_file_object (from_tty))
+ break;
}
catch (const gdb_exception_error &ex)
{
@@ -784,7 +798,10 @@ update_solib_list (int from_tty)
the time we're done walking GDB's list, the inferior's list
contains only the new shared objects, which we then add. */
- owning_intrusive_list<solib> inferior = ops->current_sos ();
+ owning_intrusive_list<solib> inferior;
+ for (auto &ops : current_program_space->solib_ops ())
+ inferior.splice (ops->current_sos ());
+
owning_intrusive_list<solib>::iterator gdb_iter
= current_program_space->solibs ().begin ();
while (gdb_iter != current_program_space->solibs ().end ())
@@ -794,8 +811,13 @@ update_solib_list (int from_tty)
/* Check to see whether the shared object *gdb also appears in
the inferior's current list. */
for (; inferior_iter != inferior.end (); ++inferior_iter)
- if (ops->same (*gdb_iter, *inferior_iter))
- break;
+ {
+ if (&gdb_iter->ops () != &inferior_iter->ops ())
+ continue;
+
+ if (gdb_iter->ops ().same (*gdb_iter, *inferior_iter))
+ break;
+ }
/* If the shared object appears on the inferior's list too, then
it's still loaded, so we don't need to do anything. Delete
@@ -1012,25 +1034,28 @@ print_solib_list_table (std::vector<const solib *> solib_list,
gdbarch *gdbarch = current_inferior ()->arch ();
/* "0x", a little whitespace, and two hex digits per byte of pointers. */
int addr_width = 4 + (gdbarch_ptr_bit (gdbarch) / 4);
- const solib_ops *ops = current_program_space->solib_ops ();
struct ui_out *uiout = current_uiout;
bool so_missing_debug_info = false;
- if (ops == nullptr)
- return;
+ /* The conditions for this command to print solib namespaces:
- /* There are 3 conditions for this command to print solib namespaces,
- first PRINT_NAMESPACE has to be true, second the solib_ops has to
- support multiple namespaces, and third there must be more than one
- active namespace. Fold all these into the PRINT_NAMESPACE condition. */
- print_namespace = (print_namespace
- && ops != nullptr
- && ops->supports_namespaces ()
- && ops->num_active_namespaces () > 1);
+ - PRINT_NAMESPACE has to be true
+ - at least one solib_ops has to have more than one active namespace
- int num_cols = 4;
+ Fold these into the PRINT_NAMESPACE condition. */
if (print_namespace)
- num_cols++;
+ {
+ print_namespace = false;
+
+ for (auto &ops : current_program_space->solib_ops ())
+ if (ops->supports_namespaces () && ops->num_active_namespaces () > 1)
+ {
+ print_namespace = true;
+ break;
+ }
+ }
+
+ int num_cols = print_namespace ? 5 : 4;
{
ui_out_emit_table table_emitter (uiout, num_cols, solib_list.size (),
@@ -1068,7 +1093,11 @@ print_solib_list_table (std::vector<const solib *> solib_list,
{
try
{
- uiout->field_fmt ("namespace", "%d", ops->find_solib_ns (*so));
+ if (so->ops ().supports_namespaces ())
+ uiout->field_fmt ("namespace", "%d",
+ so->ops ().find_solib_ns (*so));
+ else
+ uiout->field_skip ("namespace");
}
catch (const gdb_exception_error &er)
{
@@ -1151,81 +1180,92 @@ info_sharedlibrary_command (const char *pattern, int from_tty)
static void
info_linker_namespace_command (const char *pattern, int from_tty)
{
- const solib_ops *ops = current_program_space->solib_ops ();
-
- /* This command only really makes sense for inferiors that support
- linker namespaces, so we can leave early. */
- if (ops == nullptr || !ops->supports_namespaces ())
- error (_("Current inferior does not support linker namespaces. "
- "Use \"info sharedlibrary\" instead."));
-
- struct ui_out *uiout = current_uiout;
- std::vector<std::pair<int, std::vector<const solib *>>> all_solibs_to_print;
-
pattern = skip_spaces (pattern);
- if (pattern == nullptr || pattern[0] == '\0')
- {
- uiout->message (_("There are %d linker namespaces loaded.\n"),
- ops->num_active_namespaces ());
+ /* Will be set to true if at least one solib_ops in the program space
+ supports namespaces. */
+ bool one_solib_ops_supports_namespaces = false;
- int printed = 0;
- for (int i = 0; printed < ops->num_active_namespaces (); i++)
+ for (auto &ops : current_program_space->solib_ops ())
+ {
+ if (!ops->supports_namespaces ())
+ continue;
+
+ one_solib_ops_supports_namespaces = true;
+
+ struct ui_out *uiout = current_uiout;
+ std::vector<std::pair<int, std::vector<const solib *>>>
+ all_solibs_to_print;
+
+ if (pattern == nullptr || pattern[0] == '\0')
{
- std::vector<const solib *> solibs_to_print
- = ops->get_solibs_in_ns (i);
- if (solibs_to_print.size () > 0)
+ /* The output here will be awkward if multiple solib_ops support
+ namespaces, but it's just theoretical for now, so don't bother
+ trying to do anything fancier. */
+ uiout->message (_("There are %d linker namespaces loaded.\n"),
+ ops->num_active_namespaces ());
+
+ int printed = 0;
+ for (int i = 0; printed < ops->num_active_namespaces (); i++)
{
- all_solibs_to_print.push_back (std::make_pair
- (i, solibs_to_print));
- printed++;
+ std::vector<const solib *> solibs_to_print
+ = ops->get_solibs_in_ns (i);
+ if (solibs_to_print.size () > 0)
+ {
+ all_solibs_to_print.push_back (std::make_pair
+ (i, solibs_to_print));
+ printed++;
+ }
}
}
- }
- else
- {
- int ns;
- /* Check if the pattern includes the optional [[ and ]] decorators.
- To match multiple occurrences, '+' needs to be escaped, and every
- escape sequence must be doubled to survive the compiler pass. */
- re_comp ("^\\[\\[[0-9]\\+\\]\\]$");
- if (re_exec (pattern))
- ns = strtol (pattern + 2, nullptr, 10);
else
{
- char *end = nullptr;
- ns = strtol (pattern, &end, 10);
- if (end[0] != '\0')
- error (_("Invalid linker namespace identifier: %s"), pattern);
+ int ns;
+ /* Check if the pattern includes the optional [[ and ]] decorators.
+ To match multiple occurrences, '+' needs to be escaped, and every
+ escape sequence must be doubled to survive the compiler pass. */
+ re_comp ("^\\[\\[[0-9]\\+\\]\\]$");
+ if (re_exec (pattern))
+ ns = strtol (pattern + 2, nullptr, 10);
+ else
+ {
+ char *end = nullptr;
+ ns = strtol (pattern, &end, 10);
+ if (end[0] != '\0')
+ error (_("Invalid linker namespace identifier: %s"), pattern);
+ }
+
+ all_solibs_to_print.push_back
+ (std::make_pair (ns, ops->get_solibs_in_ns (ns)));
}
- all_solibs_to_print.push_back
- (std::make_pair (ns, ops->get_solibs_in_ns (ns)));
- }
-
- for (const auto &[ns, solibs_to_print] : all_solibs_to_print)
- {
- uiout->message ("\n");
-
- if (solibs_to_print.size () == 0)
+ for (const auto &[ns, solibs_to_print] : all_solibs_to_print)
{
- uiout->message (_("Linker namespace %d is not active.\n"), ns);
- /* If we got here, a specific namespace was requested, so there
- will only be one vector. We can leave early. */
- break;
+ uiout->message ("\n");
+
+ if (solibs_to_print.size () == 0)
+ {
+ uiout->message (_("Linker namespace %d is not active.\n"), ns);
+ /* If we got here, a specific namespace was requested, so there
+ will only be one vector. We can leave early. */
+ break;
+ }
+
+ if (solibs_to_print.size () == 1)
+ uiout->message
+ (_("1 library loaded in linker namespace %d:\n"), ns);
+ else
+ uiout->message
+ (_("%zu libraries loaded in linker namespace %d:\n"),
+ solibs_to_print.size (), ns);
+
+ print_solib_list_table (solibs_to_print, false);
}
-
- if (solibs_to_print.size () == 1)
- uiout->message
- (_("1 library loaded in linker namespace %d:\n"), ns);
- else
- uiout->message
- (_("%zu libraries loaded in linker namespace %d:\n"),
- solibs_to_print.size (), ns);
-
-
- print_solib_list_table (solibs_to_print, false);
}
+
+ if (!one_solib_ops_supports_namespaces)
+ error (_("Current inferior does not support linker namespaces. "
+ "Use \"info sharedlibrary\" instead."));
}
/* See solib.h. */
@@ -1273,9 +1313,11 @@ solib_ops::same (const solib &a, const solib &b) const
bool
solib_keep_data_in_core (CORE_ADDR vaddr, unsigned long size)
{
- const solib_ops *ops = current_program_space->solib_ops ();
+ for (const auto &ops : current_program_space->solib_ops ())
+ if (ops->keep_data_in_core (vaddr, size))
+ return true;
- return ops != nullptr && ops->keep_data_in_core (vaddr, size);
+ return false;
}
/* See solib.h. */
@@ -1294,8 +1336,7 @@ clear_solib (program_space *pspace)
pspace->solibs ().clear ();
- if (const solib_ops *ops = pspace->solib_ops ();
- ops != nullptr)
+ for (const auto &ops : pspace->solib_ops ())
ops->clear_solib (pspace);
}
@@ -1307,8 +1348,7 @@ clear_solib (program_space *pspace)
void
solib_create_inferior_hook (int from_tty)
{
- if (solib_ops *ops = current_program_space->solib_ops ();
- ops != nullptr)
+ for (const auto &ops : current_program_space->solib_ops ())
ops->create_inferior_hook (from_tty);
}
@@ -1317,9 +1357,11 @@ solib_create_inferior_hook (int from_tty)
bool
in_solib_dynsym_resolve_code (CORE_ADDR pc)
{
- const solib_ops *ops = current_program_space->solib_ops ();
+ for (const auto &ops : current_program_space->solib_ops ())
+ if (ops->in_dynsym_resolve_code (pc))
+ return true;
- return ops != nullptr && ops->in_dynsym_resolve_code (pc);
+ return false;
}
/* Implements the "sharedlibrary" command. */
@@ -1361,9 +1403,7 @@ no_shared_libraries_command (const char *ignored, int from_tty)
void
update_solib_breakpoints (void)
{
- const solib_ops *ops = current_program_space->solib_ops ();
-
- if (ops != nullptr)
+ for (const auto &ops : current_program_space->solib_ops ())
ops->update_breakpoints ();
}
@@ -1372,8 +1412,7 @@ update_solib_breakpoints (void)
void
handle_solib_event (void)
{
- if (solib_ops *ops = current_program_space->solib_ops ();
- ops != nullptr)
+ for (const auto &ops : current_program_space->solib_ops ())
ops->handle_event ();
current_inferior ()->pspace->clear_solib_cache ();
@@ -1471,8 +1510,7 @@ reload_shared_libraries (const char *ignored, int from_tty,
{
/* Reset or free private data structures not associated with
solib entries. */
- if (const solib_ops *ops = current_program_space->solib_ops ();
- ops != nullptr)
+ for (const auto &ops : current_program_space->solib_ops ())
ops->clear_solib (current_program_space);
/* Remove any previous solib event breakpoint. This is usually
@@ -1804,11 +1842,13 @@ remove_user_added_objfile (struct objfile *objfile)
int
solib_linker_namespace_count (program_space *pspace)
{
- if (const auto ops = pspace->solib_ops (); ops != nullptr
- && ops->supports_namespaces ())
- return ops->num_active_namespaces ();
+ int num_active_namespaces = 0;
- return 0;
+ for (const auto &ops : pspace->solib_ops ())
+ if (ops->supports_namespaces ())
+ num_active_namespaces += ops->num_active_namespaces ();
+
+ return num_active_namespaces;
}
/* Implementation of the linker_namespace convenience variable.
diff --git a/gdb/solib.h b/gdb/solib.h
index 5b5049f53435..57af984a1ae3 100644
--- a/gdb/solib.h
+++ b/gdb/solib.h
@@ -145,8 +145,8 @@ using iterate_over_objfiles_in_search_order_cb_ftype
struct solib_ops
{
- explicit solib_ops (program_space *pspace)
- : m_pspace (pspace)
+ solib_ops (program_space *pspace, bool handle_main_objfile)
+ : m_pspace (pspace), m_handle_main_objfile (handle_main_objfile)
{}
virtual ~solib_ops () = default;
@@ -276,21 +276,29 @@ struct solib_ops
virtual std::vector<const solib *> get_solibs_in_ns (int ns) const
{ gdb_assert_not_reached ("namespaces not supported"); }
- /* Iterate over all objfiles of the program space in the order that makes the
- most sense for the architecture to make global symbol searches.
+ /* Iterate over all objfiles associated to this solib_ops in the order that
+ makes the most sense for the architecture to make global symbol searches.
+
+ If M_HANDLE_MAIN_OBJFILE is set, also iterate over the "main" objfile of
+ the program space (program_space::symfile_object_file).
CB is a callback function passed an objfile to be searched. The iteration
stops if this function returns true.
If not nullptr, CURRENT_OBJFILE corresponds to the objfile being inspected
- when the symbol search was requested. */
- virtual void iterate_over_objfiles_in_search_order
+ when the symbol search was requested. If not nullptr, it is guaranteed
+ that CURRENT_OBJFILE is associated to this solib_ops. */
+ virtual bool iterate_over_objfiles_in_search_order
(iterate_over_objfiles_in_search_order_cb_ftype cb,
objfile *current_objfile) const;
protected:
/* The program space for which this solib_ops was created. */
program_space *m_pspace;
+
+ /* Whether this solib_ops should handle the main objfile
+ (pspace->symfile_object_file) in iterate_over_objfiles_in_search_order. */
+ bool m_handle_main_objfile;
};
/* A unique pointer to an solib_ops. */
@@ -355,6 +363,16 @@ extern bool in_solib_dynsym_resolve_code (CORE_ADDR);
extern void no_shared_libraries (program_space *pspace);
+/* Remove solib *SOLIB_IT from PSPACE.
+
+ Remove the corresponding objfiles and target sections.
+
+ Return an iterator to the next solib in PSPACE's solib list, helping to
+ continue iterating. */
+
+extern owning_intrusive_list<solib>::iterator remove_solib
+ (program_space *pspace, owning_intrusive_list<solib>::iterator solib_it);
+
/* Synchronize GDB's shared object list with inferior's.
Extract the list of currently loaded shared objects from the
diff --git a/gdb/target.c b/gdb/target.c
index 5d937f3ae858..e680943d5b27 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -2482,7 +2482,7 @@ target_pre_inferior ()
if (!gdbarch_has_global_solist (current_inferior ()->arch ()))
{
no_shared_libraries (current_program_space);
- current_program_space->unset_solib_ops ();
+ current_program_space->clear_solib_ops ();
invalidate_target_mem_regions ();
diff --git a/gdb/testsuite/gdb.rocm/symbol-lookup.cpp b/gdb/testsuite/gdb.rocm/symbol-lookup.cpp
new file mode 100644
index 000000000000..7de2f6a34992
--- /dev/null
+++ b/gdb/testsuite/gdb.rocm/symbol-lookup.cpp
@@ -0,0 +1,320 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2022-2025 Free Software Foundation, Inc.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#if defined(SHARED_LIB_1)
+
+extern "C"
+{
+
+ using shared_lib_1_t = int;
+
+ void func_host_shared_lib_1 (shared_lib_1_t)
+ {
+ }
+
+ void func_host_shared_lib (shared_lib_1_t)
+ {
+ }
+
+ void func_1 (shared_lib_1_t)
+ {
+ }
+
+ void func_main_shared_lib_1 (shared_lib_1_t)
+ {
+ }
+
+} /* extern "C" */
+
+#elif defined(SHARED_LIB_2)
+
+extern "C"
+{
+
+ using shared_lib_2_t = int;
+
+ void func_host_shared_lib_2 (shared_lib_2_t)
+ {
+ }
+
+ void func_host_shared_lib (shared_lib_2_t)
+ {
+ }
+
+ void func_2 (shared_lib_2_t)
+ {
+ }
+
+ void func_main_shared_lib_2 (shared_lib_2_t)
+ {
+ }
+
+} /* extern "C" */
+
+#elif defined(CODE_OBJECT_1)
+
+extern "C"
+{
+
+ using code_object_1_t = int;
+
+ __global__ void func_device_code_object_1 (code_object_1_t)
+ {
+ }
+
+ __global__ void func_device_code_object (code_object_1_t)
+ {
+ }
+
+ __global__ void func_1 (code_object_1_t)
+ {
+ }
+
+ __global__ void func_main_code_object_1 (code_object_1_t)
+ {
+ }
+
+} /* extern "C" */
+
+#elif defined(CODE_OBJECT_2)
+
+extern "C"
+{
+
+ using code_object_2_t = int;
+
+ __global__ void func_device_code_object_2 (code_object_2_t)
+ {
+ }
+
+ __global__ void func_device_code_object (code_object_2_t)
+ {
+ }
+
+ __global__ void func_2 (code_object_2_t)
+ {
+ }
+
+ __global__ void func_main_code_object_2 (code_object_2_t)
+ {
+ }
+
+} /* extern "C" */
+
+#else
+
+#include <dlfcn.h>
+#include <iostream>
+#include <memory>
+#include <stdexcept>
+#include "hip/hip_runtime.h"
+
+/* This `extern "C"` is necessary to make the test work, due to an oddity in how
+ GDB computes the demangled names. Without it, the compiler includes a
+ DW_AT_linkage_name in the DW_TAG_subprogram DIE, causing GDB to use that to
+ compute the symbol's demangled name. The symbols would then appear as
+ `func_main(int)` rather than `func_main(main_program_t)`, making it
+ impossible to differentiate them. With `extern "C"`, GDB has to construct
+ the demangled name from the DIE structure, resulting in the expected
+ `func_main(main_program_t)`. */
+
+extern "C"
+{
+
+ using main_program_t = int;
+
+ void func_main (main_program_t)
+ {
+ }
+
+ void func_main_shared_lib_1 (main_program_t)
+ {
+ }
+
+ void func_main_shared_lib_2 (main_program_t)
+ {
+ }
+
+ void func_main_code_object_1 (main_program_t)
+ {
+ }
+
+ void func_main_code_object_2 (main_program_t)
+ {
+ }
+
+} /* extern "C" */
+
+namespace
+{
+
+void
+throw_from_hip_error (const std::string &prefix, hipError_t error)
+{
+ throw std::runtime_error (prefix + ": " + hipGetErrorString (error));
+}
+
+void
+warn_from_hip_error (const std::string &prefix, hipError_t error)
+{
+ std::cerr << prefix + ": " + hipGetErrorString (error) << std::endl;
+}
+
+struct hip_module_unloader
+{
+ void operator() (hipModule_t module) const
+ {
+ hipError_t error = hipModuleUnload (module);
+
+ if (error != HIP_SUCCESS)
+ warn_from_hip_error ("Failed to unload HIP module", error);
+ }
+};
+
+using hip_module_up
+ = std::unique_ptr<std::remove_pointer_t<hipModule_t>, hip_module_unloader>;
+
+hip_module_up
+load_hip_module (const char *module_path)
+{
+ hipModule_t module;
+ hipError_t error = hipModuleLoad (&module, module_path);
+
+ if (error != HIP_SUCCESS)
+ throw_from_hip_error ((std::string ("Failed to load HIP module ")
+ + module_path),
+ error);
+
+ return hip_module_up (module);
+}
+
+void
+throw_from_dlerror (const std::string &prefix)
+{
+ throw std::runtime_error (prefix + ": " + dlerror ());
+}
+
+void
+warn_from_dlerror (const std::string &prefix)
+{
+ std::cerr << prefix + ": " + dlerror () << std::endl;
+}
+
+struct dlcloser
+{
+ void operator() (void *lib)
+ {
+ int ret = dlclose (lib);
+
+ if (ret != 0)
+ warn_from_dlerror ("Failed to dlclose");
+ }
+};
+
+using dl_up = std::unique_ptr<void, dlcloser>;
+
+dl_up
+load_shared_lib (const char *lib_path)
+{
+ void *lib = dlopen (lib_path, RTLD_NOW);
+
+ if (lib == nullptr)
+ throw_from_dlerror (std::string ("Failed to dlopen ") + lib_path);
+
+ return dl_up (lib);
+}
+
+using host_function_t = void (*) (int);
+
+host_function_t
+lookup_symbol (dl_up &dl, const char *sym_name)
+{
+ void *sym = dlsym (dl.get (), sym_name);
+
+ if (sym == nullptr)
+ throw_from_dlerror (std::string ("Failed to dlsym ") + sym_name);
+
+ return reinterpret_cast<host_function_t> (sym);
+}
+
+hipFunction_t
+lookup_symbol (hip_module_up &mod, const char *sym_name)
+{
+ hipFunction_t func;
+ hipError_t error = hipModuleGetFunction (&func, mod.get (), sym_name);
+
+ if (error != HIP_SUCCESS)
+ throw_from_hip_error (std::string ("Failed to look up kernel ") + sym_name,
+ error);
+
+ return func;
+}
+
+void
+launch_kernel (hipFunction_t func)
+{
+ int arg = 2;
+ void *args[1] = { &arg };
+
+ hipError_t error = hipModuleLaunchKernel (func, 1, 1, 1, 1, 1, 1, 0, nullptr,
+ args, nullptr);
+
+ if (error != HIP_SUCCESS)
+ throw_from_hip_error ("Failed to launch kernel", error);
+
+ error = hipDeviceSynchronize ();
+
+ if (error != HIP_SUCCESS)
+ throw_from_hip_error ("Failed to sync", error);
+}
+
+} /* namespace */
+
+int
+main (int argc, const char **argv)
+{
+ if (argc != 5)
+ {
+ fprintf (stderr, "Usage: %s <shlib1> <shlib2> <hip1> <hip1>\n", argv[0]);
+ return 1;
+ }
+
+ dl_up shared_lib_1 = load_shared_lib (argv[1]);
+ dl_up shared_lib_2 = load_shared_lib (argv[2]);
+ hip_module_up hip_module_1 = load_hip_module (argv[3]);
+ hip_module_up hip_module_2 = load_hip_module (argv[4]);
+
+ host_function_t shared_lib_1_sym
+ = lookup_symbol (shared_lib_1, "func_host_shared_lib_1");
+ host_function_t shared_lib_2_sym
+ = lookup_symbol (shared_lib_2, "func_host_shared_lib_2");
+
+ hipFunction_t code_object_1_kernel
+ = lookup_symbol (hip_module_1, "func_device_code_object_1");
+ hipFunction_t code_object_2_kernel
+ = lookup_symbol (hip_module_2, "func_device_code_object_2");
+
+ func_main (0);
+ shared_lib_1_sym (0);
+ shared_lib_2_sym (0);
+ launch_kernel (code_object_1_kernel);
+ launch_kernel (code_object_2_kernel);
+
+ return 0;
+}
+
+#endif
diff --git a/gdb/testsuite/gdb.rocm/symbol-lookup.exp b/gdb/testsuite/gdb.rocm/symbol-lookup.exp
new file mode 100644
index 000000000000..1eb658a3e4c2
--- /dev/null
+++ b/gdb/testsuite/gdb.rocm/symbol-lookup.exp
@@ -0,0 +1,243 @@
+# Copyright 2025 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Test symbol lookup with multiple host shared libraries and ROCm code objects.
+#
+# This test verifies that GDB correctly resolves symbols based on where the
+# program is stopped. The following objfiles are in play:
+#
+# - the main program
+# - two host shared libraries
+# - two ROCm code objects
+#
+# The main program is separated from host shared libraries for the purpose of
+# this test because it is handled differently than shared libraries by the
+# iterate_over_objfiles_in_search_order methods.
+#
+# Each objfile defines functions with various levels of uniqueness:
+#
+# - func_main: unique to the main program
+# - func_host_shared_lib_N: unique to host shared library N
+# - func_device_code_object_N: unique to ROCm code object N
+# - func_host_shared_lib: defined in both host shared libraries
+# - func_device_code_object: defined in both ROCm code objects
+# - func_N: defined in host shared library N and ROCm code object N
+# - func_main_shared_lib_N: defined in the main program and host shared library N
+# - func_main_code_object_N: defined in the main program and ROCm code object N
+#
+# The functions have different signatures, to be able to tell them apart.
+#
+# The test stops at breakpoints in each objfile and verifies that symbol
+# lookups return the expected function. GDB gives priority to the current
+# objfile, and then objfiles from the current "solib provider", before
+# considering other loaded objfiles.
+
+load_lib rocm.exp
+
+standard_testfile .cpp
+
+require allow_hipcc_tests
+
+# Build the main program.
+if { [build_executable "failed to prepare" \
+ $testfile $srcfile {debug hip}] == -1 } {
+ return
+}
+
+# Return the path to shared library N.
+proc shared_lib_path { n } {
+ return [standard_output_file ${::testfile}_${n}.so]
+}
+
+# Return the path to code object N.
+proc code_object_path { n } {
+ return [standard_output_file ${::testfile}_${n}.co]
+}
+
+# Build the host shared libraries and ROCm code objects.
+foreach n {1 2} {
+ set shared_lib [shared_lib_path $n]
+ set code_object [code_object_path $n]
+
+ # Build the host shlib N
+ if { [gdb_compile_shlib $srcdir/$subdir/$srcfile $shared_lib \
+ [list debug additional_flags=-DSHARED_LIB_$n]] != "" } {
+ return
+ }
+
+ # Build the ROCm code object N
+ if { [gdb_compile $srcdir/$subdir/$srcfile $code_object object \
+ [list debug hip additional_flags=--genco additional_flags=-DCODE_OBJECT_$n]] != "" } {
+ return
+ }
+}
+
+# Verify symbol lookup results at the current stop location.
+#
+# Each parameter is a regex matching the expected parameter type in the
+# function signature. This parameter type is what allows us to confirm
+# that GDB found the expected version of the function.
+proc check_funcs { func_host_shared_lib func_device_code_object
+ func_1 func_2
+ func_main_shared_lib_1 func_main_shared_lib_2
+ func_main_code_object_1 func_main_code_object_2 } {
+ # Unique functions: only one definition exists, so lookup is unambiguous.
+ gdb_test "print func_main" "<func_main\\(main_program_t\\)>"
+ gdb_test "print func_host_shared_lib_1" "<func_host_shared_lib_1\\(shared_lib_1_t\\)>"
+ gdb_test "print func_host_shared_lib_2" "<func_host_shared_lib_2\\(shared_lib_2_t\\)>"
+ gdb_test "print func_device_code_object_1" "<func_device_code_object_1\\(code_object_1_t\\)>"
+ gdb_test "print func_device_code_object_2" "<func_device_code_object_2\\(code_object_2_t\\)>"
+
+ # Functions defined in either both host shlibs or both code objects.
+ gdb_test "print func_host_shared_lib" "<func_host_shared_lib\\($func_host_shared_lib\\)>"
+ gdb_test "print func_device_code_object" "<func_device_code_object\\($func_device_code_object\\)>"
+
+ # Functions defined in one host shlib and one code object.
+ gdb_test "print func_1" "<func_1\\($func_1\\)>"
+ gdb_test "print func_2" "<func_2\\($func_2\\)>"
+
+ # Functions defined in main program and one objfile.
+ gdb_test "print func_main_shared_lib_1" "<func_main_shared_lib_1\\($func_main_shared_lib_1\\)>"
+ gdb_test "print func_main_shared_lib_2" "<func_main_shared_lib_2\\($func_main_shared_lib_2\\)>"
+ gdb_test "print func_main_code_object_1" "<func_main_code_object_1\\($func_main_code_object_1\\)>"
+ gdb_test "print func_main_code_object_2" "<func_main_code_object_2\\($func_main_code_object_2\\)>"
+}
+
+proc do_test {} {
+ clean_restart
+ gdb_load $::binfile
+
+ set shared_lib_1 [shared_lib_path 1]
+ set shared_lib_2 [shared_lib_path 2]
+ set code_object_1 [code_object_path 1]
+ set code_object_2 [code_object_path 2]
+
+ gdb_test_no_output "set args $shared_lib_1 $shared_lib_2 $code_object_1 $code_object_2" \
+ "set args"
+
+ with_rocm_gpu_lock {
+ if ![runto_main] {
+ return
+ }
+
+ # Set a breakpoint in the main program after all libraries / code
+ # objects have been loaded, as well as one breakpoint in each objfile.
+ gdb_test "break func_main" \
+ "Breakpoint $::decimal at $::hex.*"
+ gdb_test "with breakpoint pending on -- break func_host_shared_lib_1" \
+ "Breakpoint $::decimal \\(func_host_shared_lib_1\\) pending."
+ gdb_test "with breakpoint pending on -- break func_host_shared_lib_2" \
+ "Breakpoint $::decimal \\(func_host_shared_lib_2\\) pending."
+ gdb_test "with breakpoint pending on -- break func_device_code_object_1" \
+ "Breakpoint $::decimal \\(func_device_code_object_1\\) pending."
+ gdb_test "with breakpoint pending on -- break func_device_code_object_2" \
+ "Breakpoint $::decimal \\(func_device_code_object_2\\) pending."
+
+ # Stop in main program. We expect:
+ # - func_host_shared_lib to resolve to either shared lib (no preference)
+ # - func_device_code_object to resolve to either code object (no preference)
+ # - func_1 to resolve to shared_lib_1 (current solib provider)
+ # - func_2 to resolve to shared_lib_2 (current solib provider)
+ # - func_main_* symbols to resolve to main program's version (current objfile)
+ with_test_prefix "main program" {
+ gdb_test "continue" "hit Breakpoint $::decimal, func_main .*"
+ check_funcs \
+ "shared_lib_._t" \
+ "code_object_._t" \
+ "shared_lib_1_t" \
+ "shared_lib_2_t" \
+ "main_program_t" \
+ "main_program_t" \
+ "main_program_t" \
+ "main_program_t"
+ }
+
+ # Stop in host shared library 1. We expect:
+ # - func_host_shared_lib to resolve to shared_lib_1's version (current objfile)
+ # - func_device_code_object to resolve to either code object (no preference)
+ # - func_1 to resolve to shared_lib_1's version (current objfile)
+ # - func_2 to resolve to shared_lib_2's version (current solib provider)
+ # - func_main_shared_lib_1 to resolve to shared_lib_1's version (current objfile)
+ # - func_main_shared_lib_2 to resolve to either main or shared_lib_2 (no preference)
+ # - func_main_code_object_1 to resolve to either main or code_object_1 (no preference)
+ # - func_main_code_object_2 to resolve to either main or code_object_2 (no preference)
+ with_test_prefix "host shared lib 1" {
+ gdb_test "continue" "hit Breakpoint $::decimal, func_host_shared_lib_1 .*"
+ check_funcs \
+ "shared_lib_1_t" \
+ "code_object_._t" \
+ "shared_lib_1_t" \
+ "shared_lib_2_t" \
+ "shared_lib_1_t" \
+ "(main_program_t|shared_lib_2_t)" \
+ "(main_program_t|code_object_1_t)" \
+ "(main_program_t|code_object_2_t)"
+ }
+
+ # Stop in host shared library 2. Similar logic but now shared_lib_2
+ # is the current objfile.
+ with_test_prefix "host shared lib 2" {
+ gdb_test "continue" "hit Breakpoint $::decimal, func_host_shared_lib_2 .*"
+ check_funcs \
+ "shared_lib_2_t" \
+ "code_object_._t" \
+ "shared_lib_1_t" \
+ "shared_lib_2_t" \
+ "(main_program_t|shared_lib_1_t)" \
+ "shared_lib_2_t" \
+ "(main_program_t|code_object_1_t)" \
+ "(main_program_t|code_object_2_t)"
+ }
+
+ # Stop in ROCm code object 1. We expect:
+ # - func_host_shared_lib to resolve to either shared lib (no preference)
+ # - func_device_code_object to resolve to code_object_1's version (current objfile)
+ # - func_1 to resolve to code_object_1's version (current objfile)
+ # - func_2 to resolve to code_object_2's version (current solib provider)
+ # - func_main_shared_lib_1 to resolve to either main or shared_lib_1 (no preference)
+ # - func_main_shared_lib_2 to resolve to either main or shared_lib_2 (no preference)
+ # - func_main_code_object_1 to resolve to code_object_1's version (current objfile)
+ # - func_main_code_object_2 to resolve to either main or code_object_2 (no preference)
+ with_test_prefix "device code object 1" {
+ gdb_test "continue" "hit Breakpoint $::decimal, func_device_code_object_1 .*"
+ check_funcs \
+ "shared_lib_._t" \
+ "code_object_1_t" \
+ "code_object_1_t" \
+ "code_object_2_t" \
+ "(main_program_t|shared_lib_1_t)" \
+ "(main_program_t|shared_lib_2_t)" \
+ "code_object_1_t" \
+ "(main_program_t|code_object_2_t)"
+ }
+
+ # Stop in ROCm code object 2. Similar logic but now code_object_2
+ # is the current objfile.
+ with_test_prefix "device code object 2" {
+ gdb_test "continue" "hit Breakpoint $::decimal, func_device_code_object_2 .*"
+ check_funcs \
+ "shared_lib_._t" \
+ "code_object_2_t" \
+ "code_object_1_t" \
+ "code_object_2_t" \
+ "(main_program_t|shared_lib_1_t)" \
+ "(main_program_t|shared_lib_2_t)" \
+ "(main_program_t|code_object_1_t)" \
+ "code_object_2_t"
+ }
+ }
+}
+
+do_test
diff --git a/gdb/windows-tdep.c b/gdb/windows-tdep.c
index d65e6e76faeb..2201c17818be 100644
--- a/gdb/windows-tdep.c
+++ b/gdb/windows-tdep.c
@@ -836,7 +836,7 @@ struct windows_solib_ops : target_solib_ops
static solib_ops_up
make_windows_solib_ops (program_space *pspace)
{
- return std::make_unique<windows_solib_ops> (pspace);
+ return std::make_unique<windows_solib_ops> (pspace, true);
}
/* Implement the "solib_create_inferior_hook" solib_ops method. */
--
2.54.0
^ permalink raw reply [flat|nested] 3+ messages in thread