2007-10-08 Markus Deuling <deuling@de.ibm.com>

	* regcache.c (init_regcache_descr, register_type, read_pc_pid)
	(write_pc_pid, regcache_dump): Replace current_gdbarch by gdbarch.
	* regcache.c (regcache_raw_write): Use get_regcache_arch or
	get_frame_arch to get at the current architecture by regcache or by
	frame, respectively.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index a0eec9e..1a7afee 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,13 @@
 2007-10-08  Markus Deuling  <deuling@de.ibm.com>
 
+       * regcache.c (init_regcache_descr, register_type, read_pc_pid)
+       (write_pc_pid, regcache_dump): Replace current_gdbarch by gdbarch.
+       * regcache.c (regcache_raw_write): Use get_regcache_arch or
+       get_frame_arch to get at the current architecture by regcache or by
+       frame, respectively.
+
+2007-10-08  Markus Deuling  <deuling@de.ibm.com>
+
        * findvar.c (value_of_register, locate_var_value): Use
        get_regcache_arch or get_frame_arch to get at the current architecture
        by regcache or by frame, respectively.

diff --git a/gdb/regcache.c b/gdb/regcache.c
index 5eb16cc..10314b4 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -92,11 +92,11 @@ init_regcache_descr (struct gdbarch *gdbarch)
   /* Total size of the register space.  The raw registers are mapped
      directly onto the raw register cache while the pseudo's are
      either mapped onto raw-registers or memory.  */
-  descr->nr_cooked_registers = gdbarch_num_regs (current_gdbarch)
-                              + gdbarch_num_pseudo_regs (current_gdbarch);
-  descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (current_gdbarch)
+  descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
+                              + gdbarch_num_pseudo_regs (gdbarch);
+  descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
                                          + gdbarch_num_pseudo_regs 
-                                             (current_gdbarch);
+                                             (gdbarch);
 
   /* Fill in a table of register types.  */
   descr->register_type
@@ -106,7 +106,7 @@ init_regcache_descr (struct gdbarch *gdbarch)
 
   /* Construct a strictly RAW register cache.  Don't allow pseudo's
      into the register cache.  */
-  descr->nr_raw_registers = gdbarch_num_regs (current_gdbarch);
+  descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
 
   /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
      array.  This pretects GDB from erant code that accesses elements
@@ -174,8 +174,8 @@ register_size (struct gdbarch *gdbarch, int regnum)
   struct regcache_descr *descr = regcache_descr (gdbarch);
   int size;
   gdb_assert (regnum >= 0
-             && regnum < (gdbarch_num_regs (current_gdbarch)
-                          + gdbarch_num_pseudo_regs (current_gdbarch)));
+             && regnum < (gdbarch_num_regs (gdbarch)
+                          + gdbarch_num_pseudo_regs (gdbarch)));
   size = descr->sizeof_register[regnum];
   return size;
 }
@@ -642,7 +642,7 @@ regcache_raw_write (struct regcache *regcache, int regnum,
 
   /* On the sparc, writing %g0 is a no-op, so we don't even want to
      change the registers array if something writes to this register.  */
-  if (gdbarch_cannot_store_register (current_gdbarch, regnum))
+  if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
     return;
 
   /* If we have a valid copy of the register, and new value == old
@@ -837,13 +837,13 @@ read_pc_pid (ptid_t ptid)
   if (gdbarch_read_pc_p (gdbarch))
     pc_val = gdbarch_read_pc (gdbarch, regcache);
   /* Else use per-frame method on get_current_frame.  */
-  else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+  else if (gdbarch_pc_regnum (gdbarch) >= 0)
     {
       ULONGEST raw_val;
       regcache_cooked_read_unsigned (regcache,
-                                    gdbarch_pc_regnum (current_gdbarch),
+                                    gdbarch_pc_regnum (gdbarch),
                                     &raw_val);
-      pc_val = gdbarch_addr_bits_remove (current_gdbarch, raw_val);
+      pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
     }
   else
     internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
@@ -865,9 +865,9 @@ write_pc_pid (CORE_ADDR pc, ptid_t ptid)
 
   if (gdbarch_write_pc_p (gdbarch))
     gdbarch_write_pc (gdbarch, regcache, pc);
-  else if (gdbarch_pc_regnum (current_gdbarch) >= 0)
+  else if (gdbarch_pc_regnum (gdbarch) >= 0)
     regcache_cooked_write_unsigned (regcache,
-                                   gdbarch_pc_regnum (current_gdbarch), pc);
+                                   gdbarch_pc_regnum (gdbarch), pc);
   else
     internal_error (__FILE__, __LINE__,
                    _("write_pc_pid: Unable to update PC"));
@@ -938,14 +938,14 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
   fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
                      regcache->descr->sizeof_raw_register_valid_p);
   fprintf_unfiltered (file, "gdbarch_num_regs %d\n", 
-                     gdbarch_num_regs (current_gdbarch));
+                     gdbarch_num_regs (gdbarch));
   fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
-                     gdbarch_num_pseudo_regs (current_gdbarch));
+                     gdbarch_num_pseudo_regs (gdbarch));
 #endif
 
   gdb_assert (regcache->descr->nr_cooked_registers
-             == (gdbarch_num_regs (current_gdbarch)
-                 + gdbarch_num_pseudo_regs (current_gdbarch)));
+             == (gdbarch_num_regs (gdbarch)
+                 + gdbarch_num_pseudo_regs (gdbarch)));
 
   for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
     {
@@ -954,7 +954,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
        fprintf_unfiltered (file, " %-10s", "Name");
       else
        {
-         const char *p = gdbarch_register_name (current_gdbarch, regnum);
+         const char *p = gdbarch_register_name (gdbarch, regnum);
          if (p == NULL)
            p = "";
          else if (p[0] == '\0')
@@ -971,11 +971,11 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
       /* Relative number.  */
       if (regnum < 0)
        fprintf_unfiltered (file, " %4s", "Rel");
-      else if (regnum < gdbarch_num_regs (current_gdbarch))
+      else if (regnum < gdbarch_num_regs (gdbarch))
        fprintf_unfiltered (file, " %4d", regnum);
       else
        fprintf_unfiltered (file, " %4d",
-                           (regnum - gdbarch_num_regs (current_gdbarch)));
+                           (regnum - gdbarch_num_regs (gdbarch)));
 
       /* Offset.  */
       if (regnum < 0)
@@ -1050,7 +1050,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
              regcache_raw_read (regcache, regnum, buf);
              fprintf_unfiltered (file, "0x");
              dump_endian_bytes (file,
-                                gdbarch_byte_order (current_gdbarch), buf,
+                                gdbarch_byte_order (gdbarch), buf,
                                 regcache->descr->sizeof_register[regnum]);
            }
        }
@@ -1065,7 +1065,7 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
              regcache_cooked_read (regcache, regnum, buf);
              fprintf_unfiltered (file, "0x");
              dump_endian_bytes (file,
-                                gdbarch_byte_order (current_gdbarch), buf,
+                                gdbarch_byte_order (gdbarch), buf,
                                 regcache->descr->sizeof_register[regnum]);
            }
        }