Use std::unique_ptr in reg_buffer

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

diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index 410fb55e72713e318cc4a7f483b9c152585b656e..8b1b0ed97f62750672370df382fbaebed6d85aef 100644 (file)
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -108,18 +108,20 @@ struct pd_thread {
 
 /* This module's target-specific operations, active while pd_able is true.  */
 
+static const target_info aix_thread_target_info = {
+  "aix-threads",
+  N_("AIX pthread support"),
+  N_("AIX pthread support")
+};
+
 class aix_thread_target final : public target_ops
 {
 public:
   aix_thread_target ()
   { to_stratum = thread_stratum; }
 
-  const char *shortname () override
-  { return "aix-threads"; }
-  const char *longname () override
-  { return _("AIX pthread support"); }
-  const char *doc () override
-  { return _("AIX pthread support"); }
+  const target_info &info () const override
+  { return aix_thread_target_info; }
 
   void detach (inferior *, int) override;
   void resume (ptid_t, int, enum gdb_signal) override;
@@ -1021,7 +1023,7 @@ aix_thread_inferior_created (struct target_ops *ops, int from_tty)
 void
 aix_thread_target::detach (inferior *inf, int from_tty)
 {
-  struct target_ops *beneath = find_target_beneath (this);
+  target_ops *beneath = this->beneath ();
 
   pd_disable ();
   beneath->detach (inf, from_tty);
@@ -1039,10 +1041,9 @@ aix_thread_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
   if (!PD_TID (ptid))
     {
       scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
-      struct target_ops *beneath = find_target_beneath (this);
       
       inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
-      beneath->resume (ptid, step, sig);
+      beneath ()->resume (ptid, step, sig);
     }
   else
     {
@@ -1076,15 +1077,13 @@ ptid_t
 aix_thread_target::wait (ptid_t ptid, struct target_waitstatus *status,
                         int options)
 {
-  struct target_ops *beneath = find_target_beneath (this);
-
   {
     scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 
     pid_to_prc (&ptid);
 
     inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
-    ptid = beneath->wait (ptid, status, options);
+    ptid = beneath ()->wait (ptid, status, options);
   }
 
   if (ptid_get_pid (ptid) == -1)
@@ -1114,8 +1113,8 @@ supply_gprs64 (struct regcache *regcache, uint64_t *vals)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
-    regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno,
-                        (char *) (vals + regno));
+    regcache->raw_supply (tdep->ppc_gp0_regnum + regno,
+                         (char *) (vals + regno));
 }
 
 /* Record that 32-bit register REGNO contains VAL.  */
@@ -1123,7 +1122,7 @@ supply_gprs64 (struct regcache *regcache, uint64_t *vals)
 static void
 supply_reg32 (struct regcache *regcache, int regno, uint32_t val)
 {
-  regcache_raw_supply (regcache, regno, (char *) &val);
+  regcache->raw_supply (regno, (char *) &val);
 }
 
 /* Record that the floating-point registers contain VALS.  */
@@ -1142,8 +1141,8 @@ supply_fprs (struct regcache *regcache, double *vals)
   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));
+    regcache->raw_supply (regno,
+                         (char *) (vals + regno - tdep->ppc_fp0_regnum));
 }
 
 /* Predicate to test whether given register number is a "special" register.  */
@@ -1175,16 +1174,14 @@ supply_sprs64 (struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
-                      (char *) &iar);
-  regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
-  regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
-  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+  regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+  regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+  regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+  regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
   if (tdep->ppc_fpscr_regnum >= 0)
-    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
-                        (char *) &fpscr);
+    regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
 }
 
 /* Record that the special registers contain the specified 32-bit
@@ -1199,16 +1196,14 @@ supply_sprs32 (struct regcache *regcache,
   struct gdbarch *gdbarch = regcache->arch ();
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
-  regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch),
-                      (char *) &iar);
-  regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr);
-  regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr);
-  regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr);
-  regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr);
-  regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer);
+  regcache->raw_supply (gdbarch_pc_regnum (gdbarch), (char *) &iar);
+  regcache->raw_supply (tdep->ppc_ps_regnum, (char *) &msr);
+  regcache->raw_supply (tdep->ppc_cr_regnum, (char *) &cr);
+  regcache->raw_supply (tdep->ppc_lr_regnum, (char *) &lr);
+  regcache->raw_supply (tdep->ppc_ctr_regnum, (char *) &ctr);
+  regcache->raw_supply (tdep->ppc_xer_regnum, (char *) &xer);
   if (tdep->ppc_fpscr_regnum >= 0)
-    regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum,
-                        (char *) &fpscr);
+    regcache->raw_supply (tdep->ppc_fpscr_regnum, (char *) &fpscr);
 }
 
 /* Fetch all registers from pthread PDTID, which doesn't have a kernel
@@ -1347,8 +1342,7 @@ fetch_regs_kernel_thread (struct regcache *regcache, int regno,
                         sprs32.pt_fpscr);
 
          if (tdep->ppc_mq_regnum >= 0)
-           regcache_raw_supply (regcache, tdep->ppc_mq_regnum,
-                                (char *) &sprs32.pt_mq);
+           regcache->raw_supply (tdep->ppc_mq_regnum, (char *) &sprs32.pt_mq);
        }
     }
 }
@@ -1361,13 +1355,12 @@ aix_thread_target::fetch_registers (struct regcache *regcache, int regno)
 {
   struct thread_info *thread;
   pthdb_tid_t tid;
-  struct target_ops *beneath = find_target_beneath (this);
 
-  if (!PD_TID (regcache_get_ptid (regcache)))
-    beneath->fetch_registers (regcache, regno);
+  if (!PD_TID (regcache->ptid ()))
+    beneath ()->fetch_registers (regcache, regno);
   else
     {
-      thread = find_thread_ptid (regcache_get_ptid (regcache));
+      thread = find_thread_ptid (regcache->ptid ());
       aix_thread_info *priv = get_aix_thread_info (thread);
       tid = priv->tid;
 
@@ -1387,10 +1380,9 @@ fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
-    if (REG_VALID == regcache_register_status (regcache,
-                                              tdep->ppc_gp0_regnum + regno))
-      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
-                           vals + regno);
+    if (REG_VALID == regcache->get_register_status
+                      (tdep->ppc_gp0_regnum + regno))
+      regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
 }
 
 static void 
@@ -1400,10 +1392,9 @@ fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
   int regno;
 
   for (regno = 0; regno < ppc_num_gprs; regno++)
-    if (REG_VALID == regcache_register_status (regcache,
-                                              tdep->ppc_gp0_regnum + regno))
-      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
-                           vals + regno);
+    if (REG_VALID == regcache->get_register_status
+                      (tdep->ppc_gp0_regnum + regno))
+      regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
 }
 
 /* Store the floating point registers into a double array.  */
@@ -1421,9 +1412,8 @@ fill_fprs (const struct regcache *regcache, double *vals)
   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 - tdep->ppc_fp0_regnum);
+    if (REG_VALID == regcache->get_register_status (regno))
+      regcache->raw_collect (regno, vals + regno - tdep->ppc_fp0_regnum);
 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
@@ -1446,23 +1436,21 @@ fill_sprs64 (const struct regcache *regcache,
   gdb_assert (sizeof (*iar) == register_size
                                 (gdbarch, gdbarch_pc_regnum (gdbarch)));
 
-  if (REG_VALID == regcache_register_status (regcache,
-                                            gdbarch_pc_regnum (gdbarch)))
-    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+  if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
+    regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
+    regcache->raw_collect (tdep->ppc_ps_regnum, msr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
+    regcache->raw_collect (tdep->ppc_cr_regnum, cr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
+    regcache->raw_collect (tdep->ppc_lr_regnum, lr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
+    regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
+    regcache->raw_collect (tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
-      && REG_VALID == regcache_register_status (regcache,
-                                               tdep->ppc_fpscr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+      && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
+    regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
 }
 
 static void
@@ -1482,22 +1470,21 @@ fill_sprs32 (const struct regcache *regcache,
   gdb_assert (sizeof (*iar) == register_size (gdbarch,
                                              gdbarch_pc_regnum (gdbarch)));
 
-  if (REG_VALID == regcache_register_status (regcache,
-                                            gdbarch_pc_regnum (gdbarch)))
-    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
-  if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+  if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
+    regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
+    regcache->raw_collect (tdep->ppc_ps_regnum, msr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
+    regcache->raw_collect (tdep->ppc_cr_regnum, cr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
+    regcache->raw_collect (tdep->ppc_lr_regnum, lr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
+    regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
+  if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
+    regcache->raw_collect (tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
-      && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+      && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
+    regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
 }
 
 /* Store all registers into pthread PDTID, which doesn't have a kernel
@@ -1531,19 +1518,16 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
   /* Collect general-purpose register values from the regcache.  */
 
   for (i = 0; i < ppc_num_gprs; i++)
-    if (REG_VALID == regcache_register_status (regcache,
-                                              tdep->ppc_gp0_regnum + i))
+    if (REG_VALID == regcache->get_register_status (tdep->ppc_gp0_regnum + i))
       {
        if (arch64)
          {
-           regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
-                                 (void *) &int64);
+           regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int64);
            ctx.gpr[i] = int64;
          }
        else
          {
-           regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i,
-                                 (void *) &int32);
+           regcache->raw_collect (tdep->ppc_gp0_regnum + i, (void *) &int32);
            ctx.gpr[i] = int32;
          }
       }
@@ -1567,23 +1551,20 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
 
       fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr,
                             &tmp_xer, &tmp_fpscr);
-      if (REG_VALID == regcache_register_status (regcache,
-                                                gdbarch_pc_regnum (gdbarch)))
+      if (REG_VALID == regcache->get_register_status
+                        (gdbarch_pc_regnum (gdbarch)))
        ctx.iar = tmp_iar;
-      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
        ctx.msr = tmp_msr;
-      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
        ctx.cr  = tmp_cr;
-      if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
        ctx.lr  = tmp_lr;
-      if (REG_VALID == regcache_register_status (regcache,
-                                                tdep->ppc_ctr_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
        ctx.ctr = tmp_ctr;
-      if (REG_VALID == regcache_register_status (regcache,
-                                                tdep->ppc_xer_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
        ctx.xer = tmp_xer;
-      if (REG_VALID == regcache_register_status (regcache,
-                                                tdep->ppc_xer_regnum))
+      if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
        ctx.fpscr = tmp_fpscr;
     }
 
@@ -1697,10 +1678,9 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
          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);
+           if (REG_VALID == regcache->get_register_status
+                              (tdep->ppc_mq_regnum))
+             regcache->raw_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
 
          ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
        }
@@ -1715,13 +1695,12 @@ aix_thread_target::store_registers (struct regcache *regcache, int regno)
 {
   struct thread_info *thread;
   pthdb_tid_t tid;
-  struct target_ops *beneath = find_target_beneath (this);
 
-  if (!PD_TID (regcache_get_ptid (regcache)))
-    beneath->store_registers (regcache, regno);
+  if (!PD_TID (regcache->ptid ()))
+    beneath ()->store_registers (regcache, regno);
   else
     {
-      thread = find_thread_ptid (regcache_get_ptid (regcache));
+      thread = find_thread_ptid (regcache->ptid ());
       aix_thread_info *priv = get_aix_thread_info (thread);
       tid = priv->tid;
 
@@ -1742,11 +1721,10 @@ aix_thread_target::xfer_partial (enum target_object object,
                                 ULONGEST *xfered_len)
 {
   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
-  struct target_ops *beneath = find_target_beneath (this);
 
   inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
-  return beneath->xfer_partial (object, annex, readbuf,
-                               writebuf, offset, len, xfered_len);
+  return beneath ()->xfer_partial (object, annex, readbuf,
+                                  writebuf, offset, len, xfered_len);
 }
 
 /* Clean up after the inferior exits.  */
@@ -1754,7 +1732,7 @@ aix_thread_target::xfer_partial (enum target_object object,
 void
 aix_thread_target::mourn_inferior ()
 {
-  struct target_ops *beneath = find_target_beneath (this);
+  target_ops *beneath = beneath ();
 
   pd_deactivate ();
   beneath->mourn_inferior ();
@@ -1765,10 +1743,8 @@ aix_thread_target::mourn_inferior ()
 bool
 aix_thread_target::thread_alive (ptid_t ptid)
 {
-  struct target_ops *beneath = find_target_beneath (this);
-
   if (!PD_TID (ptid))
-    return beneath->thread_alive (ptid);
+    return beneath ()->thread_alive (ptid);
 
   /* We update the thread list every time the child stops, so all
      valid threads should be in the thread list.  */
@@ -1782,10 +1758,9 @@ const char *
 aix_thread_target::pid_to_str (ptid_t ptid)
 {
   static char *ret = NULL;
-  struct target_ops *beneath = find_target_beneath (this);
 
   if (!PD_TID (ptid))
-    return beneath->pid_to_str (ptid);
+    return beneath ()->pid_to_str (ptid);
 
   /* Free previous return value; a new one will be allocated by
      xstrprintf().  */