gdb: Fix build failure with GCC 7

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

diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index 5674f94c728ac32be4dc0c9307c713cc4ad12413..99824b7f8aae17b2b5dad87f6fcb7fab229a1e47 100644 (file)
--- a/gdb/iq2000-tdep.c
+++ b/gdb/iq2000-tdep.c
@@ -1,8 +1,7 @@
 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
    Debugger.
 
 /* Target-dependent code for the IQ2000 architecture, for GDB, the GNU
    Debugger.
 

-   Copyright (C) 2000, 2004, 2005, 2007, 2008, 2009, 2010, 2011
-   Free Software Foundation, Inc.
+   Copyright (C) 2000-2017 Free Software Foundation, Inc.

 
    Contributed by Red Hat.
 
 
    Contributed by Red Hat.
 


@@ -29,7 +28,6 @@
 #include "gdbtypes.h"
 #include "value.h"
 #include "dis-asm.h"
 #include "gdbtypes.h"
 #include "value.h"
 #include "dis-asm.h"

-#include "gdb_string.h"

 #include "arch-utils.h"
 #include "regcache.h"
 #include "osabi.h"
 #include "arch-utils.h"
 #include "regcache.h"
 #include "osabi.h"


@@ -84,7 +82,7 @@ insn_addr_from_ptr (CORE_ADDR ptr)    /* target_pointer to CORE_ADDR.  */
 }
 
 /* Function: pointer_to_address
 }
 
 /* Function: pointer_to_address

-   Convert a target pointer to an address in host (CORE_ADDR) format. */
+   Convert a target pointer to an address in host (CORE_ADDR) format.  */

 
 static CORE_ADDR
 iq2000_pointer_to_address (struct gdbarch *gdbarch,
 
 static CORE_ADDR
 iq2000_pointer_to_address (struct gdbarch *gdbarch,


@@ -208,8 +206,6 @@ iq2000_scan_prologue (struct gdbarch *gdbarch,
   struct symtab_and_line sal;
   CORE_ADDR pc;
   CORE_ADDR loop_end;
   struct symtab_and_line sal;
   CORE_ADDR pc;
   CORE_ADDR loop_end;

-  int found_store_lr = 0;
-  int found_decr_sp = 0;

   int srcreg;
   int tgtreg;
   signed short offset;
   int srcreg;
   int tgtreg;
   signed short offset;


@@ -233,7 +229,7 @@ iq2000_scan_prologue (struct gdbarch *gdbarch,
      only later do we compute its actual address.  Since the
      offset can be zero, we must first initialize all the 
      saved regs to minus one (so we can later distinguish 
      only later do we compute its actual address.  Since the
      offset can be zero, we must first initialize all the 
      saved regs to minus one (so we can later distinguish 

-     between one that's not saved, and one that's saved at zero). */
+     between one that's not saved, and one that's saved at zero).  */

   for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
     cache->saved_regs[srcreg] = -1;
   cache->using_fp = 0;
   for (srcreg = 0; srcreg < E_NUM_REGS; srcreg ++)
     cache->saved_regs[srcreg] = -1;
   cache->using_fp = 0;


@@ -243,7 +239,7 @@ iq2000_scan_prologue (struct gdbarch *gdbarch,
     {
       LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
       /* Skip any instructions writing to (sp) or decrementing the
     {
       LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);
       /* Skip any instructions writing to (sp) or decrementing the

-         SP. */
+         SP.  */

       if ((insn & 0xffe00000) == 0xac200000)
        {
          /* sw using SP/%1 as base.  */
       if ((insn & 0xffe00000) == 0xac200000)
        {
          /* sw using SP/%1 as base.  */


@@ -252,16 +248,13 @@ iq2000_scan_prologue (struct gdbarch *gdbarch,
          if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
            cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
 
          if (tgtreg >= 0 && tgtreg < E_NUM_REGS)
            cache->saved_regs[tgtreg] = -((signed short) (insn & 0xffff));
 

-         if (tgtreg == E_LR_REGNUM)
-           found_store_lr = 1;

          continue;
        }
 
       if ((insn & 0xffff8000) == 0x20218000)
        {
          /* addi %1, %1, -N == addi %sp, %sp, -N */
          continue;
        }
 
       if ((insn & 0xffff8000) == 0x20218000)
        {
          /* addi %1, %1, -N == addi %sp, %sp, -N */

-         /* LEGACY -- from assembly-only port */
-         found_decr_sp = 1;
+         /* LEGACY -- from assembly-only port.  */

          cache->framesize = -((signed short) (insn & 0xffff));
          continue;
        }
          cache->framesize = -((signed short) (insn & 0xffff));
          continue;
        }


@@ -284,7 +277,7 @@ iq2000_scan_prologue (struct gdbarch *gdbarch,
 
          if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
            {
 
          if (tgtreg == E_SP_REGNUM || tgtreg == E_FP_REGNUM)
            {

-             /* "push" to stack (via SP or FP reg) */
+             /* "push" to stack (via SP or FP reg).  */

              if (cache->saved_regs[srcreg] == -1) /* Don't save twice.  */
                cache->saved_regs[srcreg] = offset;
              continue;
              if (cache->saved_regs[srcreg] == -1) /* Don't save twice.  */
                cache->saved_regs[srcreg] = offset;
              continue;


@@ -374,15 +367,13 @@ iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
   int i;
 
   if (*this_cache)
   int i;
 
   if (*this_cache)

-    return *this_cache;
+    return (struct iq2000_frame_cache *) *this_cache;

 
   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
   iq2000_init_frame_cache (cache);
   *this_cache = cache;
 
   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 
   cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
   iq2000_init_frame_cache (cache);
   *this_cache = cache;
 
   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);

-  //if (cache->base == 0)
-    //return cache;

 
   current_pc = get_frame_pc (this_frame);
   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
 
   current_pc = get_frame_pc (this_frame);
   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);


@@ -404,7 +395,8 @@ static struct value *
 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
                            int regnum)
 {
 iq2000_frame_prev_register (struct frame_info *this_frame, void **this_cache,
                            int regnum)
 {

-  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
+  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+                                                        this_cache);

 
   if (regnum == E_SP_REGNUM && cache->saved_sp)
     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 
   if (regnum == E_SP_REGNUM && cache->saved_sp)
     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);


@@ -423,7 +415,8 @@ static void
 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
                      struct frame_id *this_id)
 {
 iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
                      struct frame_id *this_id)
 {

-  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
+  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+                                                        this_cache);

 
   /* This marks the outermost frame.  */
   if (cache->base == 0) 
 
   /* This marks the outermost frame.  */
   if (cache->base == 0) 


@@ -434,6 +427,7 @@ iq2000_frame_this_id (struct frame_info *this_frame, void **this_cache,
 
 static const struct frame_unwind iq2000_frame_unwind = {
   NORMAL_FRAME,
 
 static const struct frame_unwind iq2000_frame_unwind = {
   NORMAL_FRAME,

+  default_frame_unwind_stop_reason,

   iq2000_frame_this_id,
   iq2000_frame_prev_register,
   NULL,
   iq2000_frame_this_id,
   iq2000_frame_prev_register,
   NULL,


@@ -462,7 +456,8 @@ iq2000_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 static CORE_ADDR
 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {
 static CORE_ADDR
 iq2000_frame_base_address (struct frame_info *this_frame, void **this_cache)
 {

-  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame, this_cache);
+  struct iq2000_frame_cache *cache = iq2000_frame_cache (this_frame,
+                                                        this_cache);

 
   return cache->base;
 }
 
   return cache->base;
 }


@@ -474,18 +469,23 @@ static const struct frame_base iq2000_frame_base = {
   iq2000_frame_base_address
 };
 
   iq2000_frame_base_address
 };
 

-static const unsigned char *
-iq2000_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
-                          int *lenptr)
+static int
+iq2000_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)

 {
 {

-  static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
-  static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
-

   if ((*pcptr & 3) != 0)
   if ((*pcptr & 3) != 0)

-    error ("breakpoint_from_pc: invalid breakpoint address 0x%lx",
+    error (_("breakpoint_from_pc: invalid breakpoint address 0x%lx"),

           (long) *pcptr);
 
           (long) *pcptr);
 

-  *lenptr = 4;
+  return 4;
+}
+
+static const gdb_byte *
+iq2000_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
+{
+  static const unsigned char big_breakpoint[] = { 0x00, 0x00, 0x00, 0x0d };
+  static const unsigned char little_breakpoint[] = { 0x0d, 0x00, 0x00, 0x00 };
+  *size = kind;
+

   return (gdbarch_byte_order (gdbarch)
          == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
 }
   return (gdbarch_byte_order (gdbarch)
          == BFD_ENDIAN_BIG) ? big_breakpoint : little_breakpoint;
 }


@@ -505,7 +505,7 @@ iq2000_store_return_value (struct type *type, struct regcache *regcache,
 
   while (len > 0)
     {
 
   while (len > 0)
     {

-      char buf[4];
+      gdb_byte buf[4];

       int size = len % 4 ?: 4;
 
       memset (buf, 0, 4);
       int size = len % 4 ?: 4;
 
       memset (buf, 0, 4);


@@ -537,7 +537,7 @@ iq2000_use_struct_convention (struct type *type)
 
 static void
 iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 
 static void
 iq2000_extract_return_value (struct type *type, struct regcache *regcache,

-                            void *valbuf)
+                            gdb_byte *valbuf)

 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 {
   struct gdbarch *gdbarch = get_regcache_arch (regcache);
   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);


@@ -564,7 +564,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
          regcache_cooked_read_unsigned (regcache, regno++, &tmp);
          store_unsigned_integer (valbuf, size, byte_order, tmp);
          len -= size;
          regcache_cooked_read_unsigned (regcache, regno++, &tmp);
          store_unsigned_integer (valbuf, size, byte_order, tmp);
          len -= size;

-         valbuf = ((char *) valbuf) + size;
+         valbuf += size;

        }
     }
   else
        }
     }
   else


@@ -579,7 +579,7 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
 }
 
 static enum return_value_convention
 }
 
 static enum return_value_convention

-iq2000_return_value (struct gdbarch *gdbarch, struct type *func_type,
+iq2000_return_value (struct gdbarch *gdbarch, struct value *function,

                     struct type *type, struct regcache *regcache,
                     gdb_byte *readbuf, const gdb_byte *writebuf)
 {
                     struct type *type, struct regcache *regcache,
                     gdb_byte *readbuf, const gdb_byte *writebuf)
 {


@@ -609,7 +609,7 @@ iq2000_frame_align (struct gdbarch *ignore, CORE_ADDR sp)
 }
 
 /* Convenience function to check 8-byte types for being a scalar type
 }
 
 /* Convenience function to check 8-byte types for being a scalar type

-   or a struct with only one long long or double member. */
+   or a struct with only one long long or double member.  */

 static int
 iq2000_pass_8bytetype_by_address (struct type *type)
 {
 static int
 iq2000_pass_8bytetype_by_address (struct type *type)
 {


@@ -637,7 +637,7 @@ iq2000_pass_8bytetype_by_address (struct type *type)
   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
       || TYPE_CODE (ftype) == TYPE_CODE_INT)
     return 0;
   if (TYPE_CODE (ftype) == TYPE_CODE_FLT
       || TYPE_CODE (ftype) == TYPE_CODE_INT)
     return 0;

-  /* Everything else, pass by address. */
+  /* Everything else, pass by address.  */

   return 1;
 }
 
   return 1;
 }
 


@@ -653,10 +653,10 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   struct type *type;
   int i, argreg, typelen, slacklen;
   int stackspace = 0;
   struct type *type;
   int i, argreg, typelen, slacklen;
   int stackspace = 0;

-  /* Used to copy struct arguments into the stack. */
+  /* Used to copy struct arguments into the stack.  */

   CORE_ADDR struct_ptr;
 
   CORE_ADDR struct_ptr;
 

-  /* First determine how much stack space we will need. */
+  /* First determine how much stack space we will need.  */

   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
     {
       type = value_type (args[i]);
   for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
     {
       type = value_type (args[i]);


@@ -675,19 +675,19 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
         {
           /* long long, 
              double, and possibly
         {
           /* long long, 
              double, and possibly

-             structs with a single field of long long or double. */
+             structs with a single field of long long or double.  */

           if (argreg <= E_LAST_ARGREG - 1)
             {
               /* 8-byte arg goes into a register pair
           if (argreg <= E_LAST_ARGREG - 1)
             {
               /* 8-byte arg goes into a register pair

-                 (must start with an even-numbered reg) */
+                 (must start with an even-numbered reg).  */

               if (((argreg - E_1ST_ARGREG) % 2) != 0)
                 argreg ++;
               argreg += 2;
             }
           else
             {
               if (((argreg - E_1ST_ARGREG) % 2) != 0)
                 argreg ++;
               argreg += 2;
             }
           else
             {

-              argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
-              /* 8-byte arg goes on stack, must be 8-byte aligned. */
+              argreg = E_LAST_ARGREG + 1;       /* no more argregs.  */
+              /* 8-byte arg goes on stack, must be 8-byte aligned.  */

               stackspace = ((stackspace + 7) & ~7);
               stackspace += 8;
             }
               stackspace = ((stackspace + 7) & ~7);
               stackspace += 8;
             }


@@ -696,7 +696,7 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
        {
          /* Structs are passed as pointer to a copy of the struct.
             So we need room on the stack for a copy of the struct
        {
          /* Structs are passed as pointer to a copy of the struct.
             So we need room on the stack for a copy of the struct

-            plus for the argument pointer. */
+            plus for the argument pointer.  */

           if (argreg <= E_LAST_ARGREG)
             argreg++;
           else
           if (argreg <= E_LAST_ARGREG)
             argreg++;
           else


@@ -707,7 +707,7 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
     }
 
   /* Now copy params, in ascending order, into their assigned location
     }
 
   /* Now copy params, in ascending order, into their assigned location

-     (either in a register or on the stack). */
+     (either in a register or on the stack).  */

 
   sp -= (sp % 8);       /* align */
   struct_ptr = sp;
 
   sp -= (sp % 8);       /* align */
   struct_ptr = sp;


@@ -718,7 +718,7 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   argreg = E_1ST_ARGREG;
   if (struct_return)
     {
   argreg = E_1ST_ARGREG;
   if (struct_return)
     {

-      /* A function that returns a struct will consume one argreg to do so. 
+      /* A function that returns a struct will consume one argreg to do so.

        */
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
     }
        */
       regcache_cooked_write_unsigned (regcache, argreg++, struct_addr);
     }


@@ -730,18 +730,18 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       val = value_contents (args[i]);
       if (typelen <= 4)
         {
       val = value_contents (args[i]);
       if (typelen <= 4)
         {

-          /* Char, short, int, float, pointer, and structs <= four bytes. */
+          /* Char, short, int, float, pointer, and structs <= four bytes.  */

          slacklen = (4 - (typelen % 4)) % 4;
          memset (buf, 0, sizeof (buf));
          memcpy (buf + slacklen, val, typelen);
           if (argreg <= E_LAST_ARGREG)
             {
          slacklen = (4 - (typelen % 4)) % 4;
          memset (buf, 0, sizeof (buf));
          memcpy (buf + slacklen, val, typelen);
           if (argreg <= E_LAST_ARGREG)
             {

-              /* Passed in a register. */
+              /* Passed in a register.  */

              regcache_raw_write (regcache, argreg++, buf);
             }
           else
             {
              regcache_raw_write (regcache, argreg++, buf);
             }
           else
             {

-              /* Passed on the stack. */
+              /* Passed on the stack.  */

               write_memory (sp + stackspace, buf, 4);
               stackspace += 4;
             }
               write_memory (sp + stackspace, buf, 4);
               stackspace += 4;
             }


@@ -749,11 +749,11 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
         {
           /* (long long), (double), or struct consisting of 
       else if (typelen == 8 && !iq2000_pass_8bytetype_by_address (type))
         {
           /* (long long), (double), or struct consisting of 

-             a single (long long) or (double). */
+             a single (long long) or (double).  */

           if (argreg <= E_LAST_ARGREG - 1)
             {
               /* 8-byte arg goes into a register pair
           if (argreg <= E_LAST_ARGREG - 1)
             {
               /* 8-byte arg goes into a register pair

-                 (must start with an even-numbered reg) */
+                 (must start with an even-numbered reg).  */

               if (((argreg - E_1ST_ARGREG) % 2) != 0)
                 argreg++;
              regcache_raw_write (regcache, argreg++, val);
               if (((argreg - E_1ST_ARGREG) % 2) != 0)
                 argreg++;
              regcache_raw_write (regcache, argreg++, val);


@@ -761,8 +761,8 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
             }
           else
             {
             }
           else
             {

-              /* 8-byte arg goes on stack, must be 8-byte aligned. */
-              argreg = E_LAST_ARGREG + 1;       /* no more argregs. */
+              /* 8-byte arg goes on stack, must be 8-byte aligned.  */
+              argreg = E_LAST_ARGREG + 1;       /* no more argregs.  */

               stackspace = ((stackspace + 7) & ~7);
               write_memory (sp + stackspace, val, typelen);
               stackspace += 8;
               stackspace = ((stackspace + 7) & ~7);
               write_memory (sp + stackspace, val, typelen);
               stackspace += 8;


@@ -786,13 +786,13 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
         }
     }
 
         }
     }
 

-  /* Store return address. */
+  /* Store return address.  */

   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 
   regcache_cooked_write_unsigned (regcache, E_LR_REGNUM, bp_addr);
 
   /* Update stack pointer.  */
   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 

-  /* And that should do it.  Return the new stack pointer. */
+  /* And that should do it.  Return the new stack pointer.  */

   return sp;
 }
 
   return sp;
 }
 


@@ -831,11 +831,13 @@ iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   set_gdbarch_double_format        (gdbarch, floatformats_ieee_double);
   set_gdbarch_long_double_format   (gdbarch, floatformats_ieee_double);
   set_gdbarch_return_value        (gdbarch, iq2000_return_value);
   set_gdbarch_double_format        (gdbarch, floatformats_ieee_double);
   set_gdbarch_long_double_format   (gdbarch, floatformats_ieee_double);
   set_gdbarch_return_value        (gdbarch, iq2000_return_value);

-  set_gdbarch_breakpoint_from_pc   (gdbarch, iq2000_breakpoint_from_pc);
+  set_gdbarch_breakpoint_kind_from_pc (gdbarch,
+                                      iq2000_breakpoint_kind_from_pc);
+  set_gdbarch_sw_breakpoint_from_kind (gdbarch,
+                                      iq2000_sw_breakpoint_from_kind);

   set_gdbarch_frame_args_skip      (gdbarch, 0);
   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);
   set_gdbarch_frame_args_skip      (gdbarch, 0);
   set_gdbarch_skip_prologue        (gdbarch, iq2000_skip_prologue);
   set_gdbarch_inner_than           (gdbarch, core_addr_lessthan);

-  set_gdbarch_print_insn           (gdbarch, print_insn_iq2000);

   set_gdbarch_register_type (gdbarch, iq2000_register_type);
   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);
   set_gdbarch_register_type (gdbarch, iq2000_register_type);
   set_gdbarch_frame_align (gdbarch, iq2000_frame_align);
   set_gdbarch_unwind_sp (gdbarch, iq2000_unwind_sp);


@@ -854,7 +856,7 @@ iq2000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 
 /* Function: _initialize_iq2000_tdep
    Initializer function for the iq2000 module.
 
 /* Function: _initialize_iq2000_tdep
    Initializer function for the iq2000 module.

-   Called by gdb at start-up. */
+   Called by gdb at start-up.  */

 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_iq2000_tdep;
 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
 extern initialize_file_ftype _initialize_iq2000_tdep;