Merge GDB 7.5.1

gdb/aix-thread.c

 /* Low level interface for debugging AIX 4.3+ pthreads.
 
    Copyright (C) 1999-2000, 2002, 2007-2012 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
@@ skipping 952 matching lines @@
 
   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 target_signal sig)
+                   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));
       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));
 
       tid[0] = thread->private->tid;
       if (tid[0] == PTHDB_INVALID_TID)
         error (_("aix-thread resume: no tid for pthread %ld"),
                TIDGET (ptid));
       tid[1] = 0;
 
       if (arch64)
         ptrace64aix (PTT_CONTINUE, tid[0], 1, 
-                     target_signal_to_host (sig), (void *) tid);
+                     gdb_signal_to_host (sig), (void *) tid);
       else
         ptrace32 (PTT_CONTINUE, tid[0], (int *) 1,
-                  target_signal_to_host (sig), (void *) tid);
+                  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));
   ptid = beneath->to_wait (beneath, ptid, status, options);
   do_cleanups (cleanup);
 
   if (PIDGET (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 == TARGET_SIGNAL_TRAP)
+      && 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)
           - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr)
         return pd_activate (0);
     }
 
   return pd_update (0);
@@ skipping 26 matching lines @@
 supply_fprs (struct regcache *regcache, double *vals)
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */
   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 
-  for (regno = 0; regno < ppc_num_fprs; regno++)
-    regcache_raw_supply (regcache, regno + tdep->ppc_fp0_regnum,
-                         (char *) (vals + regno));
+  for (regno = tdep->ppc_fp0_regnum;
+       regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
+       regno++)
+    regcache_raw_supply (regcache, regno,
+                         (char *) (vals + regno - tdep->ppc_fp0_regnum));
 }
 
 /* Predicate to test whether given register number is a "special" register.  */
 static int
 special_register_p (struct gdbarch *gdbarch, int regno)
 {
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   return regno == gdbarch_pc_regnum (gdbarch)
       || regno == tdep->ppc_ps_regnum
@@ skipping 258 matching lines @@
   int regno;
 
   /* This function should never be called on architectures without
      floating-point registers.  */
   gdb_assert (ppc_floating_point_unit_p (gdbarch));
 
   for (regno = tdep->ppc_fp0_regnum;
        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
        regno++)
     if (REG_VALID == regcache_register_status (regcache, regno))
-      regcache_raw_collect (regcache, regno, vals + regno);
+      regcache_raw_collect (regcache, regno,
+                            vals + regno - tdep->ppc_fp0_regnum);
 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
    locations.  */
 
 static void
 fill_sprs64 (const struct regcache *regcache,
              uint64_t *iar, uint64_t *msr, uint32_t *cr,
              uint64_t *lr, uint64_t *ctr, uint32_t *xer,
              uint32_t *fpscr)
@@ skipping 452 matching lines @@
   aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str;
   aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info;
   aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid;
   aix_thread_ops.to_stratum = thread_stratum;
   aix_thread_ops.to_magic = OPS_MAGIC;
 }
 
 /* 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);
 
   /* 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);
 }