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 749065c5e56bf542aa7ebdc8629836808790809c..8b1b0ed97f62750672370df382fbaebed6d85aef 100644 (file)
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -1023,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);
@@ -1041,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
     {
@@ -1078,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)
@@ -1116,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.  */
@@ -1125,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.  */
@@ -1144,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.  */
@@ -1177,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
@@ -1201,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
@@ -1349,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);
        }
     }
 }
@@ -1363,10 +1355,9 @@ 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->ptid ()))
-    beneath->fetch_registers (regcache, regno);
+    beneath ()->fetch_registers (regcache, regno);
   else
     {
       thread = find_thread_ptid (regcache->ptid ());
@@ -1391,8 +1382,7 @@ fill_gprs64 (const struct regcache *regcache, uint64_t *vals)
   for (regno = 0; regno < ppc_num_gprs; regno++)
     if (REG_VALID == regcache->get_register_status
                       (tdep->ppc_gp0_regnum + regno))
-      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
-                           vals + regno);
+      regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
 }
 
 static void 
@@ -1404,8 +1394,7 @@ fill_gprs32 (const struct regcache *regcache, uint32_t *vals)
   for (regno = 0; regno < ppc_num_gprs; regno++)
     if (REG_VALID == regcache->get_register_status
                       (tdep->ppc_gp0_regnum + regno))
-      regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno,
-                           vals + regno);
+      regcache->raw_collect (tdep->ppc_gp0_regnum + regno, vals + regno);
 }
 
 /* Store the floating point registers into a double array.  */
@@ -1424,8 +1413,7 @@ fill_fprs (const struct regcache *regcache, double *vals)
        regno < tdep->ppc_fp0_regnum + ppc_num_fprs;
        regno++)
     if (REG_VALID == regcache->get_register_status (regno))
-      regcache_raw_collect (regcache, regno,
-                           vals + regno - tdep->ppc_fp0_regnum);
+      regcache->raw_collect (regno, vals + regno - tdep->ppc_fp0_regnum);
 }
 
 /* Store the special registers into the specified 64-bit and 32-bit
@@ -1449,20 +1437,20 @@ fill_sprs64 (const struct regcache *regcache,
                                 (gdbarch, gdbarch_pc_regnum (gdbarch)));
 
   if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
-    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+    regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
+    regcache->raw_collect (tdep->ppc_ps_regnum, msr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+    regcache->raw_collect (tdep->ppc_cr_regnum, cr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+    regcache->raw_collect (tdep->ppc_lr_regnum, lr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+    regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+    regcache->raw_collect (tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
       && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+    regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
 }
 
 static void
@@ -1483,20 +1471,20 @@ fill_sprs32 (const struct regcache *regcache,
                                              gdbarch_pc_regnum (gdbarch)));
 
   if (REG_VALID == regcache->get_register_status (gdbarch_pc_regnum (gdbarch)))
-    regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar);
+    regcache->raw_collect (gdbarch_pc_regnum (gdbarch), iar);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_ps_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr);
+    regcache->raw_collect (tdep->ppc_ps_regnum, msr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_cr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr);
+    regcache->raw_collect (tdep->ppc_cr_regnum, cr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_lr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr);
+    regcache->raw_collect (tdep->ppc_lr_regnum, lr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_ctr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr);
+    regcache->raw_collect (tdep->ppc_ctr_regnum, ctr);
   if (REG_VALID == regcache->get_register_status (tdep->ppc_xer_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer);
+    regcache->raw_collect (tdep->ppc_xer_regnum, xer);
   if (tdep->ppc_fpscr_regnum >= 0
       && REG_VALID == regcache->get_register_status (tdep->ppc_fpscr_regnum))
-    regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr);
+    regcache->raw_collect (tdep->ppc_fpscr_regnum, fpscr);
 }
 
 /* Store all registers into pthread PDTID, which doesn't have a kernel
@@ -1534,14 +1522,12 @@ store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid)
       {
        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;
          }
       }
@@ -1694,8 +1680,7 @@ store_regs_kernel_thread (const struct regcache *regcache, int regno,
          if (tdep->ppc_mq_regnum >= 0)
            if (REG_VALID == regcache->get_register_status
                               (tdep->ppc_mq_regnum))
-             regcache_raw_collect (regcache, tdep->ppc_mq_regnum,
-                                   &sprs32.pt_mq);
+             regcache->raw_collect (tdep->ppc_mq_regnum, &sprs32.pt_mq);
 
          ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL);
        }
@@ -1710,10 +1695,9 @@ 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->ptid ()))
-    beneath->store_registers (regcache, regno);
+    beneath ()->store_registers (regcache, regno);
   else
     {
       thread = find_thread_ptid (regcache->ptid ());
@@ -1737,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.  */
@@ -1749,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 ();
@@ -1760,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.  */
@@ -1777,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().  */