X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fbsd-uthread.c;h=9769d207dda2de82566ff60b17283db1e5b165d7;hb=5430098f1807e084fe4ff5057040d68435f3d8a2;hp=ecbad76782c205019f4fcdd6557d038566b8b6c7;hpb=117de6a92498c0dd715fa0fdec577697433f3c5e;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index ecbad76782..9769d207dd 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -1,6 +1,6 @@
 /* BSD user-level threads support.
 
-   Copyright (C) 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2005-2017 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -29,7 +29,6 @@
 #include "symfile.h"
 #include "target.h"
 
-#include "gdb_assert.h"
 #include "gdb_obstack.h"
 
 #include "bsd-uthread.h"
@@ -69,7 +68,9 @@ 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);
+  struct bsd_uthread_ops *ops
+    = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
   ops->supply_uthread = supply_uthread;
 }
 
@@ -81,7 +82,9 @@ 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);
+  struct bsd_uthread_ops *ops
+    = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
   ops->collect_uthread = collect_uthread;
 }
 
@@ -93,7 +96,8 @@ bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
 static void
 bsd_uthread_check_magic (CORE_ADDR addr)
 {
-  ULONGEST magic = read_memory_unsigned_integer (addr, 4);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+  ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
 
   if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
     error (_("Bad magic"));
@@ -103,7 +107,7 @@ bsd_uthread_check_magic (CORE_ADDR addr)
 #define BSD_UTHREAD_PS_RUNNING	0
 #define BSD_UTHREAD_PS_DEAD	18
 
-/* Address of the pointer to the the thread structure for the running
+/* Address of the pointer to the thread structure for the running
    thread.  */
 static CORE_ADDR bsd_uthread_thread_run_addr;
 
@@ -124,11 +128,11 @@ static int bsd_uthread_active;
 static CORE_ADDR
 bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 {
-  struct minimal_symbol *sym;
+  struct bound_minimal_symbol sym;
 
   sym = lookup_minimal_symbol (name, NULL, objfile);
-  if (sym)
-    return SYMBOL_VALUE_ADDRESS (sym);
+  if (sym.minsym)
+    return BMSYMBOL_VALUE_ADDRESS (sym);
 
   return 0;
 }
@@ -136,19 +140,20 @@ bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 static int
 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr;
 
   addr = bsd_uthread_lookup_address (name, objfile);
   if (addr == 0)
     return 0;
 
-  return read_memory_unsigned_integer (addr, 4);
+  return read_memory_unsigned_integer (addr, 4, byte_order);
 }
 
 static CORE_ADDR
 bsd_uthread_read_memory_address (CORE_ADDR addr)
 {
-  struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
+  struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
   return read_memory_typed_address (addr, ptr_type);
 }
 
@@ -159,8 +164,9 @@ bsd_uthread_read_memory_address (CORE_ADDR addr)
 static int
 bsd_uthread_activate (struct objfile *objfile)
 {
-  struct gdbarch *gdbarch = current_gdbarch;
-  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+  struct gdbarch *gdbarch = target_gdbarch ();
+  struct bsd_uthread_ops *ops
+    = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
 
   /* Skip if the thread stratum has already been activated.  */
   if (bsd_uthread_active)
@@ -202,7 +208,7 @@ bsd_uthread_activate (struct objfile *objfile)
 /* Cleanup due to deactivation.  */
 
 static void
-bsd_uthread_close (int quitting)
+bsd_uthread_close (struct target_ops *self)
 {
   bsd_uthread_active = 0;
   bsd_uthread_thread_run_addr = 0;
@@ -225,7 +231,7 @@ bsd_uthread_deactivate (void)
   unpush_target (bsd_uthread_ops_hack);
 }
 
-void
+static void
 bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
 {
   bsd_uthread_activate (NULL);
@@ -239,16 +245,16 @@ static const char *bsd_uthread_solib_names[] =
   NULL
 };
 
-void
+static 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)
+      if (startswith (so->so_original_name, *names))
 	{
-	  solib_read_symbols (so, so->from_tty);
+	  solib_read_symbols (so, 0);
 
 	  if (bsd_uthread_activate (so->objfile))
 	    {
@@ -259,7 +265,7 @@ bsd_uthread_solib_loaded (struct so_list *so)
     }
 }
 
-void
+static void
 bsd_uthread_solib_unloaded (struct so_list *so)
 {
   if (!bsd_uthread_solib_name)
@@ -272,21 +278,30 @@ bsd_uthread_solib_unloaded (struct so_list *so)
 static void
 bsd_uthread_mourn_inferior (struct target_ops *ops)
 {
-  struct target_ops *beneath = find_target_beneath (bsd_uthread_ops_hack);
+  struct target_ops *beneath = find_target_beneath (ops);
   beneath->to_mourn_inferior (beneath);
   bsd_uthread_deactivate ();
 }
 
 static void
-bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
+bsd_uthread_fetch_registers (struct target_ops *ops,
+			     struct regcache *regcache, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
-  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
-  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+  struct bsd_uthread_ops *uthread_ops
+    = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+  ptid_t ptid = regcache_get_ptid (regcache);
+  CORE_ADDR addr = ptid_get_tid (ptid);
+  struct target_ops *beneath = find_target_beneath (ops);
   CORE_ADDR active_addr;
+  struct cleanup *cleanup = save_inferior_ptid ();
+
+  /* We are doing operations (e.g. reading memory) that rely on
+     inferior_ptid.  */
+  inferior_ptid = ptid;
 
   /* Always fetch the appropriate registers from the layer beneath.  */
-  find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
+  beneath->to_fetch_registers (beneath, regcache, regnum);
 
   /* FIXME: That might have gotten us more than we asked for.  Make
      sure we overwrite all relevant registers with values from the
@@ -297,57 +312,57 @@ bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
   if (addr != 0 && addr != active_addr)
     {
       bsd_uthread_check_magic (addr);
-      ops->supply_uthread (regcache, regnum,
-			   addr + bsd_uthread_thread_ctx_offset);
+      uthread_ops->supply_uthread (regcache, regnum,
+				   addr + bsd_uthread_thread_ctx_offset);
     }
+
+  do_cleanups (cleanup);
 }
 
 static void
-bsd_uthread_store_registers (struct regcache *regcache, int regnum)
+bsd_uthread_store_registers (struct target_ops *ops,
+			     struct regcache *regcache, int regnum)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
-  struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
-  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+  struct bsd_uthread_ops *uthread_ops
+    = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+  struct target_ops *beneath = find_target_beneath (ops);
+  ptid_t ptid = regcache_get_ptid (regcache);
+  CORE_ADDR addr = ptid_get_tid (ptid);
   CORE_ADDR active_addr;
+  struct cleanup *cleanup = save_inferior_ptid ();
+
+  /* We are doing operations (e.g. reading memory) that rely on
+     inferior_ptid.  */
+  inferior_ptid = ptid;
 
   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
   if (addr != 0 && addr != active_addr)
     {
       bsd_uthread_check_magic (addr);
-      ops->collect_uthread (regcache, regnum,
-			    addr + bsd_uthread_thread_ctx_offset);
+      uthread_ops->collect_uthread (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 (regcache, regnum);
+      beneath->to_store_registers (beneath, regcache, 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, gdb_byte *readbuf,
-			  const gdb_byte *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);
+  do_cleanups (cleanup);
 }
 
 static ptid_t
 bsd_uthread_wait (struct target_ops *ops,
-		  ptid_t ptid, struct target_waitstatus *status)
+		  ptid_t ptid, struct target_waitstatus *status, int options)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr;
-  struct target_ops *beneath = find_target_beneath (bsd_uthread_ops_hack);
+  struct target_ops *beneath = find_target_beneath (ops);
 
   /* Pass the request to the layer beneath.  */
-  ptid = beneath->to_wait (beneath, ptid, status);
+  ptid = beneath->to_wait (beneath, ptid, status, options);
 
   /* If the process is no longer alive, there's no point in figuring
      out the thread ID.  It will fail anyway.  */
@@ -368,7 +383,7 @@ bsd_uthread_wait (struct target_ops *ops,
          been read from the wrong virtual memory image.  */
       if (target_read_memory (addr, buf, 4) == 0)
 	{
-	  ULONGEST magic = extract_unsigned_integer (buf, 4);
+	  ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
 	  if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
 	    ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
 	}
@@ -389,16 +404,20 @@ bsd_uthread_wait (struct target_ops *ops,
 }
 
 static void
-bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
+bsd_uthread_resume (struct target_ops *ops,
+		    ptid_t ptid, int step, enum gdb_signal sig)
 {
   /* Pass the request to the layer beneath.  */
-  find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
+  struct target_ops *beneath = find_target_beneath (ops);
+  beneath->to_resume (beneath, ptid, step, sig);
 }
 
 static int
-bsd_uthread_thread_alive (ptid_t ptid)
+bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
 {
-  CORE_ADDR addr = ptid_get_tid (inferior_ptid);
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
+  struct target_ops *beneath = find_target_beneath (ops);
+  CORE_ADDR addr = ptid_get_tid (ptid);
 
   if (addr != 0)
     {
@@ -407,21 +426,23 @@ bsd_uthread_thread_alive (ptid_t ptid)
 
       bsd_uthread_check_magic (addr);
 
-      state = read_memory_unsigned_integer (addr + offset, 4);
+      state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
       if (state == BSD_UTHREAD_PS_DEAD)
 	return 0;
     }
 
-  return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
+  return beneath->to_thread_alive (beneath, ptid);
 }
 
 static void
-bsd_uthread_find_new_threads (void)
+bsd_uthread_update_thread_list (struct target_ops *ops)
 {
   pid_t pid = ptid_get_pid (inferior_ptid);
   int offset = bsd_uthread_thread_next_offset;
   CORE_ADDR addr;
 
+  prune_threads ();
+
   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
   while (addr != 0)
     {
@@ -443,7 +464,7 @@ bsd_uthread_find_new_threads (void)
 }
 
 /* Possible states a thread can be in.  */
-static char *bsd_uthread_state[] =
+static const char *bsd_uthread_state[] =
 {
   "RUNNING",
   "SIGTHREAD",
@@ -470,9 +491,11 @@ static char *bsd_uthread_state[] =
 /* Return a string describing th state of the thread specified by
    INFO.  */
 
-static char *
-bsd_uthread_extra_thread_info (struct thread_info *info)
+static const char *
+bsd_uthread_extra_thread_info (struct target_ops *self,
+			       struct thread_info *info)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
   CORE_ADDR addr = ptid_get_tid (info->ptid);
 
   if (addr != 0)
@@ -480,7 +503,7 @@ bsd_uthread_extra_thread_info (struct thread_info *info)
       int offset = bsd_uthread_thread_state_offset;
       ULONGEST state;
 
-      state = read_memory_unsigned_integer (addr + offset, 4);
+      state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
       if (state < ARRAY_SIZE (bsd_uthread_state))
 	return bsd_uthread_state[state];
     }
@@ -488,7 +511,7 @@ bsd_uthread_extra_thread_info (struct thread_info *info)
   return NULL;
 }
 
-static char *
+static const char *
 bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   if (ptid_get_tid (ptid) != 0)
@@ -503,10 +526,10 @@ bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
   return normal_pid_to_str (ptid);
 }
 
-struct target_ops *
+static struct target_ops *
 bsd_uthread_target (void)
 {
-  struct target_ops *t = XZALLOC (struct target_ops);
+  struct target_ops *t = XCNEW (struct target_ops);
 
   t->to_shortname = "bsd-uthreads";
   t->to_longname = "BSD user-level threads";
@@ -515,11 +538,10 @@ bsd_uthread_target (void)
   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_update_thread_list = bsd_uthread_update_thread_list;
   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;
@@ -529,10 +551,13 @@ bsd_uthread_target (void)
   return t;
 }
 
+/* Provide a prototype to silence -Wmissing-prototypes.  */
+extern initialize_file_ftype _initialize_bsd_uthread;
+
 void
 _initialize_bsd_uthread (void)
 {
-  add_target (bsd_uthread_target ());
+  complete_target_initialization (bsd_uthread_target ());
 
   bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);