projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Automatic date update in version.in
[deliverable/binutils-gdb.git] / gdb / sh-tdep.c
diff --git a/gdb/sh-tdep.c b/gdb/sh-tdep.c
index edf7e94b2ea58233ddadd37fb238b472c93bc1fd..bfb220adf79206f5c92cc78f672fa2652b9ac3d9 100644 (file)
--- a/gdb/sh-tdep.c
+++ b/gdb/sh-tdep.c
@@ -1,6 +1,6 @@
 /* Target-dependent code for Renesas Super-H, for GDB.
 
 /* Target-dependent code for Renesas Super-H, for GDB.
 
-   Copyright (C) 1993-2018 Free Software Foundation, Inc.
+   Copyright (C) 1993-2021 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -24,7 +24,7 @@
 #include "frame.h"
 #include "frame-base.h"
 #include "frame-unwind.h"
 #include "frame.h"
 #include "frame-base.h"
 #include "frame-unwind.h"
-#include "dwarf2-frame.h"
+#include "dwarf2/frame.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "gdbcmd.h"
 #include "symtab.h"
 #include "gdbtypes.h"
 #include "gdbcmd.h"
@@ -92,12 +92,12 @@ sh_is_renesas_calling_convention (struct type *func_type)
     {
       func_type = check_typedef (func_type);
 
     {
       func_type = check_typedef (func_type);
 
-      if (TYPE_CODE (func_type) == TYPE_CODE_PTR)
-        func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
+      if (func_type->code () == TYPE_CODE_PTR)
+       func_type = check_typedef (TYPE_TARGET_TYPE (func_type));
 
 
-      if (TYPE_CODE (func_type) == TYPE_CODE_FUNC
-          && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GNU_renesas_sh)
-        val = 1;
+      if (func_type->code () == TYPE_CODE_FUNC
+         && TYPE_CALLING_CONVENTION (func_type) == DW_CC_GNU_renesas_sh)
+       val = 1;
     }
 
   if (sh_active_calling_convention == sh_cc_renesas)
     }
 
   if (sh_active_calling_convention == sh_cc_renesas)
@@ -432,7 +432,7 @@ sh_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
   *size = kind;
 
   /* For remote stub targets, trapa #20 is used.  */
   *size = kind;
 
   /* For remote stub targets, trapa #20 is used.  */
-  if (strcmp (target_shortname, "remote") == 0)
+  if (strcmp (target_shortname (), "remote") == 0)
     {
       static unsigned char big_remote_breakpoint[] = { 0xc3, 0x20 };
       static unsigned char little_remote_breakpoint[] = { 0x20, 0xc3 };
     {
       static unsigned char big_remote_breakpoint[] = { 0xc3, 0x20 };
       static unsigned char little_remote_breakpoint[] = { 0x20, 0xc3 };
@@ -618,12 +618,12 @@ sh_analyze_prologue (struct gdbarch *gdbarch,
        }
       else if (IS_MOVI20 (inst)
               && (pc + 2 < limit_pc))
        }
       else if (IS_MOVI20 (inst)
               && (pc + 2 < limit_pc))
-        {
+       {
          if (sav_reg < 0)
            {
              reg = GET_TARGET_REG (inst);
              if (reg < 14)
          if (sav_reg < 0)
            {
              reg = GET_TARGET_REG (inst);
              if (reg < 14)
-               {
+               {
                  sav_reg = reg;
                  sav_offset = GET_SOURCE_REG (inst) << 16;
                  /* MOVI20 is a 32 bit instruction!  */
                  sav_reg = reg;
                  sav_offset = GET_SOURCE_REG (inst) << 16;
                  /* MOVI20 is a 32 bit instruction!  */
@@ -735,7 +735,7 @@ sh_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
     {
       post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
       if (post_prologue_pc != 0)
     {
       post_prologue_pc = skip_prologue_using_sal (gdbarch, func_addr);
       if (post_prologue_pc != 0)
-        return std::max (pc, post_prologue_pc);
+       return std::max (pc, post_prologue_pc);
     }
 
   /* Can't determine prologue from the symbol table, need to examine
     }
 
   /* Can't determine prologue from the symbol table, need to examine
@@ -813,11 +813,11 @@ static int
 sh_use_struct_convention (int renesas_abi, struct type *type)
 {
   int len = TYPE_LENGTH (type);
 sh_use_struct_convention (int renesas_abi, struct type *type)
 {
   int len = TYPE_LENGTH (type);
-  int nelem = TYPE_NFIELDS (type);
+  int nelem = type->num_fields ();
 
   /* The Renesas ABI returns aggregate types always on stack.  */
 
   /* The Renesas ABI returns aggregate types always on stack.  */
-  if (renesas_abi && (TYPE_CODE (type) == TYPE_CODE_STRUCT
-                     || TYPE_CODE (type) == TYPE_CODE_UNION))
+  if (renesas_abi && (type->code () == TYPE_CODE_STRUCT
+                     || type->code () == TYPE_CODE_UNION))
     return 1;
 
   /* Non-power of 2 length types and types bigger than 8 bytes (which don't
     return 1;
 
   /* Non-power of 2 length types and types bigger than 8 bytes (which don't
@@ -832,13 +832,13 @@ sh_use_struct_convention (int renesas_abi, struct type *type)
 
   /* If the first field in the aggregate has the same length as the entire
      aggregate type, the type is returned in registers.  */
 
   /* If the first field in the aggregate has the same length as the entire
      aggregate type, the type is returned in registers.  */
-  if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == len)
+  if (TYPE_LENGTH (type->field (0).type ()) == len)
     return 0;
 
   /* If the size of the aggregate is 8 bytes and the first field is
      of size 4 bytes its alignment is equal to long long's alignment,
      so it's returned in registers.  */
     return 0;
 
   /* If the size of the aggregate is 8 bytes and the first field is
      of size 4 bytes its alignment is equal to long long's alignment,
      so it's returned in registers.  */
-  if (len == 8 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
+  if (len == 8 && TYPE_LENGTH (type->field (0).type ()) == 4)
     return 0;
 
   /* Otherwise use struct convention.  */
     return 0;
 
   /* Otherwise use struct convention.  */
@@ -849,7 +849,7 @@ static int
 sh_use_struct_convention_nofpu (int renesas_abi, struct type *type)
 {
   /* The Renesas ABI returns long longs/doubles etc. always on stack.  */
 sh_use_struct_convention_nofpu (int renesas_abi, struct type *type)
 {
   /* The Renesas ABI returns long longs/doubles etc. always on stack.  */
-  if (renesas_abi && TYPE_NFIELDS (type) == 0 && TYPE_LENGTH (type) >= 8)
+  if (renesas_abi && type->num_fields () == 0 && TYPE_LENGTH (type) >= 8)
     return 1;
   return sh_use_struct_convention (renesas_abi, type);
 }
     return 1;
   return sh_use_struct_convention (renesas_abi, type);
 }
@@ -912,7 +912,7 @@ sh_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
    not displace any of the other arguments passed in via registers R4
    to R7.  */
 
    not displace any of the other arguments passed in via registers R4
    to R7.  */
 
-/* Helper function to justify value in register according to endianess.  */
+/* Helper function to justify value in register according to endianness.  */
 static const gdb_byte *
 sh_justify_value_in_reg (struct gdbarch *gdbarch, struct value *val, int len)
 {
 static const gdb_byte *
 sh_justify_value_in_reg (struct gdbarch *gdbarch, struct value *val, int len)
 {
@@ -942,7 +942,7 @@ sh_stack_allocsize (int nargs, struct value **args)
 }
 
 /* Helper functions for getting the float arguments right.  Registers usage
 }
 
 /* Helper functions for getting the float arguments right.  Registers usage
-   depends on the ABI and the endianess.  The comments should enlighten how
+   depends on the ABI and the endianness.  The comments should enlighten how
    it's intended to work.  */
 
 /* This array stores which of the float arg registers are already in use.  */
    it's intended to work.  */
 
 /* This array stores which of the float arg registers are already in use.  */
@@ -1040,17 +1040,17 @@ static int
 sh_treat_as_flt_p (struct type *type)
 {
   /* Ordinary float types are obviously treated as float.  */
 sh_treat_as_flt_p (struct type *type)
 {
   /* Ordinary float types are obviously treated as float.  */
-  if (TYPE_CODE (type) == TYPE_CODE_FLT)
+  if (type->code () == TYPE_CODE_FLT)
     return 1;
   /* Otherwise non-struct types are not treated as float.  */
     return 1;
   /* Otherwise non-struct types are not treated as float.  */
-  if (TYPE_CODE (type) != TYPE_CODE_STRUCT)
+  if (type->code () != TYPE_CODE_STRUCT)
     return 0;
     return 0;
-  /* Otherwise structs with more than one memeber are not treated as float.  */
-  if (TYPE_NFIELDS (type) != 1)
+  /* Otherwise structs with more than one member are not treated as float.  */
+  if (type->num_fields () != 1)
     return 0;
   /* Otherwise if the type of that member is float, the whole type is
      treated as float.  */
     return 0;
   /* Otherwise if the type of that member is float, the whole type is
      treated as float.  */
-  if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) == TYPE_CODE_FLT)
+  if (type->field (0).type ()->code () == TYPE_CODE_FLT)
     return 1;
   /* Otherwise it's not treated as float.  */
   return 0;
     return 1;
   /* Otherwise it's not treated as float.  */
   return 0;
@@ -1062,7 +1062,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
                        struct regcache *regcache,
                        CORE_ADDR bp_addr, int nargs,
                        struct value **args,
                        struct regcache *regcache,
                        CORE_ADDR bp_addr, int nargs,
                        struct value **args,
-                       CORE_ADDR sp, int struct_return,
+                       CORE_ADDR sp, function_call_return_method return_method,
                        CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
                        CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -1083,8 +1083,8 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
      non-vararg argument to be on the stack, no matter how many
      registers have been used so far.  */
   if (sh_is_renesas_calling_convention (func_type)
      non-vararg argument to be on the stack, no matter how many
      registers have been used so far.  */
   if (sh_is_renesas_calling_convention (func_type)
-      && TYPE_VARARGS (func_type))
-    last_reg_arg = TYPE_NFIELDS (func_type) - 2;
+      && func_type->has_varargs ())
+    last_reg_arg = func_type->num_fields () - 2;
 
   /* First force sp to a 4-byte alignment.  */
   sp = sh_frame_align (gdbarch, sp);
 
   /* First force sp to a 4-byte alignment.  */
   sp = sh_frame_align (gdbarch, sp);
@@ -1105,7 +1105,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
       val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
 
       /* Some decisions have to be made how various types are handled.
       val = sh_justify_value_in_reg (gdbarch, args[argnum], len);
 
       /* Some decisions have to be made how various types are handled.
-         This also differs in different ABIs.  */
+        This also differs in different ABIs.  */
       pass_on_stack = 0;
 
       /* Find out the next register to use for a floating point value.  */
       pass_on_stack = 0;
 
       /* Find out the next register to use for a floating point value.  */
@@ -1115,9 +1115,9 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
       /* In Renesas ABI, long longs and aggregate types are always passed
         on stack.  */
       else if (sh_is_renesas_calling_convention (func_type)
       /* In Renesas ABI, long longs and aggregate types are always passed
         on stack.  */
       else if (sh_is_renesas_calling_convention (func_type)
-              && ((TYPE_CODE (type) == TYPE_CODE_INT && len == 8)
-                  || TYPE_CODE (type) == TYPE_CODE_STRUCT
-                  || TYPE_CODE (type) == TYPE_CODE_UNION))
+              && ((type->code () == TYPE_CODE_INT && len == 8)
+                  || type->code () == TYPE_CODE_STRUCT
+                  || type->code () == TYPE_CODE_UNION))
        pass_on_stack = 1;
       /* In contrast to non-FPU CPUs, arguments are never split between
         registers and stack.  If an argument doesn't fit in the remaining
        pass_on_stack = 1;
       /* In contrast to non-FPU CPUs, arguments are never split between
         registers and stack.  If an argument doesn't fit in the remaining
@@ -1129,7 +1129,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
        {
          if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
              || (!treat_as_flt && (argreg > ARGLAST_REGNUM
        {
          if ((treat_as_flt && flt_argreg > FLOAT_ARGLAST_REGNUM)
              || (!treat_as_flt && (argreg > ARGLAST_REGNUM
-                                   || pass_on_stack))
+                                   || pass_on_stack))
              || argnum > last_reg_arg)
            {
              /* The data goes entirely on the stack, 4-byte aligned.  */
              || argnum > last_reg_arg)
            {
              /* The data goes entirely on the stack, 4-byte aligned.  */
@@ -1143,15 +1143,15 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
              reg_size = register_size (gdbarch, flt_argreg);
              regval = extract_unsigned_integer (val, reg_size, byte_order);
              /* In little endian mode, float types taking two registers
              reg_size = register_size (gdbarch, flt_argreg);
              regval = extract_unsigned_integer (val, reg_size, byte_order);
              /* In little endian mode, float types taking two registers
-                (doubles on sh4, long doubles on sh2e, sh3e and sh4) must
+                (doubles on sh4, long doubles on sh2e, sh3e and sh4) must
                 be stored swapped in the argument registers.  The below
                 code first writes the first 32 bits in the next but one
                 register, increments the val and len values accordingly
                 and then proceeds as normal by writing the second 32 bits
                 into the next register.  */
              if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE
                 be stored swapped in the argument registers.  The below
                 code first writes the first 32 bits in the next but one
                 register, increments the val and len values accordingly
                 and then proceeds as normal by writing the second 32 bits
                 into the next register.  */
              if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE
-                 && TYPE_LENGTH (type) == 2 * reg_size)
-               {
+                 && TYPE_LENGTH (type) == 2 * reg_size)
+               {
                  regcache_cooked_write_unsigned (regcache, flt_argreg + 1,
                                                  regval);
                  val += reg_size;
                  regcache_cooked_write_unsigned (regcache, flt_argreg + 1,
                                                  regval);
                  val += reg_size;
@@ -1175,7 +1175,7 @@ sh_push_dummy_call_fpu (struct gdbarch *gdbarch,
        }
     }
 
        }
     }
 
-  if (struct_return)
+  if (return_method == return_method_struct)
     {
       if (sh_is_renesas_calling_convention (func_type))
        /* If the function uses the Renesas ABI, subtract another 4 bytes from
     {
       if (sh_is_renesas_calling_convention (func_type))
        /* If the function uses the Renesas ABI, subtract another 4 bytes from
@@ -1204,7 +1204,8 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
                          struct regcache *regcache,
                          CORE_ADDR bp_addr,
                          int nargs, struct value **args,
                          struct regcache *regcache,
                          CORE_ADDR bp_addr,
                          int nargs, struct value **args,
-                         CORE_ADDR sp, int struct_return,
+                         CORE_ADDR sp,
+                         function_call_return_method return_method,
                          CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
                          CORE_ADDR struct_addr)
 {
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
@@ -1223,8 +1224,8 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
      non-vararg argument to be on the stack, no matter how many
      registers have been used so far.  */
   if (sh_is_renesas_calling_convention (func_type)
      non-vararg argument to be on the stack, no matter how many
      registers have been used so far.  */
   if (sh_is_renesas_calling_convention (func_type)
-      && TYPE_VARARGS (func_type))
-    last_reg_arg = TYPE_NFIELDS (func_type) - 2;
+      && func_type->has_varargs ())
+    last_reg_arg = func_type->num_fields () - 2;
 
   /* First force sp to a 4-byte alignment.  */
   sp = sh_frame_align (gdbarch, sp);
 
   /* First force sp to a 4-byte alignment.  */
   sp = sh_frame_align (gdbarch, sp);
@@ -1247,10 +1248,10 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
       /* Renesas ABI pushes doubles and long longs entirely on stack.
         Same goes for aggregate types.  */
       if (sh_is_renesas_calling_convention (func_type)
       /* Renesas ABI pushes doubles and long longs entirely on stack.
         Same goes for aggregate types.  */
       if (sh_is_renesas_calling_convention (func_type)
-         && ((TYPE_CODE (type) == TYPE_CODE_INT && len >= 8)
-             || (TYPE_CODE (type) == TYPE_CODE_FLT && len >= 8)
-             || TYPE_CODE (type) == TYPE_CODE_STRUCT
-             || TYPE_CODE (type) == TYPE_CODE_UNION))
+         && ((type->code () == TYPE_CODE_INT && len >= 8)
+             || (type->code () == TYPE_CODE_FLT && len >= 8)
+             || type->code () == TYPE_CODE_STRUCT
+             || type->code () == TYPE_CODE_UNION))
        pass_on_stack = 1;
       while (len > 0)
        {
        pass_on_stack = 1;
       while (len > 0)
        {
@@ -1258,7 +1259,7 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
              || argnum > last_reg_arg)
            {
              /* The remainder of the data goes entirely on the stack,
              || argnum > last_reg_arg)
            {
              /* The remainder of the data goes entirely on the stack,
-                4-byte aligned.  */
+                4-byte aligned.  */
              reg_size = (len + 3) & ~3;
              write_memory (sp + stack_offset, val, reg_size);
              stack_offset += reg_size;
              reg_size = (len + 3) & ~3;
              write_memory (sp + stack_offset, val, reg_size);
              stack_offset += reg_size;
@@ -1278,7 +1279,7 @@ sh_push_dummy_call_nofpu (struct gdbarch *gdbarch,
        }
     }
 
        }
     }
 
-  if (struct_return)
+  if (return_method == return_method_struct)
     {
       if (sh_is_renesas_calling_convention (func_type))
        /* If the function uses the Renesas ABI, subtract another 4 bytes from
     {
       if (sh_is_renesas_calling_convention (func_type))
        /* If the function uses the Renesas ABI, subtract another 4 bytes from
@@ -1324,7 +1325,7 @@ sh_extract_return_value_nofpu (struct type *type, struct regcache *regcache,
     {
       int i, regnum = R0_REGNUM;
       for (i = 0; i < len; i += 4)
     {
       int i, regnum = R0_REGNUM;
       for (i = 0; i < len; i += 4)
-       regcache_raw_read (regcache, regnum++, valbuf + i);
+       regcache->raw_read (regnum++, valbuf + i);
     }
   else
     error (_("bad size for return value"));
     }
   else
     error (_("bad size for return value"));
@@ -1341,10 +1342,10 @@ sh_extract_return_value_fpu (struct type *type, struct regcache *regcache,
       int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
        if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
       int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
        if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
-         regcache_raw_read (regcache, regnum++,
+         regcache->raw_read (regnum++,
                             valbuf + len - 4 - i);
        else
                             valbuf + len - 4 - i);
        else
-         regcache_raw_read (regcache, regnum++, valbuf + i);
+         regcache->raw_read (regnum++, valbuf + i);
     }
   else
     sh_extract_return_value_nofpu (type, regcache, valbuf);
     }
   else
     sh_extract_return_value_nofpu (type, regcache, valbuf);
@@ -1374,7 +1375,7 @@ sh_store_return_value_nofpu (struct type *type, struct regcache *regcache,
     {
       int i, regnum = R0_REGNUM;
       for (i = 0; i < len; i += 4)
     {
       int i, regnum = R0_REGNUM;
       for (i = 0; i < len; i += 4)
-       regcache_raw_write (regcache, regnum++, valbuf + i);
+       regcache->raw_write (regnum++, valbuf + i);
     }
 }
 
     }
 }
 
@@ -1389,10 +1390,10 @@ sh_store_return_value_fpu (struct type *type, struct regcache *regcache,
       int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
        if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
       int i, regnum = gdbarch_fp0_regnum (gdbarch);
       for (i = 0; i < len; i += 4)
        if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE)
-         regcache_raw_write (regcache, regnum++,
+         regcache->raw_write (regnum++,
                              valbuf + len - 4 - i);
        else
                              valbuf + len - 4 - i);
        else
-         regcache_raw_write (regcache, regnum++, valbuf + i);
+         regcache->raw_write (regnum++, valbuf + i);
     }
   else
     sh_store_return_value_nofpu (type, regcache, valbuf);
     }
   else
     sh_store_return_value_nofpu (type, regcache, valbuf);
@@ -1405,8 +1406,8 @@ sh_return_value_nofpu (struct gdbarch *gdbarch, struct value *function,
 {
   struct type *func_type = function ? value_type (function) : NULL;
 
 {
   struct type *func_type = function ? value_type (function) : NULL;
 
-  if (sh_use_struct_convention_nofpu (
-       sh_is_renesas_calling_convention (func_type), type))
+  if (sh_use_struct_convention_nofpu
+       (sh_is_renesas_calling_convention (func_type), type))
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (writebuf)
     sh_store_return_value_nofpu (type, regcache, writebuf);
     return RETURN_VALUE_STRUCT_CONVENTION;
   if (writebuf)
     sh_store_return_value_nofpu (type, regcache, writebuf);
@@ -1558,7 +1559,7 @@ sh_littlebyte_bigword_type (struct gdbarch *gdbarch)
   if (tdep->sh_littlebyte_bigword_type == NULL)
     tdep->sh_littlebyte_bigword_type
       = arch_float_type (gdbarch, -1, "builtin_type_sh_littlebyte_bigword",
   if (tdep->sh_littlebyte_bigword_type == NULL)
     tdep->sh_littlebyte_bigword_type
       = arch_float_type (gdbarch, -1, "builtin_type_sh_littlebyte_bigword",
-                         floatformats_ieee_double_littlebyte_bigword);
+                        floatformats_ieee_double_littlebyte_bigword);
 
   return tdep->sh_littlebyte_bigword_type;
 }
 
   return tdep->sh_littlebyte_bigword_type;
 }
@@ -1668,7 +1669,7 @@ sh_pseudo_register_read (struct gdbarch *gdbarch, readable_regcache *regcache,
                                              2, base_regnum, temp_buffer);
       if (status == REG_VALID)
        {
                                              2, base_regnum, temp_buffer);
       if (status == REG_VALID)
        {
-         /* We must pay attention to the endiannes. */
+         /* We must pay attention to the endianness. */
          sh_register_convert_to_virtual (gdbarch, reg_nr,
                                          register_type (gdbarch, reg_nr),
                                          temp_buffer, buffer);
          sh_register_convert_to_virtual (gdbarch, reg_nr,
                                          register_type (gdbarch, reg_nr),
                                          temp_buffer, buffer);
@@ -1696,14 +1697,14 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
   if (reg_nr == PSEUDO_BANK_REGNUM)
     {
       /* When the bank register is written to, the whole register bank
   if (reg_nr == PSEUDO_BANK_REGNUM)
     {
       /* When the bank register is written to, the whole register bank
-         is switched and all values in the bank registers must be read
+        is switched and all values in the bank registers must be read
         from the target/sim again.  We're just invalidating the regcache
         so that a re-read happens next time it's necessary.  */
       int bregnum;
 
         from the target/sim again.  We're just invalidating the regcache
         so that a re-read happens next time it's necessary.  */
       int bregnum;
 
-      regcache_raw_write (regcache, BANK_REGNUM, buffer);
+      regcache->raw_write (BANK_REGNUM, buffer);
       for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
       for (bregnum = R0_BANK0_REGNUM; bregnum < MACLB_REGNUM; ++bregnum)
-        regcache_invalidate (regcache, bregnum);
+       regcache->invalidate (bregnum);
     }
   else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
     {
     }
   else if (reg_nr >= DR0_REGNUM && reg_nr <= DR_LAST_REGNUM)
     {
@@ -1711,13 +1712,13 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
       gdb_byte temp_buffer[4 * 2];
       base_regnum = dr_reg_base_num (gdbarch, reg_nr);
 
       gdb_byte temp_buffer[4 * 2];
       base_regnum = dr_reg_base_num (gdbarch, reg_nr);
 
-      /* We must pay attention to the endiannes.  */
+      /* We must pay attention to the endianness.  */
       sh_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr),
                                  reg_nr, buffer, temp_buffer);
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 2; portion++)
       sh_register_convert_to_raw (gdbarch, register_type (gdbarch, reg_nr),
                                  reg_nr, buffer, temp_buffer);
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 2; portion++)
-       regcache_raw_write (regcache, base_regnum + portion,
+       regcache->raw_write (base_regnum + portion,
                            (temp_buffer
                             + register_size (gdbarch,
                                              base_regnum) * portion));
                            (temp_buffer
                             + register_size (gdbarch,
                                              base_regnum) * portion));
@@ -1728,7 +1729,7 @@ sh_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 4; portion++)
 
       /* Write the real regs for which this one is an alias.  */
       for (portion = 0; portion < 4; portion++)
-       regcache_raw_write (regcache, base_regnum + portion,
+       regcache->raw_write (base_regnum + portion,
                            (buffer
                             + register_size (gdbarch,
                                              base_regnum) * portion));
                            (buffer
                             + register_size (gdbarch,
                                              base_regnum) * portion));
@@ -1759,25 +1760,25 @@ sh_sh2a_register_sim_regno (struct gdbarch *gdbarch, int nr)
   switch (nr)
     {
       case TBR_REGNUM:
   switch (nr)
     {
       case TBR_REGNUM:
-        return SIM_SH_TBR_REGNUM;
+       return SIM_SH_TBR_REGNUM;
       case IBNR_REGNUM:
       case IBNR_REGNUM:
-        return SIM_SH_IBNR_REGNUM;
+       return SIM_SH_IBNR_REGNUM;
       case IBCR_REGNUM:
       case IBCR_REGNUM:
-        return SIM_SH_IBCR_REGNUM;
+       return SIM_SH_IBCR_REGNUM;
       case BANK_REGNUM:
       case BANK_REGNUM:
-        return SIM_SH_BANK_REGNUM;
+       return SIM_SH_BANK_REGNUM;
       case MACLB_REGNUM:
       case MACLB_REGNUM:
-        return SIM_SH_BANK_MACL_REGNUM;
+       return SIM_SH_BANK_MACL_REGNUM;
       case GBRB_REGNUM:
       case GBRB_REGNUM:
-        return SIM_SH_BANK_GBR_REGNUM;
+       return SIM_SH_BANK_GBR_REGNUM;
       case PRB_REGNUM:
       case PRB_REGNUM:
-        return SIM_SH_BANK_PR_REGNUM;
+       return SIM_SH_BANK_PR_REGNUM;
       case IVNB_REGNUM:
       case IVNB_REGNUM:
-        return SIM_SH_BANK_IVN_REGNUM;
+       return SIM_SH_BANK_IVN_REGNUM;
       case MACHB_REGNUM:
       case MACHB_REGNUM:
-        return SIM_SH_BANK_MACH_REGNUM;
+       return SIM_SH_BANK_MACH_REGNUM;
       default:
       default:
-        break;
+       break;
     }
   return legacy_register_sim_regno (gdbarch, nr);
 }
     }
   return legacy_register_sim_regno (gdbarch, nr);
 }
@@ -1791,7 +1792,7 @@ sh_sh2a_register_sim_regno (struct gdbarch *gdbarch, int nr)
 
 static void
 sh_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 
 static void
 sh_dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
-                          struct dwarf2_frame_state_reg *reg,
+                         struct dwarf2_frame_state_reg *reg,
                          struct frame_info *this_frame)
 {
   /* Mark the PC as the destination for the return address.  */
                          struct frame_info *this_frame)
 {
   /* Mark the PC as the destination for the return address.  */
@@ -1905,12 +1906,12 @@ sh_frame_cache (struct frame_info *this_frame, void **this_cache)
   if (!cache->uses_fp)
     {
       /* We didn't find a valid frame, which means that CACHE->base
   if (!cache->uses_fp)
     {
       /* We didn't find a valid frame, which means that CACHE->base
-         currently holds the frame pointer for our calling frame.  If
-         we're at the start of a function, or somewhere half-way its
-         prologue, the function's frame probably hasn't been fully
-         setup yet.  Try to reconstruct the base address for the stack
-         frame by looking at the stack pointer.  For truly "frameless"
-         functions this might work too.  */
+        currently holds the frame pointer for our calling frame.  If
+        we're at the start of a function, or somewhere half-way its
+        prologue, the function's frame probably hasn't been fully
+        setup yet.  Try to reconstruct the base address for the stack
+        frame by looking at the stack pointer.  For truly "frameless"
+        functions this might work too.  */
       cache->base = get_frame_register_unsigned
                     (this_frame, gdbarch_sp_regnum (gdbarch));
     }
       cache->base = get_frame_register_unsigned
                     (this_frame, gdbarch_sp_regnum (gdbarch));
     }
@@ -1948,7 +1949,7 @@ sh_frame_prev_register (struct frame_info *this_frame,
 
   if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
     return frame_unwind_got_memory (this_frame, regnum,
 
   if (regnum < SH_NUM_REGS && cache->saved_regs[regnum] != -1)
     return frame_unwind_got_memory (this_frame, regnum,
-                                    cache->saved_regs[regnum]);
+                                   cache->saved_regs[regnum]);
 
   return frame_unwind_got_register (this_frame, regnum, regnum);
 }
 
   return frame_unwind_got_register (this_frame, regnum, regnum);
 }
@@ -1967,6 +1968,7 @@ sh_frame_this_id (struct frame_info *this_frame, void **this_cache,
 }
 
 static const struct frame_unwind sh_frame_unwind = {
 }
 
 static const struct frame_unwind sh_frame_unwind = {
+  "sh prologue",
   NORMAL_FRAME,
   default_frame_unwind_stop_reason,
   sh_frame_this_id,
   NORMAL_FRAME,
   default_frame_unwind_stop_reason,
   sh_frame_this_id,
@@ -1975,28 +1977,6 @@ static const struct frame_unwind sh_frame_unwind = {
   default_frame_sniffer
 };
 
   default_frame_sniffer
 };
 
-static CORE_ADDR
-sh_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame,
-                                        gdbarch_sp_regnum (gdbarch));
-}
-
-static CORE_ADDR
-sh_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
-{
-  return frame_unwind_register_unsigned (next_frame,
-                                        gdbarch_pc_regnum (gdbarch));
-}
-
-static struct frame_id
-sh_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
-{
-  CORE_ADDR sp = get_frame_register_unsigned (this_frame,
-                                             gdbarch_sp_regnum (gdbarch));
-  return frame_id_build (sp, get_frame_pc (this_frame));
-}
-
 static CORE_ADDR
 sh_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
 static CORE_ADDR
 sh_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
@@ -2028,7 +2008,7 @@ sh_make_stub_cache (struct frame_info *this_frame)
 
 static void
 sh_stub_this_id (struct frame_info *this_frame, void **this_cache,
 
 static void
 sh_stub_this_id (struct frame_info *this_frame, void **this_cache,
-                 struct frame_id *this_id)
+                struct frame_id *this_id)
 {
   struct sh_frame_cache *cache;
 
 {
   struct sh_frame_cache *cache;
 
@@ -2041,8 +2021,8 @@ sh_stub_this_id (struct frame_info *this_frame, void **this_cache,
 
 static int
 sh_stub_unwind_sniffer (const struct frame_unwind *self,
 
 static int
 sh_stub_unwind_sniffer (const struct frame_unwind *self,
-                        struct frame_info *this_frame,
-                        void **this_prologue_cache)
+                       struct frame_info *this_frame,
+                       void **this_prologue_cache)
 {
   CORE_ADDR addr_in_block;
 
 {
   CORE_ADDR addr_in_block;
 
@@ -2055,6 +2035,7 @@ sh_stub_unwind_sniffer (const struct frame_unwind *self,
 
 static const struct frame_unwind sh_stub_unwind =
 {
 
 static const struct frame_unwind sh_stub_unwind =
 {
+  "sh stub",
   NORMAL_FRAME,
   default_frame_unwind_stop_reason,
   sh_stub_this_id,
   NORMAL_FRAME,
   default_frame_unwind_stop_reason,
   sh_stub_this_id,
@@ -2079,9 +2060,9 @@ sh_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
     {
       ULONGEST inst;
       /* The sh epilogue is max. 14 bytes long.  Give another 14 bytes
     {
       ULONGEST inst;
       /* The sh epilogue is max. 14 bytes long.  Give another 14 bytes
-         for a nop and some fixed data (e.g. big offsets) which are
-         unfortunately also treated as part of the function (which
-         means, they are below func_end.  */
+        for a nop and some fixed data (e.g. big offsets) which are
+        unfortunately also treated as part of the function (which
+        means, they are below func_end.  */
       CORE_ADDR addr = func_end - 28;
       if (addr < func_addr + 4)
        addr = func_addr + 4;
       CORE_ADDR addr = func_end - 28;
       if (addr < func_addr + 4)
        addr = func_addr + 4;
@@ -2096,8 +2077,8 @@ sh_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
        return 0;
 
       /* At this point we should find a mov.l @r15+,r14 instruction,
        return 0;
 
       /* At this point we should find a mov.l @r15+,r14 instruction,
-         either before or after the rts.  If not, then the function has
-         probably no "normal" epilogue and we bail out here.  */
+        either before or after the rts.  If not, then the function has
+        probably no "normal" epilogue and we bail out here.  */
       inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
       if (IS_RESTORE_FP (read_memory_unsigned_integer (addr - 2, 2,
                                                       byte_order)))
       inst = read_memory_unsigned_integer (addr - 2, 2, byte_order);
       if (IS_RESTORE_FP (read_memory_unsigned_integer (addr - 2, 2,
                                                       byte_order)))
@@ -2130,7 +2111,7 @@ sh_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
        }
 
       /* Now check for FP adjustments, using add #imm,r14 or add rX, r14
        }
 
       /* Now check for FP adjustments, using add #imm,r14 or add rX, r14
-         instructions.  */
+        instructions.  */
       while (addr > func_addr + 4
             && (IS_ADD_REG_TO_FP (inst) || IS_ADD_IMM_FP (inst)))
        {
       while (addr > func_addr + 4
             && (IS_ADD_REG_TO_FP (inst) || IS_ADD_IMM_FP (inst)))
        {
@@ -2139,10 +2120,10 @@ sh_stack_frame_destroyed_p (struct gdbarch *gdbarch, CORE_ADDR pc)
        }
 
       /* On SH2a check if the previous instruction was perhaps a MOVI20.
        }
 
       /* On SH2a check if the previous instruction was perhaps a MOVI20.
-         That's allowed for the epilogue.  */
+        That's allowed for the epilogue.  */
       if ((gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a
       if ((gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a
-           || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a_nofpu)
-          && addr > func_addr + 6
+          || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_sh2a_nofpu)
+         && addr > func_addr + 6
          && IS_MOVI20 (read_memory_unsigned_integer (addr - 4, 2,
                                                      byte_order)))
        addr -= 4;
          && IS_MOVI20 (read_memory_unsigned_integer (addr - 4, 2,
                                                      byte_order)))
        addr -= 4;
@@ -2175,8 +2156,8 @@ sh_corefile_supply_regset (const struct regset *regset,
     {
       if ((regnum == -1 || regnum == regmap[i].regnum)
          && regmap[i].offset + 4 <= len)
     {
       if ((regnum == -1 || regnum == regmap[i].regnum)
          && regmap[i].offset + 4 <= len)
-       regcache_raw_supply (regcache, regmap[i].regnum,
-                            (char *)regs + regmap[i].offset);
+       regcache->raw_supply
+         (regmap[i].regnum, (char *) regs + regmap[i].offset);
     }
 }
 
     }
 }
 
@@ -2201,7 +2182,7 @@ sh_corefile_collect_regset (const struct regset *regset,
     {
       if ((regnum == -1 || regnum == regmap[i].regnum)
          && regmap[i].offset + 4 <= len)
     {
       if ((regnum == -1 || regnum == regmap[i].regnum)
          && regmap[i].offset + 4 <= len)
-       regcache_raw_collect (regcache, regmap[i].regnum,
+       regcache->raw_collect (regmap[i].regnum,
                              (char *)regs + regmap[i].offset);
     }
 }
                              (char *)regs + regmap[i].offset);
     }
 }
@@ -2232,10 +2213,12 @@ sh_iterate_over_regset_sections (struct gdbarch *gdbarch,
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep->core_gregmap != NULL)
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
   if (tdep->core_gregmap != NULL)
-    cb (".reg", tdep->sizeof_gregset, &sh_corefile_gregset, NULL, cb_data);
+    cb (".reg", tdep->sizeof_gregset, tdep->sizeof_gregset,
+       &sh_corefile_gregset, NULL, cb_data);
 
   if (tdep->core_fpregmap != NULL)
 
   if (tdep->core_fpregmap != NULL)
-    cb (".reg2", tdep->sizeof_fpregset, &sh_corefile_fpregset, NULL, cb_data);
+    cb (".reg2", tdep->sizeof_fpregset, tdep->sizeof_fpregset,
+       &sh_corefile_fpregset, NULL, cb_data);
 }
 
 /* This is the implementation of gdbarch method
 }
 
 /* This is the implementation of gdbarch method
@@ -2305,9 +2288,6 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 
   set_gdbarch_frame_align (gdbarch, sh_frame_align);
   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 
   set_gdbarch_frame_align (gdbarch, sh_frame_align);
-  set_gdbarch_unwind_sp (gdbarch, sh_unwind_sp);
-  set_gdbarch_unwind_pc (gdbarch, sh_unwind_pc);
-  set_gdbarch_dummy_id (gdbarch, sh_dummy_id);
   frame_base_set_default (gdbarch, &sh_frame_base);
 
   set_gdbarch_stack_frame_destroyed_p (gdbarch, sh_stack_frame_destroyed_p);
   frame_base_set_default (gdbarch, &sh_frame_base);
 
   set_gdbarch_stack_frame_destroyed_p (gdbarch, sh_stack_frame_destroyed_p);
@@ -2430,29 +2410,16 @@ sh_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   return gdbarch;
 }
 
   return gdbarch;
 }
 
-static void
-show_sh_command (const char *args, int from_tty)
-{
-  help_list (showshcmdlist, "show sh ", all_commands, gdb_stdout);
-}
-
-static void
-set_sh_command (const char *args, int from_tty)
-{
-  printf_unfiltered
-    ("\"set sh\" must be followed by an appropriate subcommand.\n");
-  help_list (setshcmdlist, "set sh ", all_commands, gdb_stdout);
-}
-
+void _initialize_sh_tdep ();
 void
 void
-_initialize_sh_tdep (void)
+_initialize_sh_tdep ()
 {
   gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
 
 {
   gdbarch_register (bfd_arch_sh, sh_gdbarch_init, NULL);
 
-  add_prefix_cmd ("sh", no_class, set_sh_command, "SH specific commands.",
-                  &setshcmdlist, "set sh ", 0, &setlist);
-  add_prefix_cmd ("sh", no_class, show_sh_command, "SH specific commands.",
-                  &showshcmdlist, "show sh ", 0, &showlist);
+  add_basic_prefix_cmd ("sh", no_class, "SH specific commands.",
+                       &setshcmdlist, 0, &setlist);
+  add_show_prefix_cmd ("sh", no_class, "SH specific commands.",
+                      &showshcmdlist, 0, &showlist);
   
   add_setshow_enum_cmd ("calling-convention", class_vars, sh_cc_enum,
                        &sh_active_calling_convention,
   
   add_setshow_enum_cmd ("calling-convention", class_vars, sh_cc_enum,
                        &sh_active_calling_convention,
GDB Binutils - Deliverables
This page took 0.035357 seconds and 4 git commands to generate.