Automatic date update in version.in

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

diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index 46d818d..c37f763 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
-   Free Software Foundation, Inc.
+   Copyright (C) 2000-2019 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,14 +82,16 @@ 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,
                           struct type * type, const gdb_byte * buf)
 {
 
 static CORE_ADDR
 iq2000_pointer_to_address (struct gdbarch *gdbarch,
                           struct type * type, const gdb_byte * buf)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));

-  CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
+  CORE_ADDR addr
+    = extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);

 
   if (target == TYPE_CODE_FUNC
       || target == TYPE_CODE_METHOD
 
   if (target == TYPE_CODE_FUNC
       || target == TYPE_CODE_METHOD


@@ -108,11 +108,12 @@ static void
 iq2000_address_to_pointer (struct gdbarch *gdbarch,
                           struct type *type, gdb_byte *buf, CORE_ADDR addr)
 {
 iq2000_address_to_pointer (struct gdbarch *gdbarch,
                           struct type *type, gdb_byte *buf, CORE_ADDR addr)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 
   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
     addr = insn_ptr_from_addr (addr);
   enum type_code target = TYPE_CODE (TYPE_TARGET_TYPE (type));
 
   if (target == TYPE_CODE_FUNC || target == TYPE_CODE_METHOD)
     addr = insn_ptr_from_addr (addr);

-  store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
+  store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);

 }
 
 /* Real register methods: */
 }
 
 /* Real register methods: */


@@ -195,16 +196,16 @@ find_last_line_symbol (CORE_ADDR start, CORE_ADDR end, int notcurrent)
    Returns the address of the first instruction after the prologue.  */
 
 static CORE_ADDR
    Returns the address of the first instruction after the prologue.  */
 
 static CORE_ADDR

-iq2000_scan_prologue (CORE_ADDR scan_start,
+iq2000_scan_prologue (struct gdbarch *gdbarch,
+                     CORE_ADDR scan_start,

                      CORE_ADDR scan_end,
                      struct frame_info *fi,
                      struct iq2000_frame_cache *cache)
 {
                      CORE_ADDR scan_end,
                      struct frame_info *fi,
                      struct iq2000_frame_cache *cache)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (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;


@@ -219,6 +220,8 @@ iq2000_scan_prologue (CORE_ADDR scan_start,
       loop_end = scan_end;
       if (fi)
        sal = find_last_line_symbol (scan_start, scan_end, 0);
       loop_end = scan_end;
       if (fi)
        sal = find_last_line_symbol (scan_start, scan_end, 0);

+      else
+       sal.end = 0;    /* Avoid GCC false warning.  */

     }
 
   /* Saved registers:
     }
 
   /* Saved registers:


@@ -226,7 +229,7 @@ iq2000_scan_prologue (CORE_ADDR scan_start,
      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;


@@ -234,9 +237,9 @@ iq2000_scan_prologue (CORE_ADDR scan_start,
 
   for (pc = scan_start; pc < loop_end; pc += 4)
     {
 
   for (pc = scan_start; pc < loop_end; pc += 4)
     {

-      LONGEST insn = read_memory_unsigned_integer (pc, 4);
+      LONGEST insn = read_memory_unsigned_integer (pc, 4, byte_order);

       /* Skip any instructions writing to (sp) or decrementing the
       /* 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.  */


@@ -245,16 +248,13 @@ iq2000_scan_prologue (CORE_ADDR scan_start,
          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;
        }


@@ -277,7 +277,7 @@ iq2000_scan_prologue (CORE_ADDR scan_start,
 
          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;


@@ -351,7 +351,7 @@ iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 
       /* No useable line symbol.  Use prologue parsing method.  */
       iq2000_init_frame_cache (&cache);
 
       /* No useable line symbol.  Use prologue parsing method.  */
       iq2000_init_frame_cache (&cache);

-      return iq2000_scan_prologue (func_addr, func_end, NULL, &cache);
+      return iq2000_scan_prologue (gdbarch, func_addr, func_end, NULL, &cache);

     }
 
   /* No function symbol -- just return the PC.  */
     }
 
   /* No function symbol -- just return the PC.  */


@@ -361,25 +361,24 @@ iq2000_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 static struct iq2000_frame_cache *
 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
 {
 static struct iq2000_frame_cache *
 iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
 {

+  struct gdbarch *gdbarch = get_frame_arch (this_frame);

   struct iq2000_frame_cache *cache;
   CORE_ADDR current_pc;
   int i;
 
   if (*this_cache)
   struct iq2000_frame_cache *cache;
   CORE_ADDR current_pc;
   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);
   if (cache->pc != 0)
 
   current_pc = get_frame_pc (this_frame);
   find_pc_partial_function (current_pc, NULL, &cache->pc, NULL);
   if (cache->pc != 0)

-    iq2000_scan_prologue (cache->pc, current_pc, this_frame, cache);
+    iq2000_scan_prologue (gdbarch, cache->pc, current_pc, this_frame, cache);

   if (!cache->using_fp)
     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 
   if (!cache->using_fp)
     cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 


@@ -396,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);


@@ -415,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) 


@@ -426,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,


@@ -454,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;
 }


@@ -466,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;
 }


@@ -497,12 +505,12 @@ 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);
       memcpy (buf + 4 - size, valbuf, size);
       int size = len % 4 ?: 4;
 
       memset (buf, 0, 4);
       memcpy (buf + 4 - size, valbuf, size);

-      regcache_raw_write (regcache, regno++, buf);
+      regcache->raw_write (regno++, buf);

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


@@ -529,8 +537,11 @@ 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 = regcache->arch ();
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+

   /* If the function's return value is 8 bytes or less, it is
      returned in a register, and if larger than 8 bytes, it is 
      returned in a stack location which is pointed to by the same
   /* If the function's return value is 8 bytes or less, it is
      returned in a register, and if larger than 8 bytes, it is 
      returned in a stack location which is pointed to by the same


@@ -551,9 +562,9 @@ iq2000_extract_return_value (struct type *type, struct regcache *regcache,
          /* By using store_unsigned_integer we avoid having to
             do anything special for small big-endian values.  */
          regcache_cooked_read_unsigned (regcache, regno++, &tmp);
          /* By using store_unsigned_integer we avoid having to
             do anything special for small big-endian values.  */
          regcache_cooked_read_unsigned (regcache, regno++, &tmp);

-         store_unsigned_integer (valbuf, size, tmp);
+         store_unsigned_integer (valbuf, size, byte_order, tmp);

          len -= size;
          len -= size;

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

        }
     }
   else
        }
     }
   else


@@ -568,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)
 {


@@ -598,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)
 {


@@ -626,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;
 }
 


@@ -634,18 +645,22 @@ static CORE_ADDR
 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                        struct regcache *regcache, CORE_ADDR bp_addr,
                        int nargs, struct value **args, CORE_ADDR sp,
 iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
                        struct regcache *regcache, CORE_ADDR bp_addr,
                        int nargs, struct value **args, CORE_ADDR sp,

-                       int struct_return, CORE_ADDR struct_addr)
+                       function_call_return_method return_method,
+                       CORE_ADDR struct_addr)

 {
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

   const bfd_byte *val;
   bfd_byte buf[4];
   struct type *type;
   int i, argreg, typelen, slacklen;
   int stackspace = 0;
   const bfd_byte *val;
   bfd_byte buf[4];
   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. */
-  for (i = 0, argreg = E_1ST_ARGREG + (struct_return != 0); i < nargs; i++)
+  /* First determine how much stack space we will need.  */
+  for (i = 0, argreg = E_1ST_ARGREG + (return_method == return_method_struct);
+       i < nargs;
+       i++)

     {
       type = value_type (args[i]);
       typelen = TYPE_LENGTH (type);
     {
       type = value_type (args[i]);
       typelen = TYPE_LENGTH (type);


@@ -663,19 +678,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;
             }


@@ -684,7 +699,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


@@ -695,7 +710,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;


@@ -704,9 +719,9 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
   stackspace = 0;
 
   argreg = E_1ST_ARGREG;
   stackspace = 0;
 
   argreg = E_1ST_ARGREG;

-  if (struct_return)
+  if (return_method == return_method_struct)

     {
     {

-      /* 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);
     }


@@ -718,18 +733,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. */
-             regcache_raw_write (regcache, argreg++, buf);
+              /* Passed in a register.  */
+             regcache->raw_write (argreg++, buf);

             }
           else
             {
             }
           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;
             }


@@ -737,20 +752,20 @@ 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++;
               if (((argreg - E_1ST_ARGREG) % 2) != 0)
                 argreg++;

-             regcache_raw_write (regcache, argreg++, val);
-             regcache_raw_write (regcache, argreg++, val + 4);
+             regcache->raw_write (argreg++, val);
+             regcache->raw_write (argreg++, val + 4);

             }
           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;


@@ -767,20 +782,20 @@ iq2000_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
            regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
          else
            {
            regcache_cooked_write_unsigned (regcache, argreg++, struct_ptr);
          else
            {

-             store_unsigned_integer (buf, 4, struct_ptr);
+             store_unsigned_integer (buf, 4, byte_order, struct_ptr);

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

-  /* 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;
 }
 


@@ -819,11 +834,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);


@@ -842,10 +859,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. */
-
-/* Provide a prototype to silence -Wmissing-prototypes.  */
-extern initialize_file_ftype _initialize_iq2000_tdep;
+   Called by gdb at start-up.  */

 
 void
 _initialize_iq2000_tdep (void)
 
 void
 _initialize_iq2000_tdep (void)