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

	* sh64-tdep.c (sh64_push_dummy_call, sh64_register_type)
	(sh64_pseudo_register_read, sh64_pseudo_register_write)
	(sh64_do_fp_register, sh64_do_pseudo_register, sh64_do_register)
	(sh64_print_register, sh64_media_print_registers_info)
	(sh64_compact_print_registers_info, sh64_unwind_sp)
	(sh64_unwind_pc): Replace current_gdbarch by gdbarch.
	(sh64_show_media_regs, sh64_show_compact_regs, sh64_frame_cache)
	(sh64_frame_prev_register): Use FRAME to recognize current
	architecture.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index a01bdab..be89811 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,17 @@
 2007-10-08  Markus Deuling  <deuling@de.ibm.com>
 
+       * sh64-tdep.c (sh64_push_dummy_call, sh64_register_type)
+       (sh64_pseudo_register_read, sh64_pseudo_register_write)
+       (sh64_do_fp_register, sh64_do_pseudo_register, sh64_do_register)
+       (sh64_print_register, sh64_media_print_registers_info)
+       (sh64_compact_print_registers_info, sh64_unwind_sp)
+       (sh64_unwind_pc): Replace current_gdbarch by gdbarch.
+       (sh64_show_media_regs, sh64_show_compact_regs, sh64_frame_cache)
+       (sh64_frame_prev_register): Use FRAME to recognize current
+       architecture.
+
+2007-10-08  Markus Deuling  <deuling@de.ibm.com>
+
        * sh-tdep.c (sh_push_dummy_call_fpu, sh_push_dummy_call_nofpu)
        (sh_sh2a_register_type, sh_sh3e_register_type, sh_sh4_register_type)
        (sh_register_reggroup_p, sh_dwarf2_frame_init_reg): Replace

diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index b2a1954..d7b6bf3 100644 (file)
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -1074,7 +1074,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
      in eight registers available.  Loop thru args from first to last.  */
 
   int_argreg = ARG0_REGNUM;
-  float_argreg = gdbarch_fp0_regnum (current_gdbarch);
+  float_argreg = gdbarch_fp0_regnum (gdbarch);
   double_argreg = DR0_REGNUM;
 
   for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
@@ -1085,12 +1085,12 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
       
       if (TYPE_CODE (type) != TYPE_CODE_FLT)
        {
-         argreg_size = register_size (current_gdbarch, int_argreg);
+         argreg_size = register_size (gdbarch, int_argreg);
 
          if (len < argreg_size)
            {
              /* value gets right-justified in the register or stack word */
-             if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
                memcpy (valbuf + argreg_size - len,
                        (char *) value_contents (args[argnum]), len);
              else
@@ -1144,7 +1144,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
                {
                  /* Goes in FR0...FR11 */
                  regcache_cooked_write (regcache,
-                                        gdbarch_fp0_regnum (current_gdbarch)
+                                        gdbarch_fp0_regnum (gdbarch)
                                         + float_arg_index,
                                         val);
                  fp_args[float_arg_index] = 1;
@@ -1190,7 +1190,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache,
-                                 gdbarch_sp_regnum (current_gdbarch), sp);
+                                 gdbarch_sp_regnum (gdbarch), sp);
 
   return sp;
 }
@@ -1316,12 +1316,13 @@ sh64_return_value (struct gdbarch *gdbarch, struct type *type,
 static void
 sh64_show_media_regs (struct frame_info *frame)
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   int i;
 
   printf_filtered
     ("PC=%s SR=%016llx \n",
      paddr (get_frame_register_unsigned (frame,
-                                        gdbarch_pc_regnum (current_gdbarch))),
+                                        gdbarch_pc_regnum (gdbarch))),
      (long long) get_frame_register_unsigned (frame, SR_REGNUM));
 
   printf_filtered
@@ -1348,26 +1349,27 @@ sh64_show_media_regs (struct frame_info *frame)
       ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
        i, i + 7,
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 0),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 0),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 1),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 1),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 2),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 2),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 3),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 3),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 4),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 4),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 5),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 5),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 6),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 6),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 7));
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 7));
 }
 
 static void
 sh64_show_compact_regs (struct frame_info *frame)
 {
+  struct gdbarch *gdbarch = get_frame_arch (frame);
   int i;
 
   printf_filtered
@@ -1402,21 +1404,21 @@ sh64_show_compact_regs (struct frame_info *frame)
       ("FR%d-FR%d  %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
        i, i + 7,
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 0),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 0),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 1),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 1),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 2),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 2),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 3),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 3),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 4),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 4),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 5),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 5),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 6),
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 6),
        (long) get_frame_register_unsigned
-               (frame, gdbarch_fp0_regnum (current_gdbarch) + i + 7));
+               (frame, gdbarch_fp0_regnum (gdbarch) + i + 7));
 }
 
 /* FIXME!!! This only shows the registers for shmedia, excluding the
@@ -1512,7 +1514,7 @@ sh64_build_float_register_type (int high)
 static struct type *
 sh64_register_type (struct gdbarch *gdbarch, int reg_nr)
 {
-  if ((reg_nr >= gdbarch_fp0_regnum (current_gdbarch)
+  if ((reg_nr >= gdbarch_fp0_regnum (gdbarch)
        && reg_nr <= FP_LAST_REGNUM)
       || (reg_nr >= FP0_C_REGNUM
          && reg_nr <= FP_LAST_C_REGNUM))
@@ -1653,7 +1655,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 
       /* Build the value in the provided buffer.  */ 
       regcache_raw_read (regcache, base_regnum, temp_buffer);
-      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
     }
@@ -1813,7 +1815,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
     {
       base_regnum = sh64_compact_reg_base_num (reg_nr);
       /* reg_nr is 32 bit here, and base_regnum is 64 bits.  */
-      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       else 
        offset = 0;
@@ -1984,20 +1986,20 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file,
   raw_buffer = (unsigned char *) alloca
                                 (register_size (gdbarch,
                                                 gdbarch_fp0_regnum
-                                                (current_gdbarch)));
+                                                  (gdbarch)));
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
     error ("can't read register %d (%s)",
-          regnum, gdbarch_register_name (current_gdbarch, regnum));
+          regnum, gdbarch_register_name (gdbarch, regnum));
 
   /* Get the register as a number */ 
   flt = unpack_double (builtin_type_float, raw_buffer, &inv);
 
   /* Print the name and some spaces.  */
-  fputs_filtered (gdbarch_register_name (current_gdbarch, regnum), file);
+  fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
   print_spaces_filtered (15 - strlen (gdbarch_register_name
-                                       (current_gdbarch, regnum)), file);
+                                       (gdbarch, regnum)), file);
 
   /* Print the value.  */
   if (inv)
@@ -2009,7 +2011,7 @@ sh64_do_fp_register (struct gdbarch *gdbarch, struct ui_file *file,
   fprintf_filtered (file, "\t(raw 0x");
   for (j = 0; j < register_size (gdbarch, regnum); j++)
     {
-      int idx = gdbarch_byte_order (current_gdbarch)
+      int idx = gdbarch_byte_order (gdbarch)
                == BFD_ENDIAN_BIG ? j : register_size
                (gdbarch, regnum) - 1 - j;
       fprintf_filtered (file, "%02x", raw_buffer[idx]);
@@ -2024,8 +2026,8 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 {
   /* All the sh64-compact mode registers are pseudo registers.  */
 
-  if (regnum < gdbarch_num_regs (current_gdbarch)
-      || regnum >= gdbarch_num_regs (current_gdbarch)
+  if (regnum < gdbarch_num_regs (gdbarch)
+      || regnum >= gdbarch_num_regs (gdbarch)
                   + NUM_PSEUDO_REGS_SH_MEDIA
                   + NUM_PSEUDO_REGS_SH_COMPACT)
     internal_error (__FILE__, __LINE__,
@@ -2096,9 +2098,9 @@ sh64_do_register (struct gdbarch *gdbarch, struct ui_file *file,
 {
   unsigned char raw_buffer[MAX_REGISTER_SIZE];
 
-  fputs_filtered (gdbarch_register_name (current_gdbarch, regnum), file);
+  fputs_filtered (gdbarch_register_name (gdbarch, regnum), file);
   print_spaces_filtered (15 - strlen (gdbarch_register_name
-                                     (current_gdbarch, regnum)), file);
+                                     (gdbarch, regnum)), file);
 
   /* Get the data in raw format.  */
   if (!frame_register_read (frame, regnum, raw_buffer))
@@ -2116,12 +2118,12 @@ static void
 sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
                     struct frame_info *frame, int regnum)
 {
-  if (regnum < 0 || regnum >= gdbarch_num_regs (current_gdbarch)
-                             + gdbarch_num_pseudo_regs (current_gdbarch))
+  if (regnum < 0 || regnum >= gdbarch_num_regs (gdbarch)
+                             + gdbarch_num_pseudo_regs (gdbarch))
     internal_error (__FILE__, __LINE__,
                    _("Invalid register number %d\n"), regnum);
 
-  else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
+  else if (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch))
     {
       if (TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
        sh64_do_fp_register (gdbarch, file, frame, regnum);     /* FP regs */
@@ -2129,8 +2131,8 @@ sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
        sh64_do_register (gdbarch, file, frame, regnum);
     }
 
-  else if (regnum < gdbarch_num_regs (current_gdbarch)
-                   + gdbarch_num_pseudo_regs (current_gdbarch))
+  else if (regnum < gdbarch_num_regs (gdbarch)
+                   + gdbarch_num_pseudo_regs (gdbarch))
     sh64_do_pseudo_register (gdbarch, file, frame, regnum);
 }
 
@@ -2141,7 +2143,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 {
   if (regnum != -1)            /* do one specified register */
     {
-      if (*(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
+      if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
        error ("Not a valid register for the current processor type");
 
       sh64_print_register (gdbarch, file, frame, regnum);
@@ -2150,12 +2152,12 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
     /* do all (or most) registers */
     {
       regnum = 0;
-      while (regnum < gdbarch_num_regs (current_gdbarch))
+      while (regnum < gdbarch_num_regs (gdbarch))
        {
          /* If the register name is empty, it is undefined for this
             processor, so don't display anything.  */
-         if (gdbarch_register_name (current_gdbarch, regnum) == NULL
-             || *(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
+         if (gdbarch_register_name (gdbarch, regnum) == NULL
+             || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
            { 
              regnum++;
              continue;
@@ -2171,7 +2173,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
                  regnum ++;
                }
              else
-               regnum += FP_LAST_REGNUM - gdbarch_fp0_regnum (current_gdbarch);
+               regnum += FP_LAST_REGNUM - gdbarch_fp0_regnum (gdbarch);
                /* skip FP regs */
            }
          else
@@ -2182,8 +2184,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
        }
 
       if (fpregs)
-       while (regnum < gdbarch_num_regs (current_gdbarch)
-                       + gdbarch_num_pseudo_regs (current_gdbarch))
+       while (regnum < gdbarch_num_regs (gdbarch)
+                       + gdbarch_num_pseudo_regs (gdbarch))
          {
            sh64_do_pseudo_register (gdbarch, file, frame, regnum);
            regnum++;
@@ -2199,7 +2201,7 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch,
 {
   if (regnum != -1)            /* do one specified register */
     {
-      if (*(gdbarch_register_name (current_gdbarch, regnum)) == '\0')
+      if (*(gdbarch_register_name (gdbarch, regnum)) == '\0')
        error ("Not a valid register for the current processor type");
 
       if (regnum >= 0 && regnum < R0_C_REGNUM)
@@ -2211,8 +2213,8 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch,
     /* do all compact registers */
     {
       regnum = R0_C_REGNUM;
-      while (regnum < gdbarch_num_regs (current_gdbarch)
-                     + gdbarch_num_pseudo_regs (current_gdbarch))
+      while (regnum < gdbarch_num_regs (gdbarch)
+                     + gdbarch_num_pseudo_regs (gdbarch))
         {
           sh64_do_pseudo_register (gdbarch, file, frame, regnum);
           regnum++;
@@ -2260,6 +2262,7 @@ sh64_alloc_frame_cache (void)
 static struct sh64_frame_cache *
 sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
 {
+  struct gdbarch *gdbarch;
   struct sh64_frame_cache *cache;
   CORE_ADDR current_pc;
   int i;
@@ -2267,6 +2270,7 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
   if (*this_cache)
     return *this_cache;
 
+  gdbarch = get_frame_arch (next_frame);
   cache = sh64_alloc_frame_cache ();
   *this_cache = cache;
 
@@ -2284,7 +2288,7 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
 
   cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
   if (cache->pc != 0)
-    sh64_analyze_prologue (current_gdbarch, cache, cache->pc, current_pc);
+    sh64_analyze_prologue (gdbarch, cache, cache->pc, current_pc);
 
   if (!cache->uses_fp)
     {
@@ -2296,7 +2300,7 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
          frame by looking at the stack pointer.  For truly "frameless"
          functions this might work too.  */
       cache->base = frame_unwind_register_unsigned
-                   (next_frame, gdbarch_sp_regnum (current_gdbarch));
+                   (next_frame, gdbarch_sp_regnum (gdbarch));
     }
 
   /* Now that we have the base address for the stack frame we can
@@ -2319,10 +2323,11 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
                          int *realnump, gdb_byte *valuep)
 {
   struct sh64_frame_cache *cache = sh64_frame_cache (next_frame, this_cache);
+  struct gdbarch *gdbarch = get_frame_arch (next_frame);
 
   gdb_assert (regnum >= 0);
 
-  if (regnum == gdbarch_sp_regnum (current_gdbarch) && cache->saved_sp)
+  if (regnum == gdbarch_sp_regnum (gdbarch) && cache->saved_sp)
     {
       *optimizedp = 0;
       *lvalp = not_lval;
@@ -2332,8 +2337,8 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
         {
           /* Store the value.  */
           store_unsigned_integer (valuep,
-                                 register_size (current_gdbarch,
-                                 gdbarch_sp_regnum (current_gdbarch)),
+                                 register_size (gdbarch,
+                                 gdbarch_sp_regnum (gdbarch)),
                                  cache->saved_sp);
         }
       return;
@@ -2342,19 +2347,19 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
   /* The PC of the previous frame is stored in the PR register of
      the current frame.  Frob regnum so that we pull the value from
      the correct place.  */
-  if (regnum == gdbarch_pc_regnum (current_gdbarch))
+  if (regnum == gdbarch_pc_regnum (gdbarch))
     regnum = PR_REGNUM;
 
   if (regnum < SIM_SH64_NR_REGS && cache->saved_regs[regnum] != -1)
     {
-      int reg_size = register_size (current_gdbarch, regnum);
+      int reg_size = register_size (gdbarch, regnum);
       int size;
 
       *optimizedp = 0;
       *lvalp = lval_memory;
       *addrp = cache->saved_regs[regnum];
       *realnump = -1;
-      if (gdbarch_tdep (current_gdbarch)->sh_abi == SH_ABI_32
+      if (gdbarch_tdep (gdbarch)->sh_abi == SH_ABI_32
           && (regnum == MEDIA_FP_REGNUM || regnum == PR_REGNUM))
        size = 4;
       else
@@ -2362,7 +2367,7 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
       if (valuep)
         {
          memset (valuep, 0, reg_size);
-         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
+         if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
            read_memory (*addrp, valuep, size);
          else
            read_memory (*addrp, (char *) valuep + reg_size - size, size);
@@ -2407,14 +2412,14 @@ static CORE_ADDR
 sh64_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   return frame_unwind_register_unsigned (next_frame,
-                                        gdbarch_sp_regnum (current_gdbarch));
+                                        gdbarch_sp_regnum (gdbarch));
 }
 
 static CORE_ADDR
 sh64_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 {
   return frame_unwind_register_unsigned (next_frame,
-                                        gdbarch_pc_regnum (current_gdbarch));
+                                        gdbarch_pc_regnum (gdbarch));
 }
 
 static struct frame_id