GDB 7.6.50

gdb/aix-thread.c

 /* Low level interface for debugging AIX 4.3+ pthreads.
 
-   Copyright (C) 1999-2000, 2002, 2007-2012 Free Software Foundation,
-   Inc.
+   Copyright (C) 1999-2013 Free Software Foundation, Inc.
    Written by Nick Duffek <nsd@redhat.com>.
 
    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 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ skipping 26 matching lines @@
      */
 
 #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 "gdb_string.h"
+#include <string.h>
 #include "observer.h"
 
 #include <procinfo.h>
 #include <sys/types.h>
 #include <sys/ptrace.h>
 #include <sys/reg.h>
 #include <sched.h>
 #include <sys/pthdebug.h>
 
 #if !HAVE_DECL_GETTHRDS
-extern int getthrds (pid_t, struct thrdsinfo64 *, int, pthdb_tid_t *, int);
+extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int);
 #endif
 
 /* Whether to emit debugging output.  */
 static int debug_aix_thread;
 
 /* In AIX 5.1, functions use pthdb_tid_t instead of tid_t.  */
 #ifndef PTHDB_VERSION_3
 #define pthdb_tid_t     tid_t
 #endif
 
 /* Return whether to treat PID as a debuggable thread id.  */
 
 #define PD_TID(ptid)    (pd_active && ptid_get_tid (ptid) != 0)
 
-/* Build a thread ptid.  */
-#define BUILD_THREAD(TID, PID) ptid_build (PID, 0, TID)
-
-/* Build and lwp ptid.  */
-#define BUILD_LWP(LWP, PID) MERGEPID (PID, LWP)
-
 /* pthdb_user_t value that we pass to pthdb functions.  0 causes
    PTHDB_BAD_USER errors, so use 1.  */
 
 #define PD_USER 1
 
 /* Success and failure values returned by pthdb callbacks.  */
 
 #define PDC_SUCCESS     PTHDB_SUCCESS
 #define PDC_FAILURE     PTHDB_CALLBACK
 
@@ skipping 138 matching lines @@
                                 req, id, ret, errno);
           return ret == -1 ? 0 : 1;
         }
       break;
     }
   error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"),
          req, id, ret, errno, safe_strerror (errno));
   return 0;  /* Not reached.  */
 }
 
-/* Call ptracex (REQ, ID, ADDR, DATA, BUF).  Return success.  */
+/* Call ptracex (REQ, ID, ADDR, DATA, BUF) or
+   ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
+   Return success.  */
+
+#ifdef HAVE_PTRACE64
+# define ptracex(request, pid, addr, data, buf) \
+         ptrace64 (request, pid, addr, data, buf)
+#endif
 
 static int
 ptrace64aix (int req, int id, long long addr, int data, int *buf)
 {
   errno = 0;
   return ptrace_check (req, id, ptracex (req, id, addr, data, buf));
 }
 
-/* Call ptrace (REQ, ID, ADDR, DATA, BUF).  Return success.  */
+/* Call ptrace (REQ, ID, ADDR, DATA, BUF) or
+   ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64.
+   Return success.  */
+
+#ifdef HAVE_PTRACE64
+# define ptrace(request, pid, addr, data, buf) \
+         ptrace64 (request, pid, addr, data, buf)
+# define addr_ptr long long
+#else
+# define addr_ptr int *
+#endif
 
 static int
-ptrace32 (int req, int id, int *addr, int data, int *buf)
+ptrace32 (int req, int id, addr_ptr addr, int data, int *buf)
 {
   errno = 0;
   return ptrace_check (req, id, 
-                       ptrace (req, id, (int *) addr, data, buf));
+                       ptrace (req, id, addr, data, buf));
 }
 
 /* If *PIDP is a composite process/thread id, convert it to a
    process id.  */
 
 static void
 pid_to_prc (ptid_t *ptidp)
 {
   ptid_t ptid;
 
   ptid = *ptidp;
   if (PD_TID (ptid))
-    *ptidp = pid_to_ptid (PIDGET (ptid));
+    *ptidp = pid_to_ptid (ptid_get_pid (ptid));
 }
 
 /* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to
    the address of SYMBOLS[<i>].name.  */
 
 static int
 pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count)
 {
   struct minimal_symbol *ms;
   int i;
@@ skipping 74 matching lines @@
         {
           if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
             memset (gprs32, 0, sizeof (gprs32));
           memcpy (context->gpr, gprs32, sizeof(gprs32));
         }
     }
 
   /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {
-      if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL))
+      if (!ptrace32 (PTT_READ_FPRS, tid, (addr_ptr) fprs, 0, NULL))
         memset (fprs, 0, sizeof (fprs));
       memcpy (context->fpr, fprs, sizeof(fprs));
     }
 
   /* Special-purpose registers.  */
   if (flags & PTHDB_FLAG_SPRS)
     {
       if (arch64)
         {
           if (!ptrace64aix (PTT_READ_SPRS, tid, 
                             (unsigned long) &sprs64, 0, NULL))
             memset (&sprs64, 0, sizeof (sprs64));
           memcpy (&context->msr, &sprs64, sizeof(sprs64));
         }
       else
         {
-          if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
+          if (!ptrace32 (PTT_READ_SPRS, tid, (addr_ptr) &sprs32, 0, NULL))
             memset (&sprs32, 0, sizeof (sprs32));
           memcpy (&context->msr, &sprs32, sizeof(sprs32));
         }
     }  
   return 0;
 }
 
 /* Write register function should be able to write requested context
    information to specified debuggee's kernel thread id.
    If successful return 0, else non-zero is returned.  */
@@ skipping 14 matching lines @@
     fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n",
                         (int) tid, hex_string (flags));
 
   /* General-purpose registers.  */
   if (flags & PTHDB_FLAG_GPRS)
     {
       if (arch64)
         ptrace64aix (PTT_WRITE_GPRS, tid, 
                      (unsigned long) context->gpr, 0, NULL);
       else
-        ptrace32 (PTT_WRITE_GPRS, tid, (int *) context->gpr, 0, NULL);
+        ptrace32 (PTT_WRITE_GPRS, tid, (addr_ptr) context->gpr, 0, NULL);
     }
 
  /* Floating-point registers.  */
   if (flags & PTHDB_FLAG_FPRS)
     {
-      ptrace32 (PTT_WRITE_FPRS, tid, (int *) context->fpr, 0, NULL);
+      ptrace32 (PTT_WRITE_FPRS, tid, (addr_ptr) context->fpr, 0, NULL);
     }
 
   /* Special-purpose registers.  */
   if (flags & PTHDB_FLAG_SPRS)
     {
       if (arch64)
         {
           ptrace64aix (PTT_WRITE_SPRS, tid, 
                        (unsigned long) &context->msr, 0, NULL);
         }
       else
         {
-          ptrace32 (PTT_WRITE_SPRS, tid, (void *) &context->msr, 0, NULL);
+          ptrace32 (PTT_WRITE_SPRS, tid, (addr_ptr) &context->msr, 0, NULL);
         }
     }
   return 0;
 }
 
 /* pthdb callback: read LEN bytes from process ADDR into BUF.  */
 
 static int
 pdc_read_data (pthdb_user_t user, void *buf, 
                pthdb_addr_t addr, size_t len)
@@ skipping 194 matching lines @@
 }
 
 /* Search through the list of all kernel threads for the thread
    that has stopped on a SIGTRAP signal, and return its TID.
    Return 0 if none found.  */
 
 static pthdb_tid_t
 get_signaled_thread (void)
 {
   struct thrdsinfo64 thrinf;
-  pthdb_tid_t ktid = 0;
+  tid_t ktid = 0;
   int result = 0;
 
   while (1)
   {
-    if (getthrds (PIDGET (inferior_ptid), &thrinf, 
+    if (getthrds (ptid_get_pid (inferior_ptid), &thrinf, 
                   sizeof (thrinf), &ktid, 1) != 1)
       break;
 
     if (thrinf.ti_cursig == SIGTRAP)
       return thrinf.ti_tid;
   }
 
   /* Didn't find any thread stopped on a SIGTRAP signal.  */
   return 0;
 }
@@ skipping 62 matching lines @@
   /* Accumulate an array of GDB threads sorted by pid.  */
 
   gcount = 0;
   iterate_over_threads (giter_count, &gcount);
   g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf);
   iterate_over_threads (giter_accum, &g);
   qsort (gbuf, gcount, sizeof *gbuf, gcmp);
 
   /* Apply differences between the two arrays to GDB's thread list.  */
 
-  infpid = PIDGET (inferior_ptid);
+  infpid = ptid_get_pid (inferior_ptid);
   for (pi = gi = 0; pi < pcount || gi < gcount;)
     {
       if (pi == pcount)
         {
           delete_thread (gbuf[gi]->ptid);
           gi++;
         }
       else if (gi == gcount)
         {
-          thread = add_thread (BUILD_THREAD (pbuf[pi].pthid, infpid));
+          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;
           pi++;
         }
       else
         {
           ptid_t pptid, gptid;
           int cmp_result;
 
-          pptid = BUILD_THREAD (pbuf[pi].pthid, infpid);
+          pptid = ptid_build (infpid, 0, pbuf[pi].pthid);
           gptid = gbuf[gi]->ptid;
           pdtid = pbuf[pi].pdtid;
           tid = pbuf[pi].tid;
 
           cmp_result = ptid_cmp (pptid, gptid);
 
           if (cmp_result == 0)
             {
               gbuf[gi]->private->pdtid = pdtid;
               gbuf[gi]->private->tid = tid;
@@ skipping 109 matching lines @@
 {
   int status;
   char *stub_name;
   struct minimal_symbol *ms;
 
   /* Don't initialize twice.  */
   if (pd_able)
     return;
 
   /* Check application word size.  */
-  arch64 = register_size (target_gdbarch, 0) == 8;
+  arch64 = register_size (target_gdbarch (), 0) == 8;
 
   /* Check whether the application is pthreaded.  */
   stub_name = NULL;
   status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS,
                                     &pd_callbacks, &stub_name);
   if ((status != PTHDB_SUCCESS
        && status != PTHDB_NOT_PTHREADED) || !stub_name)
     return;
 
   /* Set a breakpoint on the returned stub function.  */
   if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL)))
     return;
   pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms);
-  if (!create_thread_event_breakpoint (target_gdbarch, pd_brk_addr))
+  if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr))
     return;
 
   /* Prepare for thread debugging.  */
   push_target (&aix_thread_ops);
   pd_able = 1;
 
   /* If we're debugging a core file or an attached inferior, the
      pthread library may already have been initialized, so try to
      activate thread debugging.  */
   pd_activate (1);
@@ skipping 35 matching lines @@
 {
   struct target_ops *beneath = find_target_beneath (ops);
   
   beneath->to_attach (beneath, args, from_tty);
   pd_activate (1);
 }
 
 /* Detach from the process attached to by aix_thread_attach().  */
 
 static void
-aix_thread_detach (struct target_ops *ops, char *args, int from_tty)
+aix_thread_detach (struct target_ops *ops, const char *args, int from_tty)
 {
   struct target_ops *beneath = find_target_beneath (ops);
 
   pd_disable ();
   beneath->to_detach (beneath, args, from_tty);
 }
 
 /* Tell the inferior process to continue running thread PID if != -1
    and all threads otherwise.  */
 
 static void
 aix_thread_resume (struct target_ops *ops,
                    ptid_t ptid, int step, enum gdb_signal sig)
 {
   struct thread_info *thread;
   pthdb_tid_t tid[2];
 
   if (!PD_TID (ptid))
     {
       struct cleanup *cleanup = save_inferior_ptid ();
       struct target_ops *beneath = find_target_beneath (ops);
       
-      inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
+      inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
       beneath->to_resume (beneath, ptid, step, sig);
       do_cleanups (cleanup);
     }
   else
     {
       thread = find_thread_ptid (ptid);
       if (!thread)
         error (_("aix-thread resume: unknown pthread %ld"),
-               TIDGET (ptid));
+               ptid_get_lwp (ptid));
 
       tid[0] = thread->private->tid;
       if (tid[0] == PTHDB_INVALID_TID)
         error (_("aix-thread resume: no tid for pthread %ld"),
-               TIDGET (ptid));
+               ptid_get_lwp (ptid));
       tid[1] = 0;
 
       if (arch64)
-        ptrace64aix (PTT_CONTINUE, tid[0], 1, 
+        ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1,
                      gdb_signal_to_host (sig), (void *) tid);
       else
-        ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
+        ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1,
                   gdb_signal_to_host (sig), (void *) tid);
     }
 }
 
 /* Wait for thread/process ID if != -1 or for any thread otherwise.
    If an error occurs, return -1, else return the pid of the stopped
    thread.  */
 
 static ptid_t
 aix_thread_wait (struct target_ops *ops,
                  ptid_t ptid, struct target_waitstatus *status, int options)
 {
   struct cleanup *cleanup = save_inferior_ptid ();
   struct target_ops *beneath = find_target_beneath (ops);
 
   pid_to_prc (&ptid);
 
-  inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
+  inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
   ptid = beneath->to_wait (beneath, ptid, status, options);
   do_cleanups (cleanup);
 
-  if (PIDGET (ptid) == -1)
+  if (ptid_get_pid (ptid) == -1)
     return pid_to_ptid (-1);
 
   /* Check whether libpthdebug might be ready to be initialized.  */
   if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED
       && status->value.sig == GDB_SIGNAL_TRAP)
     {
       struct regcache *regcache = get_thread_regcache (ptid);
       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 
       if (regcache_read_pc (regcache)
@@ skipping 196 matching lines @@
     {
       if (arch64)
         {
           if (!ptrace64aix (PTT_READ_GPRS, tid, 
                             (unsigned long) gprs64, 0, NULL))
             memset (gprs64, 0, sizeof (gprs64));
           supply_gprs64 (regcache, gprs64);
         }
       else
         {
-          if (!ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL))
+          if (!ptrace32 (PTT_READ_GPRS, tid, (addr_ptr) gprs32, 0, NULL))
             memset (gprs32, 0, sizeof (gprs32));
           for (i = 0; i < ppc_num_gprs; i++)
             supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]);
         }
     }
 
   /* Floating-point registers.  */
 
   if (ppc_floating_point_unit_p (gdbarch)
       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {
-      if (!ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL))
+      if (!ptrace32 (PTT_READ_FPRS, tid, (addr_ptr) fprs, 0, NULL))
         memset (fprs, 0, sizeof (fprs));
       supply_fprs (regcache, fprs);
     }
 
   /* Special-purpose registers.  */
 
   if (regno == -1 || special_register_p (gdbarch, regno))
     {
       if (arch64)
         {
           if (!ptrace64aix (PTT_READ_SPRS, tid, 
                             (unsigned long) &sprs64, 0, NULL))
             memset (&sprs64, 0, sizeof (sprs64));
           supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr,
                          sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr,
                          sprs64.pt_xer, sprs64.pt_fpscr);
         }
       else
         {
           struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-          if (!ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL))
+          if (!ptrace32 (PTT_READ_SPRS, tid, (addr_ptr) &sprs32, 0, NULL))
             memset (&sprs32, 0, sizeof (sprs32));
           supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr,
                          sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer,
                          sprs32.pt_fpscr);
 
           if (tdep->ppc_mq_regnum >= 0)
             regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
                                  (char *) &sprs32.pt_mq);
         }
     }
@@ skipping 274 matching lines @@
       if (arch64)
         {
           /* Pre-fetch: some regs may not be in the cache.  */
           ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL);
           fill_gprs64 (regcache, gprs64);
           ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL);
         }
       else
         {
           /* Pre-fetch: some regs may not be in the cache.  */
-          ptrace32 (PTT_READ_GPRS, tid, gprs32, 0, NULL);
+          ptrace32 (PTT_READ_GPRS, tid, (addr_ptr) gprs32, 0, NULL);
           fill_gprs32 (regcache, gprs32);
-          ptrace32 (PTT_WRITE_GPRS, tid, gprs32, 0, NULL);
+          ptrace32 (PTT_WRITE_GPRS, tid, (addr_ptr) gprs32, 0, NULL);
         }
     }
 
   /* Floating-point registers.  */
 
   if (ppc_floating_point_unit_p (gdbarch)
       && (regno == -1
           || (regno >= tdep->ppc_fp0_regnum
               && regno < tdep->ppc_fp0_regnum + ppc_num_fprs)))
     {
       /* Pre-fetch: some regs may not be in the cache.  */
-      ptrace32 (PTT_READ_FPRS, tid, (void *) fprs, 0, NULL);
+      ptrace32 (PTT_READ_FPRS, tid, (addr_ptr) fprs, 0, NULL);
       fill_fprs (regcache, fprs);
-      ptrace32 (PTT_WRITE_FPRS, tid, (void *) fprs, 0, NULL);
+      ptrace32 (PTT_WRITE_FPRS, tid, (addr_ptr) fprs, 0, NULL);
     }
 
   /* Special-purpose registers.  */
 
   if (regno == -1 || special_register_p (gdbarch, regno))
     {
       if (arch64)
         {
           /* Pre-fetch: some registers won't be in the cache.  */
           ptrace64aix (PTT_READ_SPRS, tid, 
@@ skipping 11 matching lines @@
              Use temporaries to work around this problem.  Also, add an
              assert here to make sure we fail if the system header files
              use "unsigned long", and the size of that type is not what
              the headers expect.  */
           uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer,
                    tmp_fpscr;
 
           gdb_assert (sizeof (sprs32.pt_iar) == 4);
 
           /* Pre-fetch: some registers won't be in the cache.  */
-          ptrace32 (PTT_READ_SPRS, tid, (int *) &sprs32, 0, NULL);
+          ptrace32 (PTT_READ_SPRS, tid, (addr_ptr) &sprs32, 0, NULL);
 
           fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr,
                        &tmp_ctr, &tmp_xer, &tmp_fpscr);
 
           sprs32.pt_iar = tmp_iar;
           sprs32.pt_msr = tmp_msr;
           sprs32.pt_cr = tmp_cr;
           sprs32.pt_lr = tmp_lr;
           sprs32.pt_ctr = tmp_ctr;
           sprs32.pt_xer = tmp_xer;
           sprs32.pt_fpscr = tmp_fpscr;
 
           if (tdep->ppc_mq_regnum >= 0)
             if (REG_VALID == regcache_register_status (regcache,
                                                        tdep->ppc_mq_regnum))
               regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
                                     &sprs32.pt_mq);
 
-          ptrace32 (PTT_WRITE_SPRS, tid, (int *) &sprs32, 0, NULL);
+          ptrace32 (PTT_WRITE_SPRS, tid, (addr_ptr) &sprs32, 0, NULL);
         }
     }
 }
 
 /* Store gdb's current view of the register set into the
    thread/process specified by inferior_ptid.  */
 
 static void
 aix_thread_store_registers (struct target_ops *ops,
                             struct regcache *regcache, int regno)
@@ skipping 23 matching lines @@
 static LONGEST
 aix_thread_xfer_partial (struct target_ops *ops, enum target_object object,
                          const char *annex, gdb_byte *readbuf,
                          const gdb_byte *writebuf,
                          ULONGEST offset, LONGEST len)
 {
   struct cleanup *old_chain = save_inferior_ptid ();
   LONGEST xfer;
   struct target_ops *beneath = find_target_beneath (ops);
 
-  inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
+  inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
   xfer = beneath->to_xfer_partial (beneath, object, annex,
                                    readbuf, writebuf, offset, len);
 
   do_cleanups (old_chain);
   return xfer;
 }
 
 /* Clean up after the inferior exits.  */
 
 static void
@@ skipping 135 matching lines @@
 
 /* Module startup initialization function, automagically called by
    init.c.  */
 
 void _initialize_aix_thread (void);
 
 void
 _initialize_aix_thread (void)
 {
   init_aix_thread_ops ();
-  add_target (&aix_thread_ops);
+  complete_target_initialization (&aix_thread_ops);
 
   /* Notice when object files get loaded and unloaded.  */
   observer_attach_new_objfile (new_objfile);
 
   add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread,
                            _("Set debugging of AIX thread module."),
                            _("Show debugging of AIX thread module."),
                            _("Enables debugging output (used to debug GDB)."),
                            NULL, NULL,
                            /* FIXME: i18n: Debugging of AIX thread
                               module is \"%d\".  */
                            &setdebuglist, &showdebuglist);
 }