2004-07-21 Andrew Cagney <cagney@gnu.org>

[deliverable/binutils-gdb.git] / gdb / ia64-aix-nat.c

diff --git a/gdb/ia64-aix-nat.c b/gdb/ia64-aix-nat.c
index c41cc7cc88c68fd81474c351c146a462a84dd401..893f095fa5700698369fa0dfee395c8362064d98 100644 (file)
--- a/gdb/ia64-aix-nat.c
+++ b/gdb/ia64-aix-nat.c
@@ -1,5 +1,6 @@
-/* Functions specific to running gdb native on IA-64 running AIX.
-   Copyright 2000, 2001 Free Software Foundation, Inc.
+/* Low level interface to IA-64 running AIX for GDB, the GNU debugger.
+
+   Copyright 2000, 2001, 2003 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -41,41 +42,55 @@ supply_gregset (prgregset_t *gregsetp)
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
-      supply_register (regi, 
-                       (char *) &(gregsetp->__gpr[regi - IA64_GR0_REGNUM]));
+      regcache_raw_supply (current_regcache, regi, 
+                          (char *) &(gregsetp->__gpr[regi - IA64_GR0_REGNUM]));
     }
 
   for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
     {
-      supply_register (regi, 
-                       (char *) &(gregsetp->__br[regi - IA64_BR0_REGNUM]));
+      regcache_raw_supply (current_regcache, regi, 
+                          (char *) &(gregsetp->__br[regi - IA64_BR0_REGNUM]));
     }
 
-  supply_register (IA64_PSR_REGNUM, (char *) &(gregsetp->__psr));
-  supply_register (IA64_IP_REGNUM, (char *) &(gregsetp->__ip));
-  supply_register (IA64_CFM_REGNUM, (char *) &(gregsetp->__ifs));
-  supply_register (IA64_RSC_REGNUM, (char *) &(gregsetp->__rsc));
-  supply_register (IA64_BSP_REGNUM, (char *) &(gregsetp->__bsp));
-  supply_register (IA64_BSPSTORE_REGNUM, (char *) &(gregsetp->__bspstore));
-  supply_register (IA64_RNAT_REGNUM, (char *) &(gregsetp->__rnat));
-  supply_register (IA64_PFS_REGNUM, (char *) &(gregsetp->__pfs));
-  supply_register (IA64_UNAT_REGNUM, (char *) &(gregsetp->__unat));
-  supply_register (IA64_PR_REGNUM, (char *) &(gregsetp->__preds));
-  supply_register (IA64_CCV_REGNUM, (char *) &(gregsetp->__ccv));
-  supply_register (IA64_LC_REGNUM, (char *) &(gregsetp->__lc));
-  supply_register (IA64_EC_REGNUM, (char *) &(gregsetp->__ec));
+  regcache_raw_supply (current_regcache, IA64_PSR_REGNUM,
+                      (char *) &(gregsetp->__psr));
+  regcache_raw_supply (current_regcache, IA64_IP_REGNUM,
+                      (char *) &(gregsetp->__ip));
+  regcache_raw_supply (current_regcache, IA64_CFM_REGNUM,
+                      (char *) &(gregsetp->__ifs));
+  regcache_raw_supply (current_regcache, IA64_RSC_REGNUM,
+                      (char *) &(gregsetp->__rsc));
+  regcache_raw_supply (current_regcache, IA64_BSP_REGNUM,
+                      (char *) &(gregsetp->__bsp));
+  regcache_raw_supply (current_regcache, IA64_BSPSTORE_REGNUM,
+                      (char *) &(gregsetp->__bspstore));
+  regcache_raw_supply (current_regcache, IA64_RNAT_REGNUM,
+                      (char *) &(gregsetp->__rnat));
+  regcache_raw_supply (current_regcache, IA64_PFS_REGNUM,
+                      (char *) &(gregsetp->__pfs));
+  regcache_raw_supply (current_regcache, IA64_UNAT_REGNUM,
+                      (char *) &(gregsetp->__unat));
+  regcache_raw_supply (current_regcache, IA64_PR_REGNUM,
+                      (char *) &(gregsetp->__preds));
+  regcache_raw_supply (current_regcache, IA64_CCV_REGNUM,
+                      (char *) &(gregsetp->__ccv));
+  regcache_raw_supply (current_regcache, IA64_LC_REGNUM,
+                      (char *) &(gregsetp->__lc));
+  regcache_raw_supply (current_regcache, IA64_EC_REGNUM,
+                      (char *) &(gregsetp->__ec));
   /* FIXME: __nats */
-  supply_register (IA64_FPSR_REGNUM, (char *) &(gregsetp->__fpsr));
+  regcache_raw_supply (current_regcache, IA64_FPSR_REGNUM,
+                      (char *) &(gregsetp->__fpsr));
 
   /* These (for the most part) are pseudo registers and are obtained
      by other means.  Those that aren't are already handled by the
      code above.  */
   for (regi = IA64_GR32_REGNUM; regi <= IA64_GR127_REGNUM; regi++)
-    register_valid[regi] = 1;
+    deprecated_register_valid[regi] = 1;
   for (regi = IA64_PR0_REGNUM; regi <= IA64_PR63_REGNUM; regi++)
-    register_valid[regi] = 1;
+    deprecated_register_valid[regi] = 1;
   for (regi = IA64_VFP_REGNUM; regi <= NUM_REGS; regi++)
-    register_valid[regi] = 1;
+    deprecated_register_valid[regi] = 1;
 }
 
 void
@@ -85,8 +100,8 @@ fill_gregset (prgregset_t *gregsetp, int regno)
 
 #define COPY_REG(_fld_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
-    memcpy (&(gregsetp->_fld_), &registers[REGISTER_BYTE (_regi_)], \
-           REGISTER_RAW_SIZE (_regi_))
+    memcpy (&(gregsetp->_fld_), &deprecated_registers[DEPRECATED_REGISTER_BYTE (_regi_)], \
+           DEPRECATED_REGISTER_RAW_SIZE (_regi_))
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
@@ -108,11 +123,11 @@ fill_gregset (prgregset_t *gregsetp, int regno)
   if (regno == IA64_BSP_REGNUM || regno == -1)
     {
       memcpy (&(gregsetp->__bspstore),
-             &registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
-             REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
-      memcpy (&registers[REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
-             &registers[REGISTER_BYTE (IA64_BSP_REGNUM)],
-             REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
+             &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
+             DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
+      memcpy (&deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSPSTORE_REGNUM)],
+             &deprecated_registers[DEPRECATED_REGISTER_BYTE (IA64_BSP_REGNUM)],
+             DEPRECATED_REGISTER_RAW_SIZE (IA64_BSP_REGNUM));
     }
 
 #if 0
@@ -135,10 +150,10 @@ fill_gregset (prgregset_t *gregsetp, int regno)
 void
 supply_fpregset (prfpregset_t *fpregsetp)
 {
-  register int regi;
+  int regi;
 
   for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
-    supply_register (regi, 
+    regcache_raw_supply (current_regcache, regi, 
                      (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]));
 }
 
@@ -153,9 +168,9 @@ fill_fpregset (prfpregset_t *fpregsetp, int regno)
     {
       if ((regno == -1) || (regno == regi))
        {
-         from = (char *) &registers[REGISTER_BYTE (regi)];
+         from = (char *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regi)];
          to = (char *) &(fpregsetp->__fpr[regi - IA64_FR0_REGNUM]);
-         memcpy (to, from, REGISTER_RAW_SIZE (regi));
+         memcpy (to, from, DEPRECATED_REGISTER_RAW_SIZE (regi));
        }
     }
 }