garbage collect target_decr_pc_after_break

[deliverable/binutils-gdb.git] / gdb / aix-thread.c

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index 0202a2471eb19461c032872494b1f2e2f5e5ec83..e97f793911a5cd797086501891d21154d0b31ef8 100644 (file)
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -1,6 +1,6 @@
 /* Low level interface for debugging AIX 4.3+ pthreads.
 
-   Copyright (C) 1999-2014 Free Software Foundation, Inc.
+   Copyright (C) 1999-2015 Free Software Foundation, Inc.
    Written by Nick Duffek <nsd@redhat.com>.
 
    This file is part of GDB.
@@ -40,15 +40,14 @@
      */
 
 #include "defs.h"
-#include "gdb_assert.h"
 #include "gdbthread.h"
 #include "target.h"
 #include "inferior.h"
 #include "regcache.h"
 #include "gdbcmd.h"
 #include "ppc-tdep.h"
-#include <string.h>
 #include "observer.h"
+#include "objfiles.h"
 
 #include <procinfo.h>
 #include <sys/types.h>
@@ -313,7 +312,7 @@ pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
                fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n");
              return PDC_FAILURE;
            }
-         symbols[i].addr = MSYMBOL_VALUE_ADDRESS (ms.minsym);
+         symbols[i].addr = BMSYMBOL_VALUE_ADDRESS (ms);
        }
       if (debug_aix_thread)
        fprintf_unfiltered (gdb_stdlog, "  symbols[%d].addr = %s\n",
@@ -758,9 +757,9 @@ sync_threadlists (void)
       else if (gi == gcount)
        {
          thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid));
-         thread->private = xmalloc (sizeof (struct private_thread_info));
-         thread->private->pdtid = pbuf[pi].pdtid;
-         thread->private->tid = pbuf[pi].tid;
+         thread->priv = xmalloc (sizeof (struct private_thread_info));
+         thread->priv->pdtid = pbuf[pi].pdtid;
+         thread->priv->tid = pbuf[pi].tid;
          pi++;
        }
       else
@@ -777,8 +776,8 @@ sync_threadlists (void)
 
          if (cmp_result == 0)
            {
-             gbuf[gi]->private->pdtid = pdtid;
-             gbuf[gi]->private->tid = tid;
+             gbuf[gi]->priv->pdtid = pdtid;
+             gbuf[gi]->priv->tid = tid;
              pi++;
              gi++;
            }
@@ -790,9 +789,9 @@ sync_threadlists (void)
          else
            {
              thread = add_thread (pptid);
-             thread->private = xmalloc (sizeof (struct private_thread_info));
-             thread->private->pdtid = pdtid;
-             thread->private->tid = tid;
+             thread->priv = xmalloc (sizeof (struct private_thread_info));
+             thread->priv->pdtid = pdtid;
+             thread->priv->tid = tid;
              pi++;
            }
        }
@@ -810,7 +809,7 @@ iter_tid (struct thread_info *thread, void *tidp)
 {
   const pthdb_tid_t tid = *(pthdb_tid_t *)tidp;
 
-  return (thread->private->tid == tid);
+  return (thread->priv->tid == tid);
 }
 
 /* Synchronize libpthdebug's state with the inferior and with GDB,
@@ -912,7 +911,7 @@ pd_enable (void)
   ms = lookup_minimal_symbol (stub_name, NULL, NULL);
   if (ms.minsym == NULL)
     return;
-  pd_brk_addr = MSYMBOL_VALUE_ADDRESS (ms.minsym);
+  pd_brk_addr = BMSYMBOL_VALUE_ADDRESS (ms);
   if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
     return;
 
@@ -958,12 +957,9 @@ new_objfile (struct objfile *objfile)
 /* Attach to process specified by ARGS.  */
 
 static void
-aix_thread_attach (struct target_ops *ops, char *args, int from_tty)
+aix_thread_inferior_created (struct target_ops *ops, int from_tty)
 {
-  struct target_ops *beneath = find_target_beneath (ops);
-  
-  beneath->to_attach (beneath, args, from_tty);
-  pd_activate (1);
+  pd_enable ();
 }
 
 /* Detach from the process attached to by aix_thread_attach().  */
@@ -1003,7 +999,7 @@ aix_thread_resume (struct target_ops *ops,
        error (_("aix-thread resume: unknown pthread %ld"),
               ptid_get_lwp (ptid));
 
-      tid[0] = thread->private->tid;
+      tid[0] = thread->priv->tid;
       if (tid[0] == PTHDB_INVALID_TID)
        error (_("aix-thread resume: no tid for pthread %ld"),
               ptid_get_lwp (ptid));
@@ -1046,7 +1042,7 @@ aix_thread_wait (struct target_ops *ops,
       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
       if (regcache_read_pc (regcache)
-         - target_decr_pc_after_break (gdbarch) == pd_brk_addr)
+         - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
        return pd_activate (0);
     }
 
@@ -1317,10 +1313,10 @@ aix_thread_fetch_registers (struct target_ops *ops,
   else
     {
       thread = find_thread_ptid (inferior_ptid);
-      tid = thread->private->tid;
+      tid = thread->priv->tid;
 
       if (tid == PTHDB_INVALID_TID)
-       fetch_regs_user_thread (regcache, thread->private->pdtid);
+       fetch_regs_user_thread (regcache, thread->priv->pdtid);
       else
        fetch_regs_kernel_thread (regcache, regno, tid);
     }
@@ -1671,10 +1667,10 @@ aix_thread_store_registers (struct target_ops *ops,
   else
     {
       thread = find_thread_ptid (inferior_ptid);
-      tid = thread->private->tid;
+      tid = thread->priv->tid;
 
       if (tid == PTHDB_INVALID_TID)
-       store_regs_user_thread (regcache, thread->private->pdtid);
+       store_regs_user_thread (regcache, thread->priv->pdtid);
       else
        store_regs_kernel_thread (regcache, regno, tid);
     }
@@ -1768,8 +1764,8 @@ aix_thread_extra_thread_info (struct target_ops *self,
 
   buf = mem_fileopen ();
 
-  pdtid = thread->private->pdtid;
-  tid = thread->private->tid;
+  pdtid = thread->priv->pdtid;
+  tid = thread->priv->tid;
 
   if (tid != PTHDB_INVALID_TID)
     /* i18n: Like "thread-identifier %d, [state] running, suspended" */
@@ -1822,15 +1818,12 @@ init_aix_thread_ops (void)
   aix_thread_ops.to_longname = _("AIX pthread support");
   aix_thread_ops.to_doc = _("AIX pthread support");
 
-  aix_thread_ops.to_attach = aix_thread_attach;
   aix_thread_ops.to_detach = aix_thread_detach;
   aix_thread_ops.to_resume = aix_thread_resume;
   aix_thread_ops.to_wait = aix_thread_wait;
   aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers;
   aix_thread_ops.to_store_registers = aix_thread_store_registers;
   aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial;
-  /* No need for aix_thread_ops.to_create_inferior, because we activate thread
-     debugging when the inferior reaches pd_brk_addr.  */
   aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior;
   aix_thread_ops.to_thread_alive = aix_thread_thread_alive;
   aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
@@ -1854,6 +1847,10 @@ _initialize_aix_thread (void)
   /* Notice when object files get loaded and unloaded.  */
   observer_attach_new_objfile (new_objfile);
 
+  /* Add ourselves to inferior_created event chain.
+     This is needed to enable the thread target on "attach".  */
+  observer_attach_inferior_created (aix_thread_inferior_created);
+
   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
                           _("Set debugging of AIX thread module."),
                           _("Show debugging of AIX thread module."),