add "this" pointers to more target APIs

[binutils-gdb.git] / gdb / remote-m32r-sdi.c

diff --git a/gdb/remote-m32r-sdi.c b/gdb/remote-m32r-sdi.c
index 7aedd3d8da6588fdff3e5281f9d694774c366f65..48c4b4bd27d9af3abca9d731f78a7451d40bf561 100644 (file)
--- a/gdb/remote-m32r-sdi.c
+++ b/gdb/remote-m32r-sdi.c
@@ -1,7 +1,6 @@
 /* Remote debugging interface for M32R/SDI.
 
 /* Remote debugging interface for M32R/SDI.
 

-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
-   Free Software Foundation, Inc.
+   Copyright (C) 2003-2014 Free Software Foundation, Inc.

 
    Contributed by Renesas Technology Co.
    Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
 
    Contributed by Renesas Technology Co.
    Written by Kei Sakamoto <sakamoto.kei@renesas.com>.


@@ -27,20 +26,20 @@
 #include "inferior.h"
 #include "target.h"
 #include "regcache.h"
 #include "inferior.h"
 #include "target.h"
 #include "regcache.h"

-#include "gdb_string.h"
+#include <string.h>

 #include "gdbthread.h"
 #include <ctype.h>
 #include <signal.h>
 #ifdef __MINGW32__
 #include "gdbthread.h"
 #include <ctype.h>
 #include <signal.h>
 #ifdef __MINGW32__

-#include <winsock.h>
+#include <winsock2.h>

 #else
 #include <netinet/in.h>
 #endif
 #include <sys/types.h>
 #include <sys/time.h>
 #else
 #include <netinet/in.h>
 #endif
 #include <sys/types.h>
 #include <sys/time.h>

-#include <signal.h>

 #include <time.h>
 #include <time.h>

-
+#include "gdb_bfd.h"
+#include "cli/cli-utils.h"

 
 #include "serial.h"
 
 
 #include "serial.h"
 


@@ -156,9 +155,9 @@ static ptid_t remote_m32r_ptid;
 #define SDI_REG_ACC1L           35
 
 
 #define SDI_REG_ACC1L           35
 
 

-/* Low level communication functions */
+/* Low level communication functions.  */

 
 

-/* Check an ack packet from the target */
+/* Check an ack packet from the target.  */

 static int
 get_ack (void)
 {
 static int
 get_ack (void)
 {


@@ -178,12 +177,10 @@ get_ack (void)
   return 0;
 }
 
   return 0;
 }
 

-/* Send data to the target and check an ack packet */
+/* Send data to the target and check an ack packet.  */

 static int
 send_data (void *buf, int len)
 {
 static int
 send_data (void *buf, int len)
 {

-  int ret;
-

   if (!sdi_desc)
     return -1;
 
   if (!sdi_desc)
     return -1;
 


@@ -196,7 +193,7 @@ send_data (void *buf, int len)
   return len;
 }
 
   return len;
 }
 

-/* Receive data from the target */
+/* Receive data from the target.  */

 static int
 recv_data (void *buf, int len)
 {
 static int
 recv_data (void *buf, int len)
 {


@@ -219,7 +216,7 @@ recv_data (void *buf, int len)
   return len;
 }
 
   return len;
 }
 

-/* Store unsigned long parameter on packet */
+/* Store unsigned long parameter on packet.  */

 static void
 store_long_parameter (void *buf, long val)
 {
 static void
 store_long_parameter (void *buf, long val)
 {


@@ -231,6 +228,7 @@ static int
 send_cmd (unsigned char cmd)
 {
   unsigned char buf[1];
 send_cmd (unsigned char cmd)
 {
   unsigned char buf[1];

+

   buf[0] = cmd;
   return send_data (buf, 1);
 }
   buf[0] = cmd;
   return send_data (buf, 1);
 }


@@ -239,6 +237,7 @@ static int
 send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
 {
   unsigned char buf[2];
 send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
 {
   unsigned char buf[2];

+

   buf[0] = cmd;
   buf[1] = arg1;
   return send_data (buf, 2);
   buf[0] = cmd;
   buf[1] = arg1;
   return send_data (buf, 2);


@@ -248,6 +247,7 @@ static int
 send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
 {
   unsigned char buf[6];
 send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
 {
   unsigned char buf[6];

+

   buf[0] = cmd;
   buf[1] = arg1;
   store_long_parameter (buf + 2, arg2);
   buf[0] = cmd;
   buf[1] = arg1;
   store_long_parameter (buf + 2, arg2);


@@ -259,6 +259,7 @@ send_three_arg_cmd (unsigned char cmd, unsigned long arg1, unsigned long arg2,
                    unsigned long arg3)
 {
   unsigned char buf[13];
                    unsigned long arg3)
 {
   unsigned char buf[13];

+

   buf[0] = cmd;
   store_long_parameter (buf + 1, arg1);
   store_long_parameter (buf + 5, arg2);
   buf[0] = cmd;
   store_long_parameter (buf + 1, arg1);
   store_long_parameter (buf + 5, arg2);


@@ -270,6 +271,7 @@ static unsigned char
 recv_char_data (void)
 {
   unsigned char val;
 recv_char_data (void)
 {
   unsigned char val;

+

   recv_data (&val, 1);
   return val;
 }
   recv_data (&val, 1);
   return val;
 }


@@ -278,18 +280,19 @@ static unsigned long
 recv_long_data (void)
 {
   unsigned long val;
 recv_long_data (void)
 {
   unsigned long val;

+

   recv_data (&val, 4);
   return ntohl (val);
 }
 
 
   recv_data (&val, 4);
   return ntohl (val);
 }
 
 

-/* Check if MMU is on */
+/* Check if MMU is on.  */

 static void
 check_mmu_status (void)
 {
   unsigned long val;
 
 static void
 check_mmu_status (void)
 {
   unsigned long val;
 

-  /* Read PC address */
+  /* Read PC address.  */

   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
     return;
   val = recv_long_data ();
   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
     return;
   val = recv_long_data ();


@@ -299,7 +302,7 @@ check_mmu_status (void)
       return;
     }
 
       return;
     }
 

-  /* Read EVB address */
+  /* Read EVB address.  */

   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
     return;
   val = recv_long_data ();
   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
     return;
   val = recv_long_data ();


@@ -372,14 +375,14 @@ m32r_open (char *args, int from_tty)
   push_target (&m32r_ops);
 
   if (args == NULL)
   push_target (&m32r_ops);
 
   if (args == NULL)

-    sprintf (hostname, "localhost:%d", SDIPORT);
+    xsnprintf (hostname, sizeof (hostname), "localhost:%d", SDIPORT);

   else
     {
       port_str = strchr (args, ':');
       if (port_str == NULL)
   else
     {
       port_str = strchr (args, ':');
       if (port_str == NULL)

-       sprintf (hostname, "%s:%d", args, SDIPORT);
+       xsnprintf (hostname, sizeof (hostname), "%s:%d", args, SDIPORT);

       else
       else

-       strcpy (hostname, args);
+       xsnprintf (hostname, sizeof (hostname), "%s", args);

     }
 
   sdi_desc = serial_open (hostname);
     }
 
   sdi_desc = serial_open (hostname);


@@ -392,29 +395,29 @@ m32r_open (char *args, int from_tty)
   if (send_cmd (SDI_OPEN) == -1)
     error (_("Cannot connect to SDI target."));
 
   if (send_cmd (SDI_OPEN) == -1)
     error (_("Cannot connect to SDI target."));
 

-  /* Get maximum number of ib breakpoints */
+  /* Get maximum number of ib breakpoints.  */

   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
   max_ib_breakpoints = recv_char_data ();
   if (remote_debug)
     printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
 
   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
   max_ib_breakpoints = recv_char_data ();
   if (remote_debug)
     printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
 

-  /* Initialize breakpoints. */
+  /* Initialize breakpoints.  */

   for (i = 0; i < MAX_BREAKPOINTS; i++)
     bp_address[i] = 0xffffffff;
 
   for (i = 0; i < MAX_BREAKPOINTS; i++)
     bp_address[i] = 0xffffffff;
 

-  /* Get maximum number of access breaks. */
+  /* Get maximum number of access breaks.  */

   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
   max_access_breaks = recv_char_data ();
   if (remote_debug)
     printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
 
   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
   max_access_breaks = recv_char_data ();
   if (remote_debug)
     printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
 

-  /* Initialize access breask. */
+  /* Initialize access breask.  */

   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     ab_address[i] = 0x00000000;
 
   check_mmu_status ();
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     ab_address[i] = 0x00000000;
 
   check_mmu_status ();
 

-  /* Get the name of chip on target board. */
+  /* Get the name of chip on target board.  */

   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
   recv_data (chip_name, 64);
 
   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
   recv_data (chip_name, 64);
 


@@ -423,13 +426,13 @@ m32r_open (char *args, int from_tty)
                     chip_name);
 }
 
                     chip_name);
 }
 

-/* Close out all files and local state before this target loses control. */
+/* Close out all files and local state before this target loses control.  */

 
 static void
 
 static void

-m32r_close (int quitting)
+m32r_close (void)

 {
   if (remote_debug)
 {
   if (remote_debug)

-    fprintf_unfiltered (gdb_stdlog, "m32r_close(%d)\n", quitting);
+    fprintf_unfiltered (gdb_stdlog, "m32r_close()\n");

 
   if (sdi_desc)
     {
 
   if (sdi_desc)
     {


@@ -447,7 +450,7 @@ m32r_close (int quitting)
 
 static void
 m32r_resume (struct target_ops *ops,
 
 static void
 m32r_resume (struct target_ops *ops,

-            ptid_t ptid, int step, enum target_signal sig)
+            ptid_t ptid, int step, enum gdb_signal sig)

 {
   unsigned long pc_addr, bp_addr, ab_addr;
   int ib_breakpoints;
 {
   unsigned long pc_addr, bp_addr, ab_addr;
   int ib_breakpoints;


@@ -469,21 +472,21 @@ m32r_resume (struct target_ops *ops,
     fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
 
   /* At pc address there is a parallel instruction with +2 offset,
     fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
 
   /* At pc address there is a parallel instruction with +2 offset,

-     so we have to make it a serial instruction or avoid it. */
+     so we have to make it a serial instruction or avoid it.  */

   if (pc_addr == last_pc_addr)
     {
   if (pc_addr == last_pc_addr)
     {

-      /* Avoid a parallel nop. */
+      /* Avoid a parallel nop.  */

       if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
        {
          pc_addr += 2;
       if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
        {
          pc_addr += 2;

-         /* Now we can forget this instruction. */
+         /* Now we can forget this instruction.  */

          last_pc_addr = 0xffffffff;
        }
          last_pc_addr = 0xffffffff;
        }

-      /* Clear a parallel bit. */
+      /* Clear a parallel bit.  */

       else
        {
          buf[0] = SDI_WRITE_MEMORY;
       else
        {
          buf[0] = SDI_WRITE_MEMORY;

-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

            store_long_parameter (buf + 1, pc_addr);
          else
            store_long_parameter (buf + 1, pc_addr - 1);
            store_long_parameter (buf + 1, pc_addr);
          else
            store_long_parameter (buf + 1, pc_addr - 1);


@@ -493,19 +496,19 @@ m32r_resume (struct target_ops *ops,
        }
     }
 
        }
     }
 

-  /* Set PC. */
+  /* Set PC.  */

   send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 
   send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 

-  /* step mode. */
+  /* step mode.  */

   step_mode = step;
   if (step)
     {
   step_mode = step;
   if (step)
     {

-      /* Set PBP. */
+      /* Set PBP.  */

       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
     }
   else
     {
       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
     }
   else
     {

-      /* Unset PBP. */
+      /* Unset PBP.  */

       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
     }
 
       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
     }
 


@@ -514,7 +517,7 @@ m32r_resume (struct target_ops *ops,
   else
     ib_breakpoints = 0;
 
   else
     ib_breakpoints = 0;
 

-  /* Set ib breakpoints. */
+  /* Set ib breakpoints.  */

   for (i = 0; i < ib_breakpoints; i++)
     {
       bp_addr = bp_address[i];
   for (i = 0; i < ib_breakpoints; i++)
     {
       bp_addr = bp_address[i];


@@ -522,8 +525,8 @@ m32r_resume (struct target_ops *ops,
       if (bp_addr == 0xffffffff)
        continue;
 
       if (bp_addr == 0xffffffff)
        continue;
 

-      /* Set PBP. */
-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      /* Set PBP.  */
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
                            0x00000006);
       else
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
                            0x00000006);
       else


@@ -533,7 +536,7 @@ m32r_resume (struct target_ops *ops,
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
     }
 
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
     }
 

-  /* Set dbt breakpoints. */
+  /* Set dbt breakpoints.  */

   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
     {
       bp_addr = bp_address[i];
   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
     {
       bp_addr = bp_address[i];


@@ -544,13 +547,13 @@ m32r_resume (struct target_ops *ops,
       if (!mmu_on)
        bp_addr &= 0x7fffffff;
 
       if (!mmu_on)
        bp_addr &= 0x7fffffff;
 

-      /* Write DBT instruction. */
+      /* Write DBT instruction.  */

       buf[0] = SDI_WRITE_MEMORY;
       store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
       store_long_parameter (buf + 5, 4);
       if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
        {
       buf[0] = SDI_WRITE_MEMORY;
       store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
       store_long_parameter (buf + 5, 4);
       if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
        {

-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

            {
              buf[9] = dbt_bp_entry[0];
              buf[10] = dbt_bp_entry[1];
            {
              buf[9] = dbt_bp_entry[0];
              buf[10] = dbt_bp_entry[1];


@@ -567,7 +570,7 @@ m32r_resume (struct target_ops *ops,
        }
       else
        {
        }
       else
        {

-         if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+         if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

            {
              if ((bp_addr & 2) == 0)
                {
            {
              if ((bp_addr & 2) == 0)
                {


@@ -605,7 +608,7 @@ m32r_resume (struct target_ops *ops,
       send_data (buf, 13);
     }
 
       send_data (buf, 13);
     }
 

-  /* Set access breaks. */
+  /* Set access breaks.  */

   for (i = 0; i < max_access_breaks; i++)
     {
       ab_addr = ab_address[i];
   for (i = 0; i < max_access_breaks; i++)
     {
       ab_addr = ab_address[i];


@@ -613,8 +616,8 @@ m32r_resume (struct target_ops *ops,
       if (ab_addr == 0x00000000)
        continue;
 
       if (ab_addr == 0x00000000)
        continue;
 

-      /* DBC register */
-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      /* DBC register.  */
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

        {
          switch (ab_type[i])
            {
        {
          switch (ab_type[i])
            {


@@ -651,23 +654,23 @@ m32r_resume (struct target_ops *ops,
            }
        }
 
            }
        }
 

-      /* DBAH register */
+      /* DBAH register.  */

       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
 
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
 

-      /* DBAL register */
+      /* DBAL register.  */

       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
                          0xffffffff);
 
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
                          0xffffffff);
 

-      /* DBD register */
+      /* DBD register.  */

       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
                          0x00000000);
 
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
                          0x00000000);
 

-      /* DBDM register */
+      /* DBDM register.  */

       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
                          0x00000000);
     }
 
       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
                          0x00000000);
     }
 

-  /* Resume program. */
+  /* Resume program.  */

   send_cmd (SDI_EXEC_CPU);
 
   /* Without this, some commands which require an active target (such as kill)
   send_cmd (SDI_EXEC_CPU);
 
   /* Without this, some commands which require an active target (such as kill)


@@ -695,26 +698,25 @@ gdb_cntrl_c (int signo)
 
 static ptid_t
 m32r_wait (struct target_ops *ops,
 
 static ptid_t
 m32r_wait (struct target_ops *ops,

-          ptid_t ptid, struct target_waitstatus *status)
+          ptid_t ptid, struct target_waitstatus *status, int options)

 {
   static RETSIGTYPE (*prev_sigint) ();
   unsigned long bp_addr, pc_addr;
   int ib_breakpoints;
   long i;
   unsigned char buf[13];
 {
   static RETSIGTYPE (*prev_sigint) ();
   unsigned long bp_addr, pc_addr;
   int ib_breakpoints;
   long i;
   unsigned char buf[13];

-  unsigned long val;

   int ret, c;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
 
   status->kind = TARGET_WAITKIND_EXITED;
   int ret, c;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
 
   status->kind = TARGET_WAITKIND_EXITED;

-  status->value.sig = 0;
+  status->value.sig = GDB_SIGNAL_0;

 
   interrupted = 0;
   prev_sigint = signal (SIGINT, gdb_cntrl_c);
 
 
   interrupted = 0;
   prev_sigint = signal (SIGINT, gdb_cntrl_c);
 

-  /* Wait for ready */
+  /* Wait for ready.  */

   buf[0] = SDI_WAIT_FOR_READY;
   if (serial_write (sdi_desc, buf, 1) != 0)
     error (_("Remote connection closed"));
   buf[0] = SDI_WAIT_FOR_READY;
   if (serial_write (sdi_desc, buf, 1) != 0)
     error (_("Remote connection closed"));


@@ -728,7 +730,7 @@ m32r_wait (struct target_ops *ops,
       if (c == '-')            /* error */
        {
          status->kind = TARGET_WAITKIND_STOPPED;
       if (c == '-')            /* error */
        {
          status->kind = TARGET_WAITKIND_STOPPED;

-         status->value.sig = TARGET_SIGNAL_HUP;
+         status->value.sig = GDB_SIGNAL_HUP;

          return inferior_ptid;
        }
       else if (c == '+')       /* stopped */
          return inferior_ptid;
        }
       else if (c == '+')       /* stopped */


@@ -744,20 +746,20 @@ m32r_wait (struct target_ops *ops,
 
   status->kind = TARGET_WAITKIND_STOPPED;
   if (interrupted)
 
   status->kind = TARGET_WAITKIND_STOPPED;
   if (interrupted)

-    status->value.sig = TARGET_SIGNAL_INT;
+    status->value.sig = GDB_SIGNAL_INT;

   else
   else

-    status->value.sig = TARGET_SIGNAL_TRAP;
+    status->value.sig = GDB_SIGNAL_TRAP;

 
   interrupted = 0;
   signal (SIGINT, prev_sigint);
 
   check_mmu_status ();
 
 
   interrupted = 0;
   signal (SIGINT, prev_sigint);
 
   check_mmu_status ();
 

-  /* Recover parallel bit. */
+  /* Recover parallel bit.  */

   if (last_pc_addr != 0xffffffff)
     {
       buf[0] = SDI_WRITE_MEMORY;
   if (last_pc_addr != 0xffffffff)
     {
       buf[0] = SDI_WRITE_MEMORY;

-      if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+      if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

        store_long_parameter (buf + 1, last_pc_addr);
       else
        store_long_parameter (buf + 1, last_pc_addr - 1);
        store_long_parameter (buf + 1, last_pc_addr);
       else
        store_long_parameter (buf + 1, last_pc_addr - 1);


@@ -772,7 +774,7 @@ m32r_wait (struct target_ops *ops,
   else
     ib_breakpoints = 0;
 
   else
     ib_breakpoints = 0;
 

-  /* Set back pc by 2 if m32r is stopped with dbt. */
+  /* Set back pc by 2 if m32r is stopped with dbt.  */

   last_pc_addr = 0xffffffff;
   send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
   pc_addr = recv_long_data () - 2;
   last_pc_addr = 0xffffffff;
   send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
   pc_addr = recv_long_data () - 2;


@@ -783,10 +785,10 @@ m32r_wait (struct target_ops *ops,
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 
          /* If there is a parallel instruction with +2 offset at pc
          send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 
          /* If there is a parallel instruction with +2 offset at pc

-            address, we have to take care of it later. */
+            address, we have to take care of it later.  */

          if ((pc_addr & 0x2) != 0)
            {
          if ((pc_addr & 0x2) != 0)
            {

-             if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

                {
                  if ((bp_data[i][2] & 0x80) != 0)
                    {
                {
                  if ((bp_data[i][2] & 0x80) != 0)
                    {


@@ -809,14 +811,14 @@ m32r_wait (struct target_ops *ops,
        }
     }
 
        }
     }
 

-  /* Remove ib breakpoints. */
+  /* Remove ib breakpoints.  */

   for (i = 0; i < ib_breakpoints; i++)
     {
       if (bp_address[i] != 0xffffffff)
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
                            0x00000000);
     }
   for (i = 0; i < ib_breakpoints; i++)
     {
       if (bp_address[i] != 0xffffffff)
        send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
                            0x00000000);
     }

-  /* Remove dbt breakpoints. */
+  /* Remove dbt breakpoints.  */

   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
     {
       bp_addr = bp_address[i];
   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
     {
       bp_addr = bp_address[i];


@@ -835,7 +837,7 @@ m32r_wait (struct target_ops *ops,
        }
     }
 
        }
     }
 

-  /* Remove access breaks. */
+  /* Remove access breaks.  */

   hit_watchpoint_addr = 0;
   for (i = 0; i < max_access_breaks; i++)
     {
   hit_watchpoint_addr = 0;
   for (i = 0; i < max_access_breaks; i++)
     {


@@ -848,7 +850,7 @@ m32r_wait (struct target_ops *ops,
          c = serial_readchar (sdi_desc, SDI_TIMEOUT);
          if (c != '-' && recv_data (buf, 4) != -1)
            {
          c = serial_readchar (sdi_desc, SDI_TIMEOUT);
          if (c != '-' && recv_data (buf, 4) != -1)
            {

-             if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
+             if (gdbarch_byte_order (target_gdbarch ()) == BFD_ENDIAN_BIG)

                {
                  if ((buf[3] & 0x1) == 0x1)
                    hit_watchpoint_addr = ab_address[i];
                {
                  if ((buf[3] & 0x1) == 0x1)
                    hit_watchpoint_addr = ab_address[i];


@@ -875,21 +877,21 @@ m32r_wait (struct target_ops *ops,
    Use this when you want to detach and do something else
    with your gdb.  */
 static void
    Use this when you want to detach and do something else
    with your gdb.  */
 static void

-m32r_detach (struct target_ops *ops, char *args, int from_tty)
+m32r_detach (struct target_ops *ops, const char *args, int from_tty)

 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
 
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
 

-  m32r_resume (ops, inferior_ptid, 0, 0);
+  m32r_resume (ops, inferior_ptid, 0, GDB_SIGNAL_0);

 
 

-  /* calls m32r_close to do the real work */
-  pop_target ();
+  /* Calls m32r_close to do the real work.  */
+  unpush_target (ops);

   if (from_tty)
     fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
                        target_shortname);
 }
 
   if (from_tty)
     fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
                        target_shortname);
 }
 

-/* Return the id of register number REGNO. */
+/* Return the id of register number REGNO.  */

 
 static int
 get_reg_id (int regno)
 
 static int
 get_reg_id (int regno)


@@ -917,6 +919,8 @@ static void
 m32r_fetch_register (struct target_ops *ops,
                     struct regcache *regcache, int regno)
 {
 m32r_fetch_register (struct target_ops *ops,
                     struct regcache *regcache, int regno)
 {

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

   unsigned long val, val2, regid;
 
   if (regno == -1)
   unsigned long val, val2, regid;
 
   if (regno == -1)


@@ -928,7 +932,7 @@ m32r_fetch_register (struct target_ops *ops,
     }
   else
     {
     }
   else
     {

-      char buffer[MAX_REGISTER_SIZE];
+      gdb_byte buffer[MAX_REGISTER_SIZE];

 
       regid = get_reg_id (regno);
       send_one_arg_cmd (SDI_READ_CPU_REG, regid);
 
       regid = get_reg_id (regno);
       send_one_arg_cmd (SDI_READ_CPU_REG, regid);


@@ -947,7 +951,7 @@ m32r_fetch_register (struct target_ops *ops,
 
       /* We got the number the register holds, but gdb expects to see a
          value in the target byte ordering.  */
 
       /* We got the number the register holds, but gdb expects to see a
          value in the target byte ordering.  */

-      store_unsigned_integer (buffer, 4, val);
+      store_unsigned_integer (buffer, 4, byte_order, val);

       regcache_raw_supply (regcache, regno, buffer);
     }
   return;
       regcache_raw_supply (regcache, regno, buffer);
     }
   return;


@@ -1008,9 +1012,9 @@ m32r_store_register (struct target_ops *ops,
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-m32r_prepare_to_store (struct regcache *regcache)
+m32r_prepare_to_store (struct target_ops *self, struct regcache *regcache)

 {
 {

-  /* Do nothing, since we can store individual regs */
+  /* Do nothing, since we can store individual regs.  */

   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
 }
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
 }


@@ -1018,7 +1022,7 @@ m32r_prepare_to_store (struct regcache *regcache)
 static void
 m32r_files_info (struct target_ops *target)
 {
 static void
 m32r_files_info (struct target_ops *target)
 {

-  char *file = "nothing";
+  const char *file = "nothing";

 
   if (exec_bfd)
     {
 
   if (exec_bfd)
     {


@@ -1050,10 +1054,10 @@ m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
     {
       if (write)
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
     {
       if (write)
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",

-                           paddr (memaddr), len);
+                           paddress (target_gdbarch (), memaddr), len);

       else
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
       else
        fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",

-                           paddr (memaddr), len);
+                           paddress (target_gdbarch (), memaddr), len);

     }
 
   if (write)
     }
 
   if (write)


@@ -1140,7 +1144,9 @@ m32r_mourn_inferior (struct target_ops *ops)
 }
 
 static int
 }
 
 static int

-m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
+m32r_insert_breakpoint (struct target_ops *ops,
+                       struct gdbarch *gdbarch,
+                       struct bp_target_info *bp_tgt)

 {
   CORE_ADDR addr = bp_tgt->placed_address;
   int ib_breakpoints;
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   int ib_breakpoints;


@@ -1149,7 +1155,7 @@ m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",

-                       paddr (addr));
+                       paddress (gdbarch, addr));

 
   if (use_ib_breakpoints)
     ib_breakpoints = max_ib_breakpoints;
 
   if (use_ib_breakpoints)
     ib_breakpoints = max_ib_breakpoints;


@@ -1183,14 +1189,16 @@ m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
 }
 
 static int
 }
 
 static int

-m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
+m32r_remove_breakpoint (struct target_ops *ops,
+                       struct gdbarch *gdbarch,
+                       struct bp_target_info *bp_tgt)

 {
   CORE_ADDR addr = bp_tgt->placed_address;
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
 {
   CORE_ADDR addr = bp_tgt->placed_address;
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",

-                       paddr (addr));
+                       paddress (gdbarch, addr));

 
   for (i = 0; i < MAX_BREAKPOINTS; i++)
     {
 
   for (i = 0; i < MAX_BREAKPOINTS; i++)
     {


@@ -1215,11 +1223,10 @@ m32r_load (char *args, int from_tty)
   int quiet;
   int nostart;
   struct timeval start_time, end_time;
   int quiet;
   int nostart;
   struct timeval start_time, end_time;

-  unsigned long data_count;    /* Number of bytes transferred to memory */
-  int ret;
+  unsigned long data_count;    /* Number of bytes transferred to memory.  */

   static RETSIGTYPE (*prev_sigint) ();
 
   static RETSIGTYPE (*prev_sigint) ();
 

-  /* for direct tcp connections, we can do a fast binary download */
+  /* for direct tcp connections, we can do a fast binary download.  */

   quiet = 0;
   nostart = 0;
   filename = NULL;
   quiet = 0;
   nostart = 0;
   filename = NULL;


@@ -1228,8 +1235,7 @@ m32r_load (char *args, int from_tty)
     {
       char *arg;
 
     {
       char *arg;
 

-      while (isspace (*args))
-       args++;
+      args = skip_spaces (args);

 
       arg = args;
 
 
       arg = args;
 


@@ -1252,13 +1258,13 @@ m32r_load (char *args, int from_tty)
   if (!filename)
     filename = get_exec_file (1);
 
   if (!filename)
     filename = get_exec_file (1);
 

-  pbfd = bfd_openr (filename, gnutarget);
+  pbfd = gdb_bfd_open (filename, gnutarget, -1);

   if (pbfd == NULL)
     {
       perror_with_name (filename);
       return;
     }
   if (pbfd == NULL)
     {
       perror_with_name (filename);
       return;
     }

-  old_chain = make_cleanup_bfd_close (pbfd);
+  old_chain = make_cleanup_bfd_unref (pbfd);

 
   if (!bfd_check_format (pbfd, bfd_object))
     error (_("\"%s\" is not an object file: %s"), filename,
 
   if (!bfd_check_format (pbfd, bfd_object))
     error (_("\"%s\" is not an object file: %s"), filename,


@@ -1353,21 +1359,21 @@ m32r_load (char *args, int from_tty)
 
   gettimeofday (&end_time, NULL);
 
 
   gettimeofday (&end_time, NULL);
 

-  /* Make the PC point at the start address */
+  /* Make the PC point at the start address.  */

   if (exec_bfd)
     regcache_write_pc (get_current_regcache (),
                       bfd_get_start_address (exec_bfd));
 
   if (exec_bfd)
     regcache_write_pc (get_current_regcache (),
                       bfd_get_start_address (exec_bfd));
 

-  inferior_ptid = null_ptid;   /* No process now */
+  inferior_ptid = null_ptid;   /* No process now.  */

   delete_thread_silent (remote_m32r_ptid);
 
   /* This is necessary because many things were based on the PC at the time
      that we attached to the monitor, which is no longer valid now that we
      have loaded new code (and just changed the PC).  Another way to do this
      might be to call normal_stop, except that the stack may not be valid,
   delete_thread_silent (remote_m32r_ptid);
 
   /* This is necessary because many things were based on the PC at the time
      that we attached to the monitor, which is no longer valid now that we
      have loaded new code (and just changed the PC).  Another way to do this
      might be to call normal_stop, except that the stack may not be valid,

-     and things would get horribly confused... */
+     and things would get horribly confused...  */

 
 

-  clear_symtab_users ();
+  clear_symtab_users (0);

 
   if (!nostart)
     {
 
   if (!nostart)
     {


@@ -1408,16 +1414,17 @@ m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
 
 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
 
 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write

-   watchpoint. */
+   watchpoint.  */

 
 static int
 
 static int

-m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
+m32r_insert_watchpoint (CORE_ADDR addr, int len, int type,
+                       struct expression *cond)

 {
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
 {
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",

-                       paddr (addr), len, type);
+                       paddress (target_gdbarch (), addr), len, type);

 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {


@@ -1435,13 +1442,14 @@ m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
 }
 
 static int
 }
 
 static int

-m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
+m32r_remove_watchpoint (CORE_ADDR addr, int len, int type,
+                       struct expression *cond)

 {
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
 {
   int i;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",

-                       paddr (addr), len, type);
+                       paddress (target_gdbarch (), addr), len, type);

 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     {


@@ -1459,6 +1467,7 @@ static int
 m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {
   int rc = 0;
 m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 {
   int rc = 0;

+

   if (hit_watchpoint_addr != 0x00000000)
     {
       *addr_p = hit_watchpoint_addr;
   if (hit_watchpoint_addr != 0x00000000)
     {
       *addr_p = hit_watchpoint_addr;


@@ -1468,9 +1477,10 @@ m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
 }
 
 static int
 }
 
 static int

-m32r_stopped_by_watchpoint (void)
+m32r_stopped_by_watchpoint (struct target_ops *ops)

 {
   CORE_ADDR addr;
 {
   CORE_ADDR addr;

+

   return m32r_stopped_data_address (&current_target, &addr);
 }
 
   return m32r_stopped_data_address (&current_target, &addr);
 }
 


@@ -1590,8 +1600,21 @@ use_dbt_breakpoints_command (char *args, int from_tty)
   use_ib_breakpoints = 0;
 }
 
   use_ib_breakpoints = 0;
 }
 

+static int
+m32r_return_one (struct target_ops *target)
+{
+  return 1;
+}
+
+/* Implementation of the to_has_execution method.  */
+
+static int
+m32r_has_execution (struct target_ops *target, ptid_t the_ptid)
+{
+  return 1;
+}

 
 

-/* Define the target subroutine names */
+/* Define the target subroutine names.  */

 
 struct target_ops m32r_ops;
 
 
 struct target_ops m32r_ops;
 


@@ -1627,11 +1650,11 @@ init_m32r_ops (void)
   m32r_ops.to_thread_alive = m32r_thread_alive;
   m32r_ops.to_pid_to_str = m32r_pid_to_str;
   m32r_ops.to_stratum = process_stratum;
   m32r_ops.to_thread_alive = m32r_thread_alive;
   m32r_ops.to_pid_to_str = m32r_pid_to_str;
   m32r_ops.to_stratum = process_stratum;

-  m32r_ops.to_has_all_memory = 1;
-  m32r_ops.to_has_memory = 1;
-  m32r_ops.to_has_stack = 1;
-  m32r_ops.to_has_registers = 1;
-  m32r_ops.to_has_execution = 1;
+  m32r_ops.to_has_all_memory = m32r_return_one;
+  m32r_ops.to_has_memory = m32r_return_one;
+  m32r_ops.to_has_stack = m32r_return_one;
+  m32r_ops.to_has_registers = m32r_return_one;
+  m32r_ops.to_has_execution = m32r_has_execution;

   m32r_ops.to_magic = OPS_MAGIC;
 };
 
   m32r_ops.to_magic = OPS_MAGIC;
 };
 


@@ -1645,11 +1668,11 @@ _initialize_remote_m32r (void)
 
   init_m32r_ops ();
 
 
   init_m32r_ops ();
 

-  /* Initialize breakpoints. */
+  /* Initialize breakpoints.  */

   for (i = 0; i < MAX_BREAKPOINTS; i++)
     bp_address[i] = 0xffffffff;
 
   for (i = 0; i < MAX_BREAKPOINTS; i++)
     bp_address[i] = 0xffffffff;
 

-  /* Initialize access breaks. */
+  /* Initialize access breaks.  */

   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     ab_address[i] = 0x00000000;
 
   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
     ab_address[i] = 0x00000000;