2007-05-31 Markus Deuling <deuling@de.ibm.com>

[deliverable/binutils-gdb.git] / gdb / sh64-tdep.c

diff --git a/gdb/sh64-tdep.c b/gdb/sh64-tdep.c
index 1de876441ba2fd8481ae79dca2e6a19f275a39b8..da0416e24708463799b02139f489a5fc557a22d0 100644 (file)
--- a/gdb/sh64-tdep.c
+++ b/gdb/sh64-tdep.c
@@ -1,7 +1,7 @@
 /* Target-dependent code for Renesas Super-H, for GDB.
 
-   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
-   2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+   2003, 2004, 2005, 2007 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -17,8 +17,8 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
 
 /*
    Contributed by Steve Chamberlain
@@ -267,7 +267,7 @@ sh64_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
      which translates in big endian mode to 0x0, 0x3b
      and in little endian mode to 0x3b, 0x0*/
 
-  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+  if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
     {
       if (pc_is_isa32 (*pcptr))
        {
@@ -682,7 +682,7 @@ sh64_use_struct_convention (struct type *type)
 static int
 gdb_print_insn_sh64 (bfd_vma memaddr, disassemble_info *info)
 {
-  info->endian = TARGET_BYTE_ORDER;
+  info->endian = gdbarch_byte_order (current_gdbarch);
   return print_insn_sh (memaddr, info);
 }
 
@@ -1104,7 +1104,7 @@ sh64_push_dummy_call (struct gdbarch *gdbarch,
          if (len < argreg_size)
            {
              /* value gets right-justified in the register or stack word */
-             if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
                memcpy (valbuf + argreg_size - len,
                        (char *) value_contents (args[argnum]), len);
              else
@@ -1232,7 +1232,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
 
          regcache_cooked_read (regcache, DR0_REGNUM, buf);
          
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
            floatformat_to_doublest (&floatformat_ieee_double_littlebyte_bigword,
                                     buf, &val);
          else
@@ -1251,7 +1251,7 @@ sh64_extract_return_value (struct type *type, struct regcache *regcache,
             at the most significant end.  */
          regcache_raw_read (regcache, DEFAULT_RETURN_REGNUM, buf);
 
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
            offset = register_size (current_gdbarch, DEFAULT_RETURN_REGNUM)
                     - len;
          else
@@ -1281,7 +1281,7 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
     {
       int i, regnum = FP0_REGNUM;
       for (i = 0; i < len; i += 4)
-       if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+       if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
          regcache_raw_write (regcache, regnum++,
                              (char *) valbuf + len - 4 - i);
        else
@@ -1296,7 +1296,7 @@ sh64_store_return_value (struct type *type, struct regcache *regcache,
        {
          /* Pad with zeros.  */
          memset (buf, 0, register_size (current_gdbarch, return_register));
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
            offset = 0; /*register_size (current_gdbarch, 
                          return_register) - len;*/
          else
@@ -1408,8 +1408,7 @@ sh64_show_compact_regs (void)
 void
 sh64_show_regs (void)
 {
-  if (deprecated_selected_frame
-      && pc_is_isa32 (get_frame_pc (deprecated_selected_frame)))
+  if (pc_is_isa32 (get_frame_pc (get_selected_frame (NULL))))
     sh64_show_media_regs ();
   else
     sh64_show_compact_regs ();
@@ -1528,7 +1527,7 @@ static void
 sh64_register_convert_to_virtual (int regnum, struct type *type,
                                     char *from, char *to)
 {
-  if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
       memcpy (to, from, register_size (current_gdbarch, regnum));
@@ -1553,7 +1552,7 @@ static void
 sh64_register_convert_to_raw (struct type *type, int regnum,
                                 const void *from, void *to)
 {
-  if (TARGET_BYTE_ORDER != BFD_ENDIAN_LITTLE)
+  if (gdbarch_byte_order (current_gdbarch) != BFD_ENDIAN_LITTLE)
     {
       /* It is a no-op.  */
       memcpy (to, from, register_size (current_gdbarch, regnum));
@@ -1597,8 +1596,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 
       /* We must pay attention to the endianness.  */
       sh64_register_convert_to_virtual (reg_nr, 
-                                       gdbarch_register_type (gdbarch, 
-                                                              reg_nr),
+                                       register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
 
     }
@@ -1639,7 +1637,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       memcpy (buffer, temp_buffer + offset, 4); /* get LOWER 32 bits only????*/
     }
@@ -1669,8 +1667,7 @@ sh64_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
 
       /* We must pay attention to the endianness.  */
       sh64_register_convert_to_virtual (reg_nr, 
-                                       gdbarch_register_type (gdbarch, 
-                                                              reg_nr),
+                                       register_type (gdbarch, reg_nr),
                                        temp_buffer, buffer);
     }
 
@@ -1755,7 +1752,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
     {
       base_regnum = sh64_dr_reg_base_num (reg_nr);
       /* We must pay attention to the endianness.  */
-      sh64_register_convert_to_raw (gdbarch_register_type (gdbarch, reg_nr),
+      sh64_register_convert_to_raw (register_type (gdbarch, reg_nr),
                                    reg_nr,
                                    buffer, temp_buffer);
 
@@ -1800,7 +1797,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 (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
        offset = 4;
       else 
        offset = 0;
@@ -1829,8 +1826,7 @@ sh64_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       for (portion = 0; portion < 2; portion++)
        {
          /* We must pay attention to the endianness.  */
-         sh64_register_convert_to_raw (gdbarch_register_type (gdbarch,
-                                                              reg_nr), 
+         sh64_register_convert_to_raw (register_type (gdbarch, reg_nr),
                                        reg_nr,
                                        buffer, temp_buffer);
 
@@ -1992,8 +1988,9 @@ 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 = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
-       : register_size (gdbarch, regnum) - 1 - j;
+      int idx = gdbarch_byte_order (current_gdbarch)
+               == BFD_ENDIAN_BIG ? j : register_size
+               (gdbarch, regnum) - 1 - j;
       fprintf_filtered (file, "%02x", raw_buffer[idx]);
     }
   fprintf_filtered (file, ")");
@@ -2006,9 +2003,10 @@ sh64_do_pseudo_register (struct gdbarch *gdbarch, struct ui_file *file,
 {
   /* All the sh64-compact mode registers are pseudo registers.  */
 
-  if (regnum < NUM_REGS 
-      || regnum >= NUM_REGS + NUM_PSEUDO_REGS_SH_MEDIA
-                           + NUM_PSEUDO_REGS_SH_COMPACT)
+  if (regnum < gdbarch_num_regs (current_gdbarch)
+      || regnum >= gdbarch_num_regs (current_gdbarch)
+                  + NUM_PSEUDO_REGS_SH_MEDIA
+                  + NUM_PSEUDO_REGS_SH_COMPACT)
     internal_error (__FILE__, __LINE__,
                    _("Invalid pseudo register number %d\n"), regnum);
 
@@ -2084,10 +2082,10 @@ sh64_do_register (struct gdbarch *gdbarch, struct ui_file *file,
   if (!frame_register_read (frame, regnum, raw_buffer))
     fprintf_filtered (file, "*value not available*\n");
       
-  val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
+  val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
             file, 'x', 1, 0, Val_pretty_default);
   fprintf_filtered (file, "\t");
-  val_print (gdbarch_register_type (gdbarch, regnum), raw_buffer, 0, 0,
+  val_print (register_type (gdbarch, regnum), raw_buffer, 0, 0,
             file, 0, 1, 0, Val_pretty_default);
   fprintf_filtered (file, "\n");
 }
@@ -2096,19 +2094,21 @@ static void
 sh64_print_register (struct gdbarch *gdbarch, struct ui_file *file,
                     struct frame_info *frame, int regnum)
 {
-  if (regnum < 0 || regnum >= NUM_REGS + NUM_PSEUDO_REGS)
+  if (regnum < 0 || regnum >= gdbarch_num_regs (current_gdbarch)
+                             + gdbarch_num_pseudo_regs (current_gdbarch))
     internal_error (__FILE__, __LINE__,
                    _("Invalid register number %d\n"), regnum);
 
-  else if (regnum >= 0 && regnum < NUM_REGS)
+  else if (regnum >= 0 && regnum < gdbarch_num_regs (current_gdbarch))
     {
-      if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
+      if (TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT)
        sh64_do_fp_register (gdbarch, file, frame, regnum);     /* FP regs */
       else
        sh64_do_register (gdbarch, file, frame, regnum);
     }
 
-  else if (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+  else if (regnum < gdbarch_num_regs (current_gdbarch)
+                   + gdbarch_num_pseudo_regs (current_gdbarch))
     sh64_do_pseudo_register (gdbarch, file, frame, regnum);
 }
 
@@ -2128,7 +2128,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
     /* do all (or most) registers */
     {
       regnum = 0;
-      while (regnum < NUM_REGS)
+      while (regnum < gdbarch_num_regs (current_gdbarch))
        {
          /* If the register name is empty, it is undefined for this
             processor, so don't display anything.  */
@@ -2139,7 +2139,7 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
              continue;
            }
 
-         if (TYPE_CODE (gdbarch_register_type (gdbarch, regnum))
+         if (TYPE_CODE (register_type (gdbarch, regnum))
              == TYPE_CODE_FLT)
            {
              if (fpregs)
@@ -2159,7 +2159,8 @@ sh64_media_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
        }
 
       if (fpregs)
-       while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+       while (regnum < gdbarch_num_regs (current_gdbarch)
+                       + gdbarch_num_pseudo_regs (current_gdbarch))
          {
            sh64_do_pseudo_register (gdbarch, file, frame, regnum);
            regnum++;
@@ -2187,7 +2188,8 @@ sh64_compact_print_registers_info (struct gdbarch *gdbarch,
     /* do all compact registers */
     {
       regnum = R0_C_REGNUM;
-      while (regnum < NUM_REGS + NUM_PSEUDO_REGS)
+      while (regnum < gdbarch_num_regs (current_gdbarch)
+                     + gdbarch_num_pseudo_regs (current_gdbarch))
         {
           sh64_do_pseudo_register (gdbarch, file, frame, regnum);
           regnum++;
@@ -2257,7 +2259,7 @@ sh64_frame_cache (struct frame_info *next_frame, void **this_cache)
   if (cache->base == 0)
     return cache;
 
-  cache->pc = frame_func_unwind (next_frame);
+  cache->pc = frame_func_unwind (next_frame, NORMAL_FRAME);
   if (cache->pc != 0)
     sh64_analyze_prologue (current_gdbarch, cache, cache->pc, current_pc);
 
@@ -2335,7 +2337,7 @@ sh64_frame_prev_register (struct frame_info *next_frame, void **this_cache,
       if (valuep)
         {
          memset (valuep, 0, reg_size);
-         if (TARGET_BYTE_ORDER == BFD_ENDIAN_LITTLE)
+         if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE)
            read_memory (*addrp, valuep, size);
          else
            read_memory (*addrp, (char *) valuep + reg_size - size, size);