projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* mips-tdep.c (mips_gdbarch_init): Use Tag_GNU_MIPS_ABI_FP to
[deliverable/binutils-gdb.git] / gdb / ia64-linux-nat.c
diff --git a/gdb/ia64-linux-nat.c b/gdb/ia64-linux-nat.c
index 989550a81203c8b8f5100aefaa4d17c44156bc89..f42ca0ffc3087aafcff4660d6af3f1c5757c37bf 100644 (file)
--- a/gdb/ia64-linux-nat.c
+++ b/gdb/ia64-linux-nat.c
@@ -308,7 +308,7 @@ ia64_register_addr (int regno)
 {
   CORE_ADDR addr;
 
-  if (regno < 0 || regno >= NUM_REGS)
+  if (regno < 0 || regno >= gdbarch_num_regs (current_gdbarch))
     error (_("Invalid register number %d."), regno);
 
   if (u_offsets[regno] == -1)
@@ -322,7 +322,9 @@ ia64_register_addr (int regno)
 static int
 ia64_cannot_fetch_register (int regno)
 {
-  return regno < 0 || regno >= NUM_REGS || u_offsets[regno] == -1;
+  return regno < 0
+        || regno >= gdbarch_num_regs (current_gdbarch)
+        || u_offsets[regno] == -1;
 }
 
 static int
@@ -357,70 +359,58 @@ ia64_cannot_store_register (int regno)
      were previously read from the inferior process to be written
      back.)  */
 
-  return regno < 0 || regno >= NUM_REGS || u_offsets[regno] == -1
+  return regno < 0
+        || regno >= gdbarch_num_regs (current_gdbarch)
+        || u_offsets[regno] == -1
          || regno == IA64_BSPSTORE_REGNUM;
 }
 
 void
-supply_gregset (gregset_t *gregsetp)
+supply_gregset (struct regcache *regcache, const gregset_t *gregsetp)
 {
   int regi;
-  greg_t *regp = (greg_t *) gregsetp;
+  const greg_t *regp = (const greg_t *) gregsetp;
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
-      regcache_raw_supply (current_regcache, regi,
-                          (char *) (regp + (regi - IA64_GR0_REGNUM)));
+      regcache_raw_supply (regcache, regi, regp + (regi - IA64_GR0_REGNUM));
     }
 
   /* FIXME: NAT collection bits are at index 32; gotta deal with these
      somehow... */
 
-  regcache_raw_supply (current_regcache, IA64_PR_REGNUM, (char *) (regp + 33));
+  regcache_raw_supply (regcache, IA64_PR_REGNUM, regp + 33);
 
   for (regi = IA64_BR0_REGNUM; regi <= IA64_BR7_REGNUM; regi++)
     {
-      regcache_raw_supply (current_regcache, regi,
-                          (char *) (regp + 34 + (regi - IA64_BR0_REGNUM)));
+      regcache_raw_supply (regcache, regi,
+                          regp + 34 + (regi - IA64_BR0_REGNUM));
     }
 
-  regcache_raw_supply (current_regcache, IA64_IP_REGNUM,
-                      (char *) (regp + 42));
-  regcache_raw_supply (current_regcache, IA64_CFM_REGNUM,
-                      (char *) (regp + 43));
-  regcache_raw_supply (current_regcache, IA64_PSR_REGNUM,
-                      (char *) (regp + 44));
-  regcache_raw_supply (current_regcache, IA64_RSC_REGNUM,
-                      (char *) (regp + 45));
-  regcache_raw_supply (current_regcache, IA64_BSP_REGNUM,
-                      (char *) (regp + 46));
-  regcache_raw_supply (current_regcache, IA64_BSPSTORE_REGNUM,
-                      (char *) (regp + 47));
-  regcache_raw_supply (current_regcache, IA64_RNAT_REGNUM,
-                      (char *) (regp + 48));
-  regcache_raw_supply (current_regcache, IA64_CCV_REGNUM,
-                      (char *) (regp + 49));
-  regcache_raw_supply (current_regcache, IA64_UNAT_REGNUM,
-                      (char *) (regp + 50));
-  regcache_raw_supply (current_regcache, IA64_FPSR_REGNUM,
-                      (char *) (regp + 51));
-  regcache_raw_supply (current_regcache, IA64_PFS_REGNUM,
-                      (char *) (regp + 52));
-  regcache_raw_supply (current_regcache, IA64_LC_REGNUM,
-                      (char *) (regp + 53));
-  regcache_raw_supply (current_regcache, IA64_EC_REGNUM,
-                      (char *) (regp + 54));
+  regcache_raw_supply (regcache, IA64_IP_REGNUM, regp + 42);
+  regcache_raw_supply (regcache, IA64_CFM_REGNUM, regp + 43);
+  regcache_raw_supply (regcache, IA64_PSR_REGNUM, regp + 44);
+  regcache_raw_supply (regcache, IA64_RSC_REGNUM, regp + 45);
+  regcache_raw_supply (regcache, IA64_BSP_REGNUM, regp + 46);
+  regcache_raw_supply (regcache, IA64_BSPSTORE_REGNUM, regp + 47);
+  regcache_raw_supply (regcache, IA64_RNAT_REGNUM, regp + 48);
+  regcache_raw_supply (regcache, IA64_CCV_REGNUM, regp + 49);
+  regcache_raw_supply (regcache, IA64_UNAT_REGNUM, regp + 50);
+  regcache_raw_supply (regcache, IA64_FPSR_REGNUM, regp + 51);
+  regcache_raw_supply (regcache, IA64_PFS_REGNUM, regp + 52);
+  regcache_raw_supply (regcache, IA64_LC_REGNUM, regp + 53);
+  regcache_raw_supply (regcache, IA64_EC_REGNUM, regp + 54);
 }
 
 void
-fill_gregset (gregset_t *gregsetp, int regno)
+fill_gregset (const struct regcache *regcache, gregset_t *gregsetp, int regno)
 {
   int regi;
   greg_t *regp = (greg_t *) gregsetp;
 
 #define COPY_REG(_idx_,_regi_) \
   if ((regno == -1) || regno == _regi_) \
-    regcache_raw_collect (current_regcache, _regi_, regp + _idx_)
+    regcache_raw_collect (regcache, _regi_, regp + _idx_)
 
   for (regi = IA64_GR0_REGNUM; regi <= IA64_GR31_REGNUM; regi++)
     {
@@ -456,15 +446,15 @@ fill_gregset (gregset_t *gregsetp, int regno)
    idea of the current floating point register values. */
 
 void
-supply_fpregset (fpregset_t *fpregsetp)
+supply_fpregset (struct regcache *regcache, const fpregset_t *fpregsetp)
 {
   int regi;
-  char *from;
+  const char *from;
 
   for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
     {
-      from = (char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
-      regcache_raw_supply (current_regcache, regi, from);
+      from = (const char *) &((*fpregsetp)[regi - IA64_FR0_REGNUM]);
+      regcache_raw_supply (regcache, regi, from);
     }
 }
 
@@ -474,14 +464,15 @@ supply_fpregset (fpregset_t *fpregsetp)
    them all. */
 
 void
-fill_fpregset (fpregset_t *fpregsetp, int regno)
+fill_fpregset (const struct regcache *regcache,
+              fpregset_t *fpregsetp, int regno)
 {
   int regi;
 
   for (regi = IA64_FR0_REGNUM; regi <= IA64_FR127_REGNUM; regi++)
     {
       if ((regno == -1) || (regno == regi))
-       regcache_raw_collect (current_regcache, regi,
+       regcache_raw_collect (regcache, regi,
                              &((*fpregsetp)[regi - IA64_FR0_REGNUM]));
     }
 }
@@ -490,16 +481,16 @@ fill_fpregset (fpregset_t *fpregsetp, int regno)
 #define IA64_PSR_DD (1UL << 39)
 
 static void
-enable_watchpoints_in_psr (ptid_t ptid)
+enable_watchpoints_in_psr (struct regcache *regcache)
 {
-  CORE_ADDR psr;
+  ULONGEST psr;
 
-  psr = read_register_pid (IA64_PSR_REGNUM, ptid);
+  regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr);
   if (!(psr & IA64_PSR_DB))
     {
       psr |= IA64_PSR_DB;      /* Set the db bit - this enables hardware
                                   watchpoints and breakpoints. */
-      write_register_pid (IA64_PSR_REGNUM, psr, ptid);
+      regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr);
     }
 }
 
@@ -604,7 +595,7 @@ ia64_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw)
     }
 
   store_debug_register_pair (ptid, idx, &dbr_addr, &dbr_mask);
-  enable_watchpoints_in_psr (ptid);
+  enable_watchpoints_in_psr (get_current_regcache ());
 
   return 0;
 }
@@ -641,6 +632,7 @@ ia64_linux_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
   int tid;
   struct siginfo siginfo;
   ptid_t ptid = inferior_ptid;
+  struct regcache *regcache = get_current_regcache ();
 
   tid = TIDGET(ptid);
   if (tid == 0)
@@ -653,10 +645,10 @@ ia64_linux_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p)
       (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
     return 0;
 
-  psr = read_register_pid (IA64_PSR_REGNUM, ptid);
+  regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr);
   psr |= IA64_PSR_DD;  /* Set the dd bit - this will disable the watchpoint
                            for the next instruction */
-  write_register_pid (IA64_PSR_REGNUM, psr, ptid);
+  regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr);
 
   *addr_p = (CORE_ADDR)siginfo.si_addr;
   return 1;
@@ -679,7 +671,7 @@ ia64_linux_can_use_hw_breakpoint (int type, int cnt, int othertype)
 /* Fetch register REGNUM from the inferior.  */
 
 static void
-ia64_linux_fetch_register (int regnum)
+ia64_linux_fetch_register (struct regcache *regcache, int regnum)
 {
   CORE_ADDR addr;
   size_t size;
@@ -688,7 +680,7 @@ ia64_linux_fetch_register (int regnum)
 
   if (ia64_cannot_fetch_register (regnum))
     {
-      regcache_raw_supply (current_regcache, regnum, NULL);
+      regcache_raw_supply (regcache, regnum, NULL);
       return;
     }
 
@@ -712,30 +704,31 @@ ia64_linux_fetch_register (int regnum)
       buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)addr, 0);
       if (errno != 0)
        error (_("Couldn't read register %s (#%d): %s."),
-              REGISTER_NAME (regnum), regnum, safe_strerror (errno));
+              gdbarch_register_name (current_gdbarch, regnum),
+              regnum, safe_strerror (errno));
 
       addr += sizeof (PTRACE_TYPE_RET);
     }
-  regcache_raw_supply (current_regcache, regnum, buf);
+  regcache_raw_supply (regcache, regnum, buf);
 }
 
 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
    for all registers.  */
 
 static void
-ia64_linux_fetch_registers (int regnum)
+ia64_linux_fetch_registers (struct regcache *regcache, int regnum)
 {
   if (regnum == -1)
-    for (regnum = 0; regnum < NUM_REGS; regnum++)
-      ia64_linux_fetch_register (regnum);
+    for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++)
+      ia64_linux_fetch_register (regcache, regnum);
   else
-    ia64_linux_fetch_register (regnum);
+    ia64_linux_fetch_register (regcache, regnum);
 }
 
 /* Store register REGNUM into the inferior.  */
 
 static void
-ia64_linux_store_register (int regnum)
+ia64_linux_store_register (const struct regcache *regcache, int regnum)
 {
   CORE_ADDR addr;
   size_t size;
@@ -759,14 +752,15 @@ ia64_linux_store_register (int regnum)
   buf = alloca (size);
 
   /* Write the register contents into the inferior a chunk at a time.  */
-  regcache_raw_collect (current_regcache, regnum, buf);
+  regcache_raw_collect (regcache, regnum, buf);
   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
     {
       errno = 0;
       ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]);
       if (errno != 0)
        error (_("Couldn't write register %s (#%d): %s."),
-              REGISTER_NAME (regnum), regnum, safe_strerror (errno));
+              gdbarch_register_name (current_gdbarch, regnum),
+              regnum, safe_strerror (errno));
 
       addr += sizeof (PTRACE_TYPE_RET);
     }
@@ -776,13 +770,13 @@ ia64_linux_store_register (int regnum)
    this for all registers.  */
 
 static void
-ia64_linux_store_registers (int regnum)
+ia64_linux_store_registers (struct regcache *regcache, int regnum)
 {
   if (regnum == -1)
-    for (regnum = 0; regnum < NUM_REGS; regnum++)
-      ia64_linux_store_register (regnum);
+    for (regnum = 0; regnum < gdbarch_num_regs (current_gdbarch); regnum++)
+      ia64_linux_store_register (regcache, regnum);
   else
-    ia64_linux_store_register (regnum);
+    ia64_linux_store_register (regcache, regnum);
 }
 
 
GDB Binutils - Deliverables
This page took 0.027191 seconds and 4 git commands to generate.