Threads support.

8 files changed, 655 insertions, 30 deletions

diff --git a/gnu/usr.bin/binutils/gdb/Makefile.in b/gnu/usr.bin/binutils/gdb/Makefile.in
index f4b987185b5..040db280e42 100644
--- a/gnu/usr.bin/binutils/gdb/Makefile.in
+++ b/gnu/usr.bin/binutils/gdb/Makefile.in
@@ -643,6 +643,7 @@ bfd_target_h = bfd-target.h
 block_h = block.h
 breakpoint_h = breakpoint.h $(frame_h) $(value_h) $(gdb_events_h)
 bsd_kvm_h = bsd-kvm.h
+bsd_uthread_h = bsd-uthread.h
 buildsym_h = buildsym.h
 call_cmds_h = call-cmds.h
 charset_h = charset.h
@@ -1743,6 +1744,10 @@ breakpoint.o: breakpoint.c $(defs_h) $(symtab_h) $(frame_h) $(breakpoint_h) \
 bsd-kvm.o: bsd-kvm.c $(defs_h) $(cli_cmds_h) $(command_h) $(frame_h) \
 	$(regcache_h) $(target_h) $(value_h) $(gdbcore_h) $(gdb_assert_h) \
 	$(readline_h) $(bsd_kvm_h)
+bsd-uthread.o: bsd-uthread.c $(defs_h) $(gdbcore_h) $(gdbthread_h) \
+	$(inferior_h) $(objfiles_h) $(observer_h) $(regcache_h) $(solib_h) \
+	$(solist_h) $(symfile_h) $(target_h) $(gdb_assert_h) \
+	$(gdb_obstack_h) $(bsd_uthread_h)
 buildsym.o: buildsym.c $(defs_h) $(bfd_h) $(gdb_obstack_h) $(symtab_h) \
 	$(symfile_h) $(objfiles_h) $(gdbtypes_h) $(gdb_assert_h) \
 	$(complaints_h) $(gdb_string_h) $(expression_h) $(bcache_h) \
diff --git a/gnu/usr.bin/binutils/gdb/bsd-uthread.c b/gnu/usr.bin/binutils/gdb/bsd-uthread.c
new file mode 100644
index 00000000000..e626c49169b
--- /dev/null
+++ b/gnu/usr.bin/binutils/gdb/bsd-uthread.c
@@ -0,0 +1,516 @@
+/* BSD user-level threads support.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "gdbcore.h"
+#include "gdbthread.h"
+#include "inferior.h"
+#include "objfiles.h"
+#include "observer.h"
+#include "regcache.h"
+#include "solib.h"
+#include "solist.h"
+#include "symfile.h"
+#include "target.h"
+
+#include "gdb_assert.h"
+#include "gdb_obstack.h"
+
+#include "bsd-uthread.h"
+
+/* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target.  */
+static struct target_ops *bsd_uthread_ops_hack;
+
+
+/* Architecture-specific operations.  */
+
+/* Per-architecture data key.  */
+static struct gdbarch_data *bsd_uthread_data;
+
+struct bsd_uthread_ops
+{
+  /* Supply registers for an inactive thread to a register cache.  */
+  void (*supply_uthread)(struct regcache *, int, CORE_ADDR);
+
+  /* Collect registers for an inactive thread from a register cache.  */
+  void (*collect_uthread)(const struct regcache *, int, CORE_ADDR);
+};
+
+static void *
+bsd_uthread_init (struct obstack *obstack)
+{
+  struct bsd_uthread_ops *ops;
+
+  ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
+  return ops;
+}
+
+/* Set the function that supplies registers from an inactive thread
+   for architecture GDBARCH to SUPPLY_UTHREAD.  */
+
+void
+bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
+				void (*supply_uthread) (struct regcache *,
+							int, CORE_ADDR))
+{
+  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+  ops->supply_uthread = supply_uthread;
+}
+
+/* Set the function that collects registers for an inactive thread for
+   architecture GDBARCH to SUPPLY_UTHREAD.  */
+
+void
+bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
+			 void (*collect_uthread) (const struct regcache *,
+						  int, CORE_ADDR))
+{
+  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+  ops->collect_uthread = collect_uthread;
+}
+
+/* Magic number to help recognize a valid thread structure.  */
+#define BSD_UTHREAD_PTHREAD_MAGIC	0xd09ba115
+
+/* Check whether the thread structure at ADDR is valid.  */
+
+static void
+bsd_uthread_check_magic (CORE_ADDR addr)
+{
+  ULONGEST magic = read_memory_unsigned_integer (addr, 4);
+
+  if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
+    error (_("Bad magic"));
+}
+
+/* Thread states.  */
+#define BSD_UTHREAD_PS_RUNNING	0
+#define BSD_UTHREAD_PS_DEAD	18
+
+/* Address of the pointer to the the thread structure for the running
+   thread.  */
+static CORE_ADDR bsd_uthread_thread_run_addr;
+
+/* Address of the list of all threads.  */
+static CORE_ADDR bsd_uthread_thread_list_addr;
+
+/* Offsets of various "interesting" bits in the thread structure.  */
+static int bsd_uthread_thread_state_offset = -1;
+static int bsd_uthread_thread_next_offset = -1;
+static int bsd_uthread_thread_ctx_offset;
+
+/* Name of shared threads library.  */
+static const char *bsd_uthread_solib_name;
+
+/* Non-zero if the thread startum implemented by this module is active.  */
+static int bsd_uthread_active;
+
+static CORE_ADDR
+bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
+{
+  struct minimal_symbol *sym;
+
+  sym = lookup_minimal_symbol (name, NULL, objfile);
+  if (sym)
+    return SYMBOL_VALUE_ADDRESS (sym);
+
+  return 0;
+}
+
+static int
+bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
+{
+  CORE_ADDR addr;
+
+  addr = bsd_uthread_lookup_address (name, objfile);
+  if (addr == 0)
+    return 0;
+
+  return read_memory_unsigned_integer (addr, 4);
+}
+
+/* If OBJFILE contains the symbols corresponding to one of the
+   supported user-level threads libraries, activate the thread stratum
+   implemented by this module.  */
+
+static int
+bsd_uthread_activate (struct objfile *objfile)
+{
+  struct gdbarch *gdbarch = current_gdbarch;
+  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+
+  /* Skip if the thread stratum has already been activated.  */
+  if (bsd_uthread_active)
+    return 0;
+
+  /* There's no point in enabling this module if no
+     architecture-specific operations are provided.  */
+  if (!ops->supply_uthread)
+    return 0;
+
+  bsd_uthread_thread_run_addr =
+    bsd_uthread_lookup_address ("_thread_run", objfile);
+  if (bsd_uthread_thread_run_addr == 0)
+    return 0;
+
+  bsd_uthread_thread_list_addr =
+    bsd_uthread_lookup_address ("_thread_list", objfile);
+  if (bsd_uthread_thread_list_addr == 0)
+    return 0;
+
+  bsd_uthread_thread_state_offset =
+    bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
+  if (bsd_uthread_thread_state_offset == 0)
+    return 0;
+
+  bsd_uthread_thread_next_offset =
+    bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
+  if (bsd_uthread_thread_next_offset == 0)
+    return 0;
+
+  bsd_uthread_thread_ctx_offset =
+    bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
+
+  push_target (bsd_uthread_ops_hack);
+  bsd_uthread_active = 1;
+  return 1;
+}
+
+/* Deactivate the thread stratum implemented by this module.  */
+
+static void
+bsd_uthread_deactivate (void)
+{
+  /* Skip if the thread stratum has already been deactivated.  */
+  if (!bsd_uthread_active)
+    return;
+
+  bsd_uthread_active = 0;
+  unpush_target (bsd_uthread_ops_hack);
+
+  bsd_uthread_thread_run_addr = 0;
+  bsd_uthread_thread_list_addr = 0;
+  bsd_uthread_thread_state_offset = 0;
+  bsd_uthread_thread_next_offset = 0;
+  bsd_uthread_thread_ctx_offset = 0;
+  bsd_uthread_solib_name = NULL;
+}
+
+void
+bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
+{
+  bsd_uthread_activate (NULL);
+}
+
+/* Likely candidates for the threads library.  */
+static const char *bsd_uthread_solib_names[] =
+{
+  "/usr/lib/libc_r.so",		/* FreeBSD */
+  "/usr/lib/libpthread.so",	/* OpenBSD */
+  NULL
+};
+
+void
+bsd_uthread_solib_loaded (struct so_list *so)
+{
+  const char **names = bsd_uthread_solib_names;
+
+  for (names = bsd_uthread_solib_names; *names; names++)
+    {
+      if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
+	{
+	  solib_read_symbols (so, so->from_tty);
+
+	  if (bsd_uthread_activate (so->objfile))
+	    {
+	      bsd_uthread_solib_name == so->so_original_name;
+	      return;
+	    }
+	}
+    }
+}
+
+void
+bsd_uthread_solib_unloaded (struct so_list *so)
+{
+  if (!bsd_uthread_solib_name)
+    return;
+
+  if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
+    bsd_uthread_deactivate ();
+}
+
+static void
+bsd_uthread_mourn_inferior (void)
+{
+  find_target_beneath (bsd_uthread_ops_hack)->to_mourn_inferior ();
+  bsd_uthread_deactivate ();
+}
+
+static void
+bsd_uthread_fetch_registers (int regnum)
+{
+  struct gdbarch *gdbarch = current_gdbarch;
+  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+  CORE_ADDR active_addr;
+
+  /* Always fetch the appropriate registers from the layer beneath.  */
+  find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regnum);
+
+  /* FIXME: That might have gotten us more than we asked for.  Make
+     sure we overwrite all relevant registers with values from the
+     thread structure.  This can go once we fix the underlying target.  */
+  regnum = -1;
+
+  active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
+					   builtin_type_void_data_ptr);
+  if (addr != 0 && addr != active_addr)
+    {
+      bsd_uthread_check_magic (addr);
+      ops->supply_uthread (current_regcache, regnum,
+			   addr + bsd_uthread_thread_ctx_offset);
+    }
+}
+
+static void
+bsd_uthread_store_registers (int regnum)
+{
+  struct gdbarch *gdbarch = current_gdbarch;
+  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+  CORE_ADDR active_addr;
+
+  active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
+					   builtin_type_void_data_ptr);
+  if (addr != 0 && addr != active_addr)
+    {
+      bsd_uthread_check_magic (addr);
+      ops->collect_uthread (current_regcache, regnum,
+			    addr + bsd_uthread_thread_ctx_offset);
+    }
+  else
+    {
+      /* Updating the thread that is currently running; pass the
+         request to the layer beneath.  */
+      find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regnum);
+    }
+}
+
+/* FIXME: This function is only there because otherwise GDB tries to
+   invoke deprecate_xfer_memory.  */
+
+static LONGEST
+bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
+			  const char *annex, void *readbuf,
+			  const void *writebuf,
+			  ULONGEST offset, LONGEST len)
+{
+  gdb_assert (ops->beneath->to_xfer_partial);
+  return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
+					writebuf, offset, len);
+}
+
+static ptid_t
+bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+  CORE_ADDR addr;
+
+  /* Pass the request to the layer beneath.  */
+  ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
+
+  /* Fetch the corresponding thread ID, and augment the returned
+     process ID with it.  */
+  addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
+				    builtin_type_void_data_ptr);
+  if (addr != 0)
+    {
+      char buf[4];
+
+      /* FIXME: For executables linked statically with the threads
+         library, we end up here before the program has actually been
+         executed.  In that case ADDR will be garbage since it has
+         been read from the wrong virtual memory image.  */
+      if (target_read_memory (addr, buf, 4) == 0)
+	{
+	  ULONGEST magic = extract_unsigned_integer (buf, 4);
+	  if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
+	    ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
+	}
+    }
+
+  /* HACK: Twiddle INFERIOR_PTID such that the initial thread of a
+     process isn't recognized as a new thread.  */
+  if (ptid_get_tid (ptid) != 0 && !in_thread_list (ptid)
+      && ptid_get_tid (inferior_ptid) == 0)
+    {
+      add_thread (ptid);
+      inferior_ptid = ptid;
+    }
+
+  return ptid;
+}
+
+static void
+bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
+{
+  /* Pass the request to the layer beneath.  */
+  find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
+}
+
+static int
+bsd_uthread_thread_alive (ptid_t ptid)
+{
+  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+
+  if (addr != 0)
+    {
+      int offset = bsd_uthread_thread_state_offset;
+      ULONGEST state;
+
+      bsd_uthread_check_magic (addr);
+
+      state = read_memory_unsigned_integer (addr + offset, 4);
+      if (state == BSD_UTHREAD_PS_DEAD)
+	return 0;
+    }
+
+  return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
+}
+
+static void
+bsd_uthread_find_new_threads (void)
+{
+  pid_t pid = ptid_get_pid (inferior_ptid);
+  int offset = bsd_uthread_thread_next_offset;
+  CORE_ADDR addr;
+
+  addr = read_memory_typed_address (bsd_uthread_thread_list_addr,
+				    builtin_type_void_data_ptr);
+  while (addr != 0)
+    {
+      ptid_t ptid = ptid_build (pid, 0, addr);
+
+      if (!in_thread_list (ptid))
+	add_thread (ptid);
+
+      addr = read_memory_typed_address (addr + offset,
+					builtin_type_void_data_ptr);
+    }
+}
+
+/* Possible states a thread can be in.  */
+static char *bsd_uthread_state[] =
+{
+  "RUNNING",
+  "SIGTHREAD",
+  "MUTEX_WAIT",
+  "COND_WAIT",
+  "FDLR_WAIT",
+  "FDLW_WAIT",
+  "FDR_WAIT",
+  "FDW_WAIT",
+  "FILE_WAIT",
+  "POLL_WAIT",
+  "SELECT_WAIT",
+  "SLEEP_WAIT",
+  "WAIT_WAIT",
+  "SIGSUSPEND",
+  "SIGWAIT",
+  "SPINBLOCK",
+  "JOIN",
+  "SUSPENDED",
+  "DEAD",
+  "DEADLOCK"
+};
+
+/* Return a string describing th state of the thread specified by
+   INFO.  */
+
+static char *
+bsd_uthread_extra_thread_info (struct thread_info *info)
+{
+  CORE_ADDR addr = ptid_get_tid (info->ptid);
+
+  if (addr != 0)
+    {
+      int offset = bsd_uthread_thread_state_offset;
+      ULONGEST state;
+
+      state = read_memory_unsigned_integer (addr + offset, 4);
+      if (state < ARRAY_SIZE (bsd_uthread_state))
+	return bsd_uthread_state[state];
+    }
+
+  return NULL;
+}
+
+static char *
+bsd_uthread_pid_to_str (ptid_t ptid)
+{
+  if (ptid_get_tid (ptid) != 0)
+    {
+      static char buf[64];
+
+      xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
+		 ptid_get_pid (ptid), ptid_get_tid (ptid));
+      return buf;
+    }
+
+  return normal_pid_to_str (ptid);
+}
+
+struct target_ops *
+bsd_uthread_target (void)
+{
+  struct target_ops *t = XZALLOC (struct target_ops);
+
+  t->to_shortname = "bsd-uthreads";
+  t->to_longname = "BSD user-level threads";
+  t->to_doc = "BSD user-level threads";
+  t->to_mourn_inferior = bsd_uthread_mourn_inferior;
+  t->to_fetch_registers = bsd_uthread_fetch_registers;
+  t->to_store_registers = bsd_uthread_store_registers;
+  t->to_xfer_partial = bsd_uthread_xfer_partial;
+  t->to_wait = bsd_uthread_wait;
+  t->to_resume = bsd_uthread_resume;
+  t->to_thread_alive = bsd_uthread_thread_alive;
+  t->to_find_new_threads = bsd_uthread_find_new_threads;
+  t->to_extra_thread_info = bsd_uthread_extra_thread_info;
+  t->to_pid_to_str = bsd_uthread_pid_to_str;
+  t->to_stratum = thread_stratum;
+  t->to_magic = OPS_MAGIC;
+  bsd_uthread_ops_hack = t;
+
+  return t;
+}
+
+void
+_initialize_bsd_uthread (void)
+{
+  add_target (bsd_uthread_target ());
+
+  bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
+
+  observer_attach_inferior_created (bsd_uthread_inferior_created);
+  observer_attach_solib_loaded (bsd_uthread_solib_loaded);
+  observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
+}
diff --git a/gnu/usr.bin/binutils/gdb/bsd-uthread.h b/gnu/usr.bin/binutils/gdb/bsd-uthread.h
new file mode 100644
index 00000000000..b4ac0feafaf
--- /dev/null
+++ b/gnu/usr.bin/binutils/gdb/bsd-uthread.h
@@ -0,0 +1,40 @@
+/* BSD user-level threads support.
+
+   Copyright 2005 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   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 2 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, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef BSD_UTHREAD_H
+#define BSD_UTHREAD_H 1
+
+/* Set the function that supplies registers for an inactive thread for
+   architecture GDBARCH to SUPPLY_UTHREAD.  */
+
+extern void bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
+				    void (*supply_uthread) (struct regcache *,
+							    int, CORE_ADDR));
+
+
+/* Set the function that collects registers for an inactive thread for
+   architecture GDBARCH to SUPPLY_UTHREAD.  */
+
+extern void bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
+			     void (*collect_uthread) (const struct regcache *,
+						      int, CORE_ADDR));
+
+#endif /* bsd-uthread.h */
diff --git a/gnu/usr.bin/binutils/gdb/defs.h b/gnu/usr.bin/binutils/gdb/defs.h
index fd96665d44b..4642c782c98 100644
--- a/gnu/usr.bin/binutils/gdb/defs.h
+++ b/gnu/usr.bin/binutils/gdb/defs.h
@@ -879,6 +879,10 @@ extern void xvasprintf (char **ret, const char *format, va_list ap);
 extern char *xstrprintf (const char *format, ...) ATTR_FORMAT (printf, 1, 2);
 extern char *xstrvprintf (const char *format, va_list ap);
 
+/* Like snprintf, but throw an error if the output buffer is too small.  */
+extern int xsnprintf (char *str, size_t size, const char *format, ...)
+     ATTR_FORMAT (printf, 3, 4);
+
 extern int parse_escape (char **);
 
 /* Message to be printed before the error message, when an error occurs.  */
diff --git a/gnu/usr.bin/binutils/gdb/doc/observer.texi b/gnu/usr.bin/binutils/gdb/doc/observer.texi
index de48a192a36..5f7171cc6c0 100644
--- a/gnu/usr.bin/binutils/gdb/doc/observer.texi
+++ b/gnu/usr.bin/binutils/gdb/doc/observer.texi
@@ -35,6 +35,11 @@ The observer implementation is also currently not reentrant.
 In particular, it is therefore not possible to call the attach
 or detach routines during a notification.
 
+@section Debugging
+Observer notifications can be traced using the command @samp{set debug
+observer 1} (@pxref{Debugging Output, , Optional messages about
+internal happenings, gdb, Debugging with @var{GDBN}}).
+
 @section @code{normal_stop} Notifications
 @cindex @code{normal_stop} observer
 @cindex notification about inferior execution stop
@@ -50,21 +55,48 @@ a condition that is not met.  If the breakpoint has any associated
 commands list, the commands are executed after the notification
 is emitted.
 
-The following interface is available to manage @code{normal_stop}
-observers:
+The following interfaces are available to manage observers:
 
-@deftypefun extern struct observer *observer_attach_normal_stop (observer_normal_stop_ftype *@var{f})
-Attach the given @code{normal_stop} callback function @var{f} and
-return the associated observer.
+@deftypefun extern struct observer *observer_attach_@var{event} (observer_@var{event}_ftype *@var{f})
+Using the function @var{f}, create an observer that is notified when
+ever @var{event} occures, return the observer.
 @end deftypefun
 
-@deftypefun extern void observer_detach_normal_stop (struct observer *@var{observer});
+@deftypefun extern void observer_detach_@var{event} (struct observer *@var{observer});
 Remove @var{observer} from the list of observers to be notified when
-a @code{normal_stop} event occurs.
+@var{event} occurs.
+@end deftypefun
+
+@deftypefun extern void observer_notify_@var{event} (void);
+Send a notification to all @var{event} observers.
 @end deftypefun
 
-@deftypefun extern void observer_notify_normal_stop (void);
-Send a notification to all @code{normal_stop} observers.
+The following observable events are defined:
+
+@c note: all events must take at least one parameter.
+
+@deftypefun void normal_stop (struct bpstats *@var{bs})
+The inferior has stopped for real.
 @end deftypefun
 
+@deftypefun void target_changed (struct target_ops *@var{target})
+The target's register contents have changed.
+@end deftypefun
 
+@deftypefun void inferior_created (struct target_ops *@var{objfile}, int @var{from_tty})
+@value{GDBN} has just connected to an inferior.  For @samp{run},
+@value{GDBN} calls this observer while the inferior is still stopped
+at the entry-point instruction.  For @samp{attach} and @samp{core},
+@value{GDBN} calls this observer immediately after connecting to the
+inferior, and before any information on the inferior has been printed.
+@end deftypefun
+
+@deftypefun void solib_loaded (struct so_list *@var{solib})
+The shared library specified by @var{solib} has been loaded.  Note that
+when @value{GDBN} calls this observer, the library's symbols probably
+haven't been loaded yet.
+@end deftypefun
+
+@deftypefun void solib_unloaded (struct so_list *@var{solib})
+The specified shared library has been discovered to be unloaded.
+@end deftypefun
diff --git a/gnu/usr.bin/binutils/gdb/solib.c b/gnu/usr.bin/binutils/gdb/solib.c
index 35480bfbbb9..b0885fb9cae 100644
--- a/gnu/usr.bin/binutils/gdb/solib.c
+++ b/gnu/usr.bin/binutils/gdb/solib.c
@@ -369,6 +369,33 @@ symbol_add_stub (void *arg)
   return (1);
 }
 
+/* Read in symbols for shared object SO.  If FROM_TTY is non-zero, be
+   chatty about it.  Return non-zero if any symbols were actually
+   loaded.  */
+
+int
+solib_read_symbols (struct so_list *so, int from_tty)
+{
+  if (so->symbols_loaded)
+    {
+      if (from_tty)
+	printf_unfiltered (_("Symbols already loaded for %s\n"), so->so_name);
+    }
+  else
+    {
+      if (catch_errors (symbol_add_stub, so,
+			"Error while reading shared library symbols:\n",
+			RETURN_MASK_ALL))
+	{
+	  if (from_tty)
+	    printf_unfiltered (_("Loaded symbols for %s\n"), so->so_name);
+	  so->symbols_loaded = 1;
+	  return 1;
+	}
+    }
+
+  return 0;
+}
 
 /* LOCAL FUNCTION
 
@@ -533,6 +560,10 @@ update_solib_list (int from_tty, struct target_ops *target)
 			  count * sizeof (i->sections[0]));
 		}
 	    }
+
+	  /* Notify any observer that the shared object has been
+             loaded now that we've added it to GDB's tables.  */
+	  observer_notify_solib_loaded (i);
 	}
     }
 }
@@ -584,27 +615,8 @@ solib_add (char *pattern, int from_tty, struct target_ops *target, int readsyms)
       if (! pattern || re_exec (gdb->so_name))
 	{
 	  any_matches = 1;
-
-	  if (gdb->symbols_loaded)
-	    {
-	      if (from_tty)
-		printf_unfiltered ("Symbols already loaded for %s\n",
-				   gdb->so_name);
-	    }
-	  else if (readsyms)
-	    {
-	      if (catch_errors
-		  (symbol_add_stub, gdb,
-		   "Error while reading shared library symbols:\n",
-		   RETURN_MASK_ALL))
-		{
-		  if (from_tty)
-		    printf_unfiltered ("Loaded symbols for %s\n",
-				       gdb->so_name);
-		  gdb->symbols_loaded = 1;
-		  loaded_any_symbols = 1;
-		}
-	    }
+	  if (readsyms && solib_read_symbols (gdb, from_tty))
+	    loaded_any_symbols = 1;
 	}
 
     if (from_tty && pattern && ! any_matches)
diff --git a/gnu/usr.bin/binutils/gdb/solib.h b/gnu/usr.bin/binutils/gdb/solib.h
index cb4ba2d382a..1318c3085f0 100644
--- a/gnu/usr.bin/binutils/gdb/solib.h
+++ b/gnu/usr.bin/binutils/gdb/solib.h
@@ -23,6 +23,7 @@
 #define SOLIB_H
 
 /* Forward decl's for prototypes */
+struct so_list;
 struct target_ops;
 
 /* Called when we free all symtabs, to free the shared library information
@@ -38,6 +39,7 @@ extern void clear_solib (void);
     solib_add (filename, from_tty, targ, readsyms)
 
 extern void solib_add (char *, int, struct target_ops *, int);
+extern int solib_read_symbols (struct so_list *, int);
 
 /* Function to be called when the inferior starts up, to discover the names
    of shared libraries that are dynamically linked, the base addresses to
diff --git a/gnu/usr.bin/binutils/gdb/utils.c b/gnu/usr.bin/binutils/gdb/utils.c
index e30808c38b4..78530a34d1e 100644
--- a/gnu/usr.bin/binutils/gdb/utils.c
+++ b/gnu/usr.bin/binutils/gdb/utils.c
@@ -1133,6 +1133,20 @@ xstrvprintf (const char *format, va_list ap)
   return ret;
 }
 
+int
+xsnprintf (char *str, size_t size, const char *format, ...)
+{
+  va_list args;
+  int ret;
+
+  va_start (args, format);
+  ret = vsnprintf (str, size, format, args);
+  gdb_assert (ret < size);
+  va_end (args);
+
+  return ret;
+}
+
 /* My replacement for the read system call.
    Used like `read' but keeps going if `read' returns too soon.  */