* gdbint.texinfo (Target Architecture Definition): Remove

[deliverable/binutils-gdb.git] / gdb / monitor.c

diff --git a/gdb/monitor.c b/gdb/monitor.c
index 869a91e2928ebfd4c5bbf9bc9ca8fbb99a789b82..a3f6672f74a7f429c5e7222682f01cee7a3bea48 100644 (file)
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -1,5 +1,8 @@
 /* Remote debugging interface for boot monitors, for GDB.
 /* Remote debugging interface for boot monitors, for GDB.

-   Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
+
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+   1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+

    Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
    Resurrected from the ashes by Stu Grossman.
 
    Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
    Resurrected from the ashes by Stu Grossman.
 


@@ -23,7 +26,7 @@
 /* This file was derived from various remote-* modules. It is a collection
    of generic support functions so GDB can talk directly to a ROM based
    monitor. This saves use from having to hack an exception based handler
 /* This file was derived from various remote-* modules. It is a collection
    of generic support functions so GDB can talk directly to a ROM based
    monitor. This saves use from having to hack an exception based handler

-   into existance, and makes for quick porting.
+   into existence, and makes for quick porting.

 
    This module talks to a debug monitor called 'MONITOR', which
    We communicate with MONITOR via either a direct serial line, or a TCP
 
    This module talks to a debug monitor called 'MONITOR', which
    We communicate with MONITOR via either a direct serial line, or a TCP


@@ -40,7 +43,6 @@
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"

-#include "gdb_wait.h"

 #include <signal.h>
 #include <ctype.h>
 #include "gdb_string.h"
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_string.h"


@@ -51,8 +53,8 @@
 #include "gdbcmd.h"
 #include "inferior.h"
 #include "gdb_regex.h"
 #include "gdbcmd.h"
 #include "inferior.h"
 #include "gdb_regex.h"

-#include "dcache.h"

 #include "srec.h"
 #include "srec.h"

+#include "regcache.h"

 
 static char *dev_name;
 static struct target_ops *targ_ops;
 
 static char *dev_name;
 static struct target_ops *targ_ops;


@@ -67,18 +69,20 @@ static void monitor_store_register (int regno);
 static void monitor_printable_string (char *newstr, char *oldstr, int len);
 static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
 static void monitor_detach (char *args, int from_tty);
 static void monitor_printable_string (char *newstr, char *oldstr, int len);
 static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
 static void monitor_detach (char *args, int from_tty);

-static void monitor_resume (int pid, int step, enum target_signal sig);
+static void monitor_resume (ptid_t ptid, int step, enum target_signal sig);

 static void monitor_interrupt (int signo);
 static void monitor_interrupt_twice (int signo);
 static void monitor_interrupt_query (void);
 static void monitor_wait_cleanup (void *old_timeout);
 
 static void monitor_interrupt (int signo);
 static void monitor_interrupt_twice (int signo);
 static void monitor_interrupt_query (void);
 static void monitor_wait_cleanup (void *old_timeout);
 

-static int monitor_wait (int pid, struct target_waitstatus *status);
+static ptid_t monitor_wait (ptid_t ptid, struct target_waitstatus *status);

 static void monitor_fetch_registers (int regno);
 static void monitor_store_registers (int regno);
 static void monitor_prepare_to_store (void);
 static int monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
 static void monitor_fetch_registers (int regno);
 static void monitor_store_registers (int regno);
 static void monitor_prepare_to_store (void);
 static int monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,

-                               int write, struct target_ops *target);
+                               int write, 
+                               struct mem_attrib *attrib,
+                               struct target_ops *target);

 static void monitor_files_info (struct target_ops *ops);
 static int monitor_insert_breakpoint (CORE_ADDR addr, char *shadow);
 static int monitor_remove_breakpoint (CORE_ADDR addr, char *shadow);
 static void monitor_files_info (struct target_ops *ops);
 static int monitor_insert_breakpoint (CORE_ADDR addr, char *shadow);
 static int monitor_remove_breakpoint (CORE_ADDR addr, char *shadow);


@@ -117,7 +121,7 @@ static CORE_ADDR *breakaddr;
    that monitor_open knows that we don't have a file open when the
    program starts.  */
 
    that monitor_open knows that we don't have a file open when the
    program starts.  */
 

-static serial_t monitor_desc = NULL;
+static struct serial *monitor_desc = NULL;

 
 /* Pointer to regexp pattern matching data */
 
 
 /* Pointer to regexp pattern matching data */
 


@@ -127,10 +131,15 @@ static char register_fastmap[256];
 static struct re_pattern_buffer getmem_resp_delim_pattern;
 static char getmem_resp_delim_fastmap[256];
 
 static struct re_pattern_buffer getmem_resp_delim_pattern;
 static char getmem_resp_delim_fastmap[256];
 

+static struct re_pattern_buffer setmem_resp_delim_pattern;
+static char setmem_resp_delim_fastmap[256];
+
+static struct re_pattern_buffer setreg_resp_delim_pattern;
+static char setreg_resp_delim_fastmap[256];
+

 static int dump_reg_flag;      /* Non-zero means do a dump_registers cmd when
                                   monitor_wait wakes up.  */
 
 static int dump_reg_flag;      /* Non-zero means do a dump_registers cmd when
                                   monitor_wait wakes up.  */
 

-static DCACHE *remote_dcache;

 static int first_time = 0;     /* is this the first time we're executing after 
                                   gaving created the child proccess? */
 
 static int first_time = 0;     /* is this the first time we're executing after 
                                   gaving created the child proccess? */
 


@@ -336,7 +345,7 @@ monitor_printf_noecho (char *pattern,...)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)

-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


@@ -364,7 +373,7 @@ monitor_printf (char *pattern,...)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)

-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


@@ -389,8 +398,8 @@ monitor_printf (char *pattern,...)
 void
 monitor_write (char *buf, int buflen)
 {
 void
 monitor_write (char *buf, int buflen)
 {

-  if (SERIAL_WRITE (monitor_desc, buf, buflen))
-    fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
+  if (serial_write (monitor_desc, buf, buflen))
+    fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",

                        safe_strerror (errno));
 }
 
                        safe_strerror (errno));
 }
 


@@ -408,7 +417,7 @@ monitor_readchar (void)
   do
     {
       looping = 0;
   do
     {
       looping = 0;

-      c = SERIAL_READCHAR (monitor_desc, timeout);
+      c = serial_readchar (monitor_desc, timeout);

 
       if (c >= 0)
        c &= 0xff;              /* don't lose bit 7 */
 
       if (c >= 0)
        c &= 0xff;              /* don't lose bit 7 */


@@ -442,7 +451,7 @@ readchar (int timeout)
   do
     {
       looping = 0;
   do
     {
       looping = 0;

-      c = SERIAL_READCHAR (monitor_desc, timeout);
+      c = serial_readchar (monitor_desc, timeout);

 
       if (c >= 0)
        {
 
       if (c >= 0)
        {


@@ -512,7 +521,6 @@ monitor_expect (char *string, char *buf, int buflen)
   char *p = string;
   int obuflen = buflen;
   int c;
   char *p = string;
   int obuflen = buflen;
   int c;

-  extern struct target_ops *targ_ops;

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


@@ -560,12 +568,6 @@ monitor_expect (char *string, char *buf, int buflen)
                return 0;
            }
        }
                return 0;
            }
        }

-      else if ((c == '\021' || c == '\023') &&
-              (STREQ (targ_ops->to_shortname, "m32r")
-               || STREQ (targ_ops->to_shortname, "mon2000")))
-       {                       /* m32r monitor emits random DC1/DC3 chars */
-         continue;
-       }

       else
        {
          /* We got a character that doesn't match the string.  We need to
       else
        {
          /* We got a character that doesn't match the string.  We need to


@@ -751,33 +753,41 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
                     getmem_resp_delim_fastmap);
 
     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
                     getmem_resp_delim_fastmap);
 

+  if (mon_ops->setmem.resp_delim)
+    compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
+                     setmem_resp_delim_fastmap);
+
+  if (mon_ops->setreg.resp_delim)
+    compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
+                     setreg_resp_delim_fastmap);
+  

   unpush_target (targ_ops);
 
   if (dev_name)
   unpush_target (targ_ops);
 
   if (dev_name)

-    free (dev_name);
-  dev_name = strsave (args);
+    xfree (dev_name);
+  dev_name = xstrdup (args);

 
 

-  monitor_desc = SERIAL_OPEN (dev_name);
+  monitor_desc = serial_open (dev_name);

 
   if (!monitor_desc)
     perror_with_name (dev_name);
 
   if (baud_rate != -1)
     {
 
   if (!monitor_desc)
     perror_with_name (dev_name);
 
   if (baud_rate != -1)
     {

-      if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
+      if (serial_setbaudrate (monitor_desc, baud_rate))

        {
        {

-         SERIAL_CLOSE (monitor_desc);
+         serial_close (monitor_desc);

          perror_with_name (dev_name);
        }
     }
 
          perror_with_name (dev_name);
        }
     }
 

-  SERIAL_RAW (monitor_desc);
+  serial_raw (monitor_desc);

 
 

-  SERIAL_FLUSH_INPUT (monitor_desc);
+  serial_flush_input (monitor_desc);

 
   /* some systems only work with 2 stop bits */
 
 
   /* some systems only work with 2 stop bits */
 

-  SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
+  serial_setstopbits (monitor_desc, mon_ops->stopbits);

 
   current_monitor = mon_ops;
 
 
   current_monitor = mon_ops;
 


@@ -807,7 +817,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
       monitor_expect_prompt (NULL, 0);
     }
 
       monitor_expect_prompt (NULL, 0);
     }
 

-  SERIAL_FLUSH_INPUT (monitor_desc);
+  serial_flush_input (monitor_desc);

 
   /* Alloc breakpoints */
   if (mon_ops->set_break != NULL)
 
   /* Alloc breakpoints */
   if (mon_ops->set_break != NULL)


@@ -832,21 +842,12 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
 
   push_target (targ_ops);
 
 
   push_target (targ_ops);
 

-  inferior_pid = 42000;                /* Make run command think we are busy... */
+  inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */

 
   /* Give monitor_wait something to read */
 
   monitor_printf (current_monitor->line_term);
 
 
   /* Give monitor_wait something to read */
 
   monitor_printf (current_monitor->line_term);
 

-  if (remote_dcache)
-    dcache_free (remote_dcache);
-
-  if (current_monitor->flags & MO_HAS_BLOCKWRITES)
-    remote_dcache = dcache_init (monitor_read_memory, 
-                                monitor_write_memory_block);
-  else
-    remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
-

   start_remote ();
 }
 
   start_remote ();
 }
 


@@ -857,12 +858,12 @@ void
 monitor_close (int quitting)
 {
   if (monitor_desc)
 monitor_close (int quitting)
 {
   if (monitor_desc)

-    SERIAL_CLOSE (monitor_desc);
+    serial_close (monitor_desc);

 
   /* Free breakpoint memory */
   if (breakaddr != NULL)
     {
 
   /* Free breakpoint memory */
   if (breakaddr != NULL)
     {

-      free (breakaddr);
+      xfree (breakaddr);

       breakaddr = NULL;
     }
 
       breakaddr = NULL;
     }
 


@@ -886,7 +887,7 @@ char *
 monitor_supply_register (int regno, char *valstr)
 {
   ULONGEST val;
 monitor_supply_register (int regno, char *valstr)
 {
   ULONGEST val;

-  unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+  unsigned char regbuf[MAX_REGISTER_SIZE];

   char *p;
 
   val = 0;
   char *p;
 
   val = 0;


@@ -914,13 +915,13 @@ monitor_supply_register (int regno, char *valstr)
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 

-  if (*p != '\0')
+  if (val == 0 && valstr == p)

     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
           regno, valstr);
 
   /* supply register stores in target byte order, so swap here */
 
     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
           regno, valstr);
 
   /* supply register stores in target byte order, so swap here */
 

-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+  store_unsigned_integer (regbuf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);

 
   supply_register (regno, regbuf);
 
 
   supply_register (regno, regbuf);
 


@@ -929,14 +930,8 @@ monitor_supply_register (int regno, char *valstr)
 
 /* Tell the remote machine to resume.  */
 
 
 /* Tell the remote machine to resume.  */
 

-void
-flush_monitor_dcache (void)
-{
-  dcache_invd (remote_dcache);
-}
-

 static void
 static void

-monitor_resume (int pid, int step, enum target_signal sig)
+monitor_resume (ptid_t ptid, int step, enum target_signal sig)

 {
   /* Some monitors require a different command when starting a program */
   monitor_debug ("MON resume\n");
 {
   /* Some monitors require a different command when starting a program */
   monitor_debug ("MON resume\n");


@@ -948,7 +943,6 @@ monitor_resume (int pid, int step, enum target_signal sig)
        dump_reg_flag = 1;
       return;
     }
        dump_reg_flag = 1;
       return;
     }

-  dcache_invd (remote_dcache);

   if (step)
     monitor_printf (current_monitor->step);
   else
   if (step)
     monitor_printf (current_monitor->step);
   else


@@ -1035,7 +1029,7 @@ monitor_interrupt_query (void)
 Give up (and stop debugging it)? "))
     {
       target_mourn_inferior ();
 Give up (and stop debugging it)? "))
     {
       target_mourn_inferior ();

-      return_to_top_level (RETURN_QUIT);
+      throw_exception (RETURN_QUIT);

     }
 
   target_terminal_inferior ();
     }
 
   target_terminal_inferior ();


@@ -1051,12 +1045,11 @@ monitor_wait_cleanup (void *old_timeout)
 
 
 
 
 
 

-void
+static void

 monitor_wait_filter (char *buf,
                     int bufmax,
                     int *ext_resp_len,
 monitor_wait_filter (char *buf,
                     int bufmax,
                     int *ext_resp_len,

-                    struct target_waitstatus *status
-)
+                    struct target_waitstatus *status)

 {
   int resp_len;
   do
 {
   int resp_len;
   do


@@ -1087,8 +1080,8 @@ monitor_wait_filter (char *buf,
 /* Wait until the remote machine stops, then return, storing status in
    status just as `wait' would.  */
 
 /* Wait until the remote machine stops, then return, storing status in
    status just as `wait' would.  */
 

-static int
-monitor_wait (int pid, struct target_waitstatus *status)
+static ptid_t
+monitor_wait (ptid_t ptid, struct target_waitstatus *status)

 {
   int old_timeout = timeout;
   char buf[TARGET_BUF_SIZE];
 {
   int old_timeout = timeout;
   char buf[TARGET_BUF_SIZE];


@@ -1164,7 +1157,7 @@ monitor_wait (int pid, struct target_waitstatus *status)
 
   in_monitor_wait = 0;
 
 
   in_monitor_wait = 0;
 

-  return inferior_pid;
+  return inferior_ptid;

 }
 
 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
 }
 
 /* Fetch register REGNO, or all registers if REGNO is -1. Returns


@@ -1173,16 +1166,19 @@ monitor_wait (int pid, struct target_waitstatus *status)
 static void
 monitor_fetch_register (int regno)
 {
 static void
 monitor_fetch_register (int regno)
 {

-  char *name;
+  const char *name;

   char *zerobuf;
   char *regbuf;
   int i;
 
   char *zerobuf;
   char *regbuf;
   int i;
 

-  regbuf  = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
-  zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
-  memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+  regbuf  = alloca (MAX_REGISTER_SIZE * 2 + 1);
+  zerobuf = alloca (MAX_REGISTER_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);

 
 

-  name = current_monitor->regnames[regno];
+  if (current_monitor->regname != NULL)
+    name = current_monitor->regname (regno);
+  else
+    name = current_monitor->regnames[regno];

   monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
 
   if (!name || (*name == '\0'))
   monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
 
   if (!name || (*name == '\0'))


@@ -1231,7 +1227,7 @@ monitor_fetch_register (int regno)
      spaces, but stop reading if something else is seen.  Some monitors
      like to drop leading zeros.  */
 
      spaces, but stop reading if something else is seen.  Some monitors
      like to drop leading zeros.  */
 

-  for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+  for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno) * 2; i++)

     {
       int c;
       c = readchar (timeout);
     {
       int c;
       c = readchar (timeout);


@@ -1303,7 +1299,7 @@ monitor_dump_regs (void)
       parse_register_dump (buf, resp_len);
     }
   else
       parse_register_dump (buf, resp_len);
     }
   else

-    abort ();                  /* Need some way to read registers */
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");                  /* Need some way to read registers */

 }
 
 static void
 }
 
 static void


@@ -1332,10 +1328,14 @@ monitor_fetch_registers (int regno)
 static void
 monitor_store_register (int regno)
 {
 static void
 monitor_store_register (int regno)
 {

-  char *name;
+  const char *name;

   ULONGEST val;
   ULONGEST val;

-
-  name = current_monitor->regnames[regno];
+  
+  if (current_monitor->regname != NULL)
+    name = current_monitor->regname (regno);
+  else
+    name = current_monitor->regnames[regno];
+  

   if (!name || (*name == '\0'))
     {
       monitor_debug ("MON Cannot store unknown register\n");
   if (!name || (*name == '\0'))
     {
       monitor_debug ("MON Cannot store unknown register\n");


@@ -1344,7 +1344,7 @@ monitor_store_register (int regno)
 
   val = read_register (regno);
   monitor_debug ("MON storeg %d %s\n", regno,
 
   val = read_register (regno);
   monitor_debug ("MON storeg %d %s\n", regno,

-                phex (val, REGISTER_RAW_SIZE (regno)));
+                phex (val, DEPRECATED_REGISTER_RAW_SIZE (regno)));

 
   /* send the register deposit command */
 
 
   /* send the register deposit command */
 


@@ -1355,6 +1355,13 @@ monitor_store_register (int regno)
   else
     monitor_printf (current_monitor->setreg.cmd, name, val);
 
   else
     monitor_printf (current_monitor->setreg.cmd, name, val);
 

+  if (current_monitor->setreg.resp_delim)
+    {
+      monitor_debug ("EXP setreg.resp_delim\n");
+      monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
+      if (current_monitor->flags & MO_SETREG_INTERACTIVE)
+       monitor_printf ("%s\r", paddr_nz (val));
+    }

   if (current_monitor->setreg.term)
     {
       monitor_debug ("EXP setreg.term\n");
   if (current_monitor->setreg.term)
     {
       monitor_debug ("EXP setreg.term\n");


@@ -1481,6 +1488,12 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
 
       monitor_printf_noecho (cmd, memaddr);
 
 
       monitor_printf_noecho (cmd, memaddr);
 

+      if (current_monitor->setmem.resp_delim)
+        {
+          monitor_debug ("EXP setmem.resp_delim");
+          monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0); 
+         monitor_printf ("%x\r", val);
+       }

       if (current_monitor->setmem.term)
        {
          monitor_debug ("EXP setmem.term");
       if (current_monitor->setmem.term)
        {
          monitor_debug ("EXP setmem.term");


@@ -1502,33 +1515,6 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
 }
 
 
 }
 
 

-static int
-monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len)
-{
-  unsigned int val;
-  int written = 0;;
-  /* Enter the sub mode */
-  monitor_printf (current_monitor->setmem.cmdl, memaddr);
-  monitor_expect_prompt (NULL, 0);
-
-  while (len)
-    {
-      val = extract_unsigned_integer (myaddr, 4);      /* REALLY */
-      monitor_printf ("%x\r", val);
-      myaddr += 4;
-      memaddr += 4;
-      written += 4;
-      monitor_debug (" @ %s\n", paddr (memaddr));
-      /* If we wanted to, here we could validate the address */
-      monitor_expect_prompt (NULL, 0);
-    }
-  /* Now exit the sub mode */
-  monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt (NULL, 0);
-  return written;
-}
-
-

 static int
 monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
 {
 static int
 monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
 {


@@ -1680,17 +1666,6 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
     {
       return monitor_write_memory_longlongs (memaddr, myaddr, len);
     }
     {
       return monitor_write_memory_longlongs (memaddr, myaddr, len);
     }

-#endif
-#if 0
-  if (len > 4)
-    {
-      int sublen;
-      written = monitor_write_even_block (memaddr, myaddr, len);
-      /* Adjust calling parameters by written amount */
-      memaddr += written;
-      myaddr += written;
-      len -= written;
-    }

 #endif
   written = monitor_write_memory_bytes (memaddr, myaddr, len);
   return written;
 #endif
   written = monitor_write_memory_bytes (memaddr, myaddr, len);
   return written;


@@ -1706,7 +1681,6 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
   char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;
   char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;

-  int i;

 
   monitor_debug ("MON read single\n");
 #if 0
 
   monitor_debug ("MON read single\n");
 #if 0


@@ -1766,29 +1740,31 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
       else
        monitor_error ("monitor_read_memory_single", 
                       "bad response from monitor",
       else
        monitor_error ("monitor_read_memory_single", 
                       "bad response from monitor",

-                      memaddr, i, membuf, c);
+                      memaddr, 0, NULL, 0);

     }
     }

-  for (i = 0; i < len * 2; i++)
-    {
-      int c;
-
-      while (1)
-       {
-         c = readchar (timeout);
-         if (isxdigit (c))
-           break;
-         if (c == ' ')
-           continue;

 
 

-         monitor_error ("monitor_read_memory_single",
-                        "bad response from monitor",
-                        memaddr, i, membuf, c);
-       }
+  {
+    int i;
+    for (i = 0; i < len * 2; i++)
+      {
+       int c;

 
 

+       while (1)
+         {
+           c = readchar (timeout);
+           if (isxdigit (c))
+             break;
+           if (c == ' ')
+             continue;
+           
+           monitor_error ("monitor_read_memory_single",
+                          "bad response from monitor",
+                          memaddr, i, membuf, 0);
+         }

       membuf[i] = c;
     }
       membuf[i] = c;
     }

-
-  membuf[i] = '\000';          /* terminate the number */
+    membuf[i] = '\000';                /* terminate the number */
+  }

 
 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
    present), we will send TERM_CMD if that is present.  In any case, we collect
 
 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
    present), we will send TERM_CMD if that is present.  In any case, we collect


@@ -1890,7 +1866,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
 
       if (current_monitor->getmem.term_cmd)
        {
 
       if (current_monitor->getmem.term_cmd)
        {

-         SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
+         serial_write (monitor_desc, current_monitor->getmem.term_cmd,

                        strlen (current_monitor->getmem.term_cmd));
          monitor_expect_prompt (NULL, 0);
        }
                        strlen (current_monitor->getmem.term_cmd));
          monitor_expect_prompt (NULL, 0);
        }


@@ -2006,9 +1982,23 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
 
 static int
 monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 
 static int
 monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,

-                    struct target_ops *target)
+                    struct mem_attrib *attrib, struct target_ops *target)

 {
 {

-  return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
+  int res;
+
+  if (write)
+    {
+      if (current_monitor->flags & MO_HAS_BLOCKWRITES)
+       res = monitor_write_memory_block(memaddr, myaddr, len);
+      else
+       res = monitor_write_memory(memaddr, myaddr, len);
+    }
+  else
+    {
+      res = monitor_read_memory(memaddr, myaddr, len);
+    }
+
+  return res;

 }
 
 static void
 }
 
 static void


@@ -2021,7 +2011,8 @@ monitor_kill (void)
    the program at that point.  */
 
 static void
    the program at that point.  */
 
 static void

-monitor_create_inferior (char *exec_file, char *args, char **env)
+monitor_create_inferior (char *exec_file, char *args, char **env,
+                        int from_tty)

 {
   if (args && (*args != '\000'))
     error ("Args are not supported by the monitor.");
 {
   if (args && (*args != '\000'))
     error ("Args are not supported by the monitor.");


@@ -2049,7 +2040,7 @@ static int
 monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
 {
   int i;
 monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
 {
   int i;

-  unsigned char *bp;
+  const unsigned char *bp;

   int bplen;
 
   monitor_debug ("MON inst bkpt %s\n", paddr (addr));
   int bplen;
 
   monitor_debug ("MON inst bkpt %s\n", paddr (addr));


@@ -2060,7 +2051,7 @@ monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
     addr = ADDR_BITS_REMOVE (addr);
 
   /* Determine appropriate breakpoint size for this address.  */
     addr = ADDR_BITS_REMOVE (addr);
 
   /* Determine appropriate breakpoint size for this address.  */

-  bp = memory_breakpoint_from_pc (&addr, &bplen);
+  bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);

 
   for (i = 0; i < current_monitor->num_breakpoints; i++)
     {
 
   for (i = 0; i < current_monitor->num_breakpoints; i++)
     {


@@ -2145,7 +2136,6 @@ monitor_wait_srec_ack (void)
 static void
 monitor_load (char *file, int from_tty)
 {
 static void
 monitor_load (char *file, int from_tty)
 {

-  dcache_invd (remote_dcache);

   monitor_debug ("MON load\n");
 
   if (current_monitor->load_routine)
   monitor_debug ("MON load\n");
 
   if (current_monitor->load_routine)


@@ -2175,20 +2165,23 @@ monitor_load (char *file, int from_tty)
       monitor_expect_prompt (NULL, 0);
     }
 
       monitor_expect_prompt (NULL, 0);
     }
 

-/* Finally, make the PC point at the start address */
-
+  /* Finally, make the PC point at the start address */

   if (exec_bfd)
     write_pc (bfd_get_start_address (exec_bfd));
 
   if (exec_bfd)
     write_pc (bfd_get_start_address (exec_bfd));
 

-  inferior_pid = 0;            /* No process now */
-
-/* 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... */
-
-  clear_symtab_users ();
+  /* There used to be code here which would clear inferior_ptid and
+     call clear_symtab_users.  None of that should be necessary:
+     monitor targets should behave like remote protocol targets, and
+     since generic_load does none of those things, this function
+     shouldn't either.
+
+     Furthermore, clearing inferior_ptid is *incorrect*.  After doing
+     a load, we still have a valid connection to the monitor, with a
+     live processor state to fiddle with.  The user can type
+     `continue' or `jump *start' and make the program run.  If they do
+     these things, however, GDB will be talking to a running program
+     while inferior_ptid is null_ptid; this makes things like
+     reinit_frame_cache very confused.  */

 }
 
 static void
 }
 
 static void


@@ -2196,7 +2189,7 @@ monitor_stop (void)
 {
   monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
 {
   monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)

-    SERIAL_SEND_BREAK (monitor_desc);
+    serial_send_break (monitor_desc);

   if (current_monitor->stop)
     monitor_printf_noecho (current_monitor->stop);
 }
   if (current_monitor->stop)
     monitor_printf_noecho (current_monitor->stop);
 }


@@ -2256,19 +2249,10 @@ static struct target_ops monitor_ops;
 static void
 init_base_monitor_ops (void)
 {
 static void
 init_base_monitor_ops (void)
 {

-  monitor_ops.to_shortname = NULL;
-  monitor_ops.to_longname = NULL;
-  monitor_ops.to_doc = NULL;
-  monitor_ops.to_open = NULL;

   monitor_ops.to_close = monitor_close;
   monitor_ops.to_close = monitor_close;

-  monitor_ops.to_attach = NULL;
-  monitor_ops.to_post_attach = NULL;
-  monitor_ops.to_require_attach = NULL;

   monitor_ops.to_detach = monitor_detach;
   monitor_ops.to_detach = monitor_detach;

-  monitor_ops.to_require_detach = NULL;

   monitor_ops.to_resume = monitor_resume;
   monitor_ops.to_wait = monitor_wait;
   monitor_ops.to_resume = monitor_resume;
   monitor_ops.to_wait = monitor_wait;

-  monitor_ops.to_post_wait = NULL;

   monitor_ops.to_fetch_registers = monitor_fetch_registers;
   monitor_ops.to_store_registers = monitor_store_registers;
   monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
   monitor_ops.to_fetch_registers = monitor_fetch_registers;
   monitor_ops.to_store_registers = monitor_store_registers;
   monitor_ops.to_prepare_to_store = monitor_prepare_to_store;


@@ -2276,49 +2260,18 @@ init_base_monitor_ops (void)
   monitor_ops.to_files_info = monitor_files_info;
   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
   monitor_ops.to_files_info = monitor_files_info;
   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;

-  monitor_ops.to_terminal_init = 0;
-  monitor_ops.to_terminal_inferior = 0;
-  monitor_ops.to_terminal_ours_for_output = 0;
-  monitor_ops.to_terminal_ours = 0;
-  monitor_ops.to_terminal_info = 0;

   monitor_ops.to_kill = monitor_kill;
   monitor_ops.to_load = monitor_load;
   monitor_ops.to_kill = monitor_kill;
   monitor_ops.to_load = monitor_load;

-  monitor_ops.to_lookup_symbol = 0;

   monitor_ops.to_create_inferior = monitor_create_inferior;
   monitor_ops.to_create_inferior = monitor_create_inferior;

-  monitor_ops.to_post_startup_inferior = NULL;
-  monitor_ops.to_acknowledge_created_inferior = NULL;
-  monitor_ops.to_clone_and_follow_inferior = NULL;
-  monitor_ops.to_post_follow_inferior_by_clone = NULL;
-  monitor_ops.to_insert_fork_catchpoint = NULL;
-  monitor_ops.to_remove_fork_catchpoint = NULL;
-  monitor_ops.to_insert_vfork_catchpoint = NULL;
-  monitor_ops.to_remove_vfork_catchpoint = NULL;
-  monitor_ops.to_has_forked = NULL;
-  monitor_ops.to_has_vforked = NULL;
-  monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
-  monitor_ops.to_post_follow_vfork = NULL;
-  monitor_ops.to_insert_exec_catchpoint = NULL;
-  monitor_ops.to_remove_exec_catchpoint = NULL;
-  monitor_ops.to_has_execd = NULL;
-  monitor_ops.to_reported_exec_events_per_exec_call = NULL;
-  monitor_ops.to_has_exited = NULL;

   monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
   monitor_ops.to_mourn_inferior = monitor_mourn_inferior;

-  monitor_ops.to_can_run = 0;
-  monitor_ops.to_notice_signals = 0;
-  monitor_ops.to_thread_alive = 0;

   monitor_ops.to_stop = monitor_stop;
   monitor_ops.to_rcmd = monitor_rcmd;
   monitor_ops.to_stop = monitor_stop;
   monitor_ops.to_rcmd = monitor_rcmd;

-  monitor_ops.to_pid_to_exec_file = NULL;
-  monitor_ops.to_core_file_to_sym_file = NULL;

   monitor_ops.to_stratum = process_stratum;
   monitor_ops.to_stratum = process_stratum;

-  monitor_ops.DONT_USE = 0;

   monitor_ops.to_has_all_memory = 1;
   monitor_ops.to_has_memory = 1;
   monitor_ops.to_has_stack = 1;
   monitor_ops.to_has_registers = 1;
   monitor_ops.to_has_execution = 1;
   monitor_ops.to_has_all_memory = 1;
   monitor_ops.to_has_memory = 1;
   monitor_ops.to_has_stack = 1;
   monitor_ops.to_has_registers = 1;
   monitor_ops.to_has_execution = 1;

-  monitor_ops.to_sections = 0;
-  monitor_ops.to_sections_end = 0;

   monitor_ops.to_magic = OPS_MAGIC;
 }                              /* init_base_monitor_ops */
 
   monitor_ops.to_magic = OPS_MAGIC;
 }                              /* init_base_monitor_ops */
 


@@ -2335,6 +2288,8 @@ init_monitor_ops (struct target_ops *ops)
 
 /* Define additional commands that are usually only used by monitors.  */
 
 
 /* Define additional commands that are usually only used by monitors.  */
 

+extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
+

 void
 _initialize_remote_monitors (void)
 {
 void
 _initialize_remote_monitors (void)
 {