2005-02-11 Andrew Cagney <cagney@gnu.org>

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

diff --git a/gdb/monitor.c b/gdb/monitor.c
index 03817542b712a296d306ccc27b16de19eee05d7a..81c4876cd302fbe642c954d791eef62ee8ae9b54 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,7 @@
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"

-#include "gdb_wait.h"
+#include "exceptions.h"

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


@@ -51,8 +54,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 +70,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 +122,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 +132,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? */
 


@@ -144,7 +154,7 @@ static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
 static int monitor_debug_p = 0;
 
 /* NOTE: This file alternates between monitor_debug_p and remote_debug
 static int monitor_debug_p = 0;
 
 /* NOTE: This file alternates between monitor_debug_p and remote_debug

-   when determining if debug information is printed.  Perhaphs this
+   when determining if debug information is printed.  Perhaps this

    could be simplified. */
 
 static void
    could be simplified. */
 
 static void


@@ -235,16 +245,15 @@ monitor_error (char *function, char *message,
   monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)
   monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)

-    error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
+    error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);

   else
   else

-    error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
+    error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);

 }
 
 /* Convert hex digit A to a number.  */
 
 static int
 }
 
 /* Convert hex digit A to a number.  */
 
 static int

-fromhex (a)
-     int a;
+fromhex (int a)

 {
   if (a >= '0' && a <= '9')
     return a - '0';
 {
   if (a >= '0' && a <= '9')
     return a - '0';


@@ -253,7 +262,7 @@ fromhex (a)
   else if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
   else
   else if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
   else

-    error ("Invalid hex digit %d", a);
+    error (_("Invalid hex digit %d"), a);

 }
 
 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
 }
 
 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses


@@ -271,10 +280,7 @@ fromhex (a)
  */
 
 static void
  */
 
 static void

-monitor_vsprintf (sndbuf, pattern, args)
-     char *sndbuf;
-     char *pattern;
-     va_list args;
+monitor_vsprintf (char *sndbuf, char *pattern, va_list args)

 {
   char format[10];
   char fmt;
 {
   char format[10];
   char fmt;


@@ -340,7 +346,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)
     {


@@ -368,7 +374,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)
     {


@@ -391,12 +397,10 @@ monitor_printf (char *pattern,...)
 /* Write characters to the remote system.  */
 
 void
 /* Write characters to the remote system.  */
 
 void

-monitor_write (buf, buflen)
-     char *buf;
-     int buflen;
+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));
 }
 


@@ -406,7 +410,7 @@ monitor_write (buf, buflen)
    and without printing remote debug information.  */
 
 int
    and without printing remote debug information.  */
 
 int

-monitor_readchar ()
+monitor_readchar (void)

 {
   int c;
   int looping;
 {
   int c;
   int looping;


@@ -414,7 +418,7 @@ monitor_readchar ()
   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 */


@@ -425,9 +429,9 @@ monitor_readchar ()
     return c;
 
   if (c == SERIAL_TIMEOUT)
     return c;
 
   if (c == SERIAL_TIMEOUT)

-    error ("Timeout reading from remote system.");
+    error (_("Timeout reading from remote system."));

 
 

-  perror_with_name ("remote-monitor");
+  perror_with_name (_("remote-monitor"));

 }
 
 
 }
 
 


@@ -435,8 +439,7 @@ monitor_readchar ()
    timeout stuff.  */
 
 static int
    timeout stuff.  */
 
 static int

-readchar (timeout)
-     int timeout;
+readchar (int timeout)

 {
   int c;
   static enum
 {
   int c;
   static enum


@@ -449,7 +452,7 @@ readchar (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)
        {


@@ -497,13 +500,13 @@ readchar (timeout)
     if (in_monitor_wait)       /* Watchdog went off */
       {
        target_mourn_inferior ();
     if (in_monitor_wait)       /* Watchdog went off */
       {
        target_mourn_inferior ();

-       error ("GDB serial timeout has expired.  Target detached.\n");
+       error (_("GDB serial timeout has expired.  Target detached."));

       }
     else
 #endif
       }
     else
 #endif

-      error ("Timeout reading from remote system.");
+      error (_("Timeout reading from remote system."));

 
 

-  perror_with_name ("remote-monitor");
+  perror_with_name (_("remote-monitor"));

 }
 
 /* Scan input from the remote system, until STRING is found.  If BUF is non-
 }
 
 /* Scan input from the remote system, until STRING is found.  If BUF is non-


@@ -514,15 +517,11 @@ readchar (timeout)
    will be at the end of BUF.  */
 
 int
    will be at the end of BUF.  */
 
 int

-monitor_expect (string, buf, buflen)
-     char *string;
-     char *buf;
-     int buflen;
+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)
     {


@@ -531,7 +530,7 @@ monitor_expect (string, buf, buflen)
       fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
     }
 
       fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
     }
 

-  immediate_quit = 1;
+  immediate_quit++;

   while (1)
     {
       if (buf)
   while (1)
     {
       if (buf)


@@ -539,7 +538,7 @@ monitor_expect (string, buf, buflen)
          if (buflen < 2)
            {
              *buf = '\000';
          if (buflen < 2)
            {
              *buf = '\000';

-             immediate_quit = 0;
+             immediate_quit--;

              return -1;
            }
 
              return -1;
            }
 


@@ -559,7 +558,7 @@ monitor_expect (string, buf, buflen)
          p++;
          if (*p == '\0')
            {
          p++;
          if (*p == '\0')
            {

-             immediate_quit = 0;
+             immediate_quit--;

 
              if (buf)
                {
 
              if (buf)
                {


@@ -570,12 +569,6 @@ monitor_expect (string, buf, 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


@@ -622,10 +615,7 @@ monitor_expect (string, buf, buflen)
 /* Search for a regexp.  */
 
 static int
 /* Search for a regexp.  */
 
 static int

-monitor_expect_regexp (pat, buf, buflen)
-     struct re_pattern_buffer *pat;
-     char *buf;
-     int buflen;
+monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)

 {
   char *mybuf;
   char *p;
 {
   char *mybuf;
   char *p;


@@ -676,9 +666,7 @@ monitor_expect_regexp (pat, buf, buflen)
    getting into states from which we can't recover.  */
 
 int
    getting into states from which we can't recover.  */
 
 int

-monitor_expect_prompt (buf, buflen)
-     char *buf;
-     int buflen;
+monitor_expect_prompt (char *buf, int buflen)

 {
   monitor_debug ("MON Expecting prompt\n");
   return monitor_expect (current_monitor->prompt, buf, buflen);
 {
   monitor_debug ("MON Expecting prompt\n");
   return monitor_expect (current_monitor->prompt, buf, buflen);


@@ -689,7 +677,7 @@ monitor_expect_prompt (buf, buflen)
 
 #if 0
 static unsigned long
 
 #if 0
 static unsigned long

-get_hex_word ()
+get_hex_word (void)

 {
   unsigned long val;
   int i;
 {
   unsigned long val;
   int i;


@@ -714,10 +702,8 @@ get_hex_word ()
 #endif
 
 static void
 #endif
 
 static void

-compile_pattern (pattern, compiled_pattern, fastmap)
-     char *pattern;
-     struct re_pattern_buffer *compiled_pattern;
-     char *fastmap;
+compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
+                char *fastmap)

 {
   int tmp;
   const char *val;
 {
   int tmp;
   const char *val;


@@ -731,7 +717,7 @@ compile_pattern (pattern, compiled_pattern, fastmap)
   re_set_syntax (tmp);
 
   if (val)
   re_set_syntax (tmp);
 
   if (val)

-    error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
+    error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern, val);

 
   if (fastmap)
     re_compile_fastmap (compiled_pattern);
 
   if (fastmap)
     re_compile_fastmap (compiled_pattern);


@@ -741,23 +727,20 @@ compile_pattern (pattern, compiled_pattern, fastmap)
    for communication.  */
 
 void
    for communication.  */
 
 void

-monitor_open (args, mon_ops, from_tty)
-     char *args;
-     struct monitor_ops *mon_ops;
-     int from_tty;
+monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)

 {
   char *name;
   char **p;
 
   if (mon_ops->magic != MONITOR_OPS_MAGIC)
 {
   char *name;
   char **p;
 
   if (mon_ops->magic != MONITOR_OPS_MAGIC)

-    error ("Magic number of monitor_ops struct wrong.");
+    error (_("Magic number of monitor_ops struct wrong."));

 
   targ_ops = mon_ops->target;
   name = targ_ops->to_shortname;
 
   if (!args)
 
   targ_ops = mon_ops->target;
   name = targ_ops->to_shortname;
 
   if (!args)

-    error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
-`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
+    error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
+`target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);

 
   target_preopen (from_tty);
 
 
   target_preopen (from_tty);
 


@@ -771,33 +754,41 @@ monitor_open (args, mon_ops, 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;
 


@@ -827,7 +818,7 @@ monitor_open (args, mon_ops, 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)


@@ -852,16 +843,12 @@ monitor_open (args, mon_ops, 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 (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 ();
 }
 


@@ -869,16 +856,15 @@ monitor_open (args, mon_ops, from_tty)
    control.  */
 
 void
    control.  */
 
 void

-monitor_close (quitting)
-     int quitting;
+monitor_close (int quitting)

 {
   if (monitor_desc)
 {
   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;
     }
 


@@ -889,9 +875,7 @@ monitor_close (quitting)
    when you want to detach and do something else with your gdb.  */
 
 static void
    when you want to detach and do something else with your gdb.  */
 
 static void

-monitor_detach (args, from_tty)
-     char *args;
-     int from_tty;
+monitor_detach (char *args, int from_tty)

 {
   pop_target ();               /* calls monitor_close to do the real work */
   if (from_tty)
 {
   pop_target ();               /* calls monitor_close to do the real work */
   if (from_tty)


@@ -901,12 +885,10 @@ monitor_detach (args, from_tty)
 /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
 
 char *
 /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
 
 char *

-monitor_supply_register (regno, valstr)
-     int regno;
-     char *valstr;
+monitor_supply_register (int regno, char *valstr)

 {
   ULONGEST val;
 {
   ULONGEST val;

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

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


@@ -934,31 +916,23 @@ monitor_supply_register (regno, valstr)
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 

-  if (*p != '\0')
-    error ("monitor_supply_register (%d):  bad value from monitor: %s.",
+  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 */
 
           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, register_size (current_gdbarch, regno), val);

 
 

-  supply_register (regno, regbuf);
+  regcache_raw_supply (current_regcache, regno, regbuf);

 
   return p;
 }
 
 /* Tell the remote machine to resume.  */
 
 
   return p;
 }
 
 /* Tell the remote machine to resume.  */
 

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

 static void
 static void

-monitor_resume (pid, step, sig)
-     int pid, 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");


@@ -970,7 +944,6 @@ monitor_resume (pid, step, sig)
        dump_reg_flag = 1;
       return;
     }
        dump_reg_flag = 1;
       return;
     }

-  dcache_flush (remote_dcache);

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


@@ -990,9 +963,7 @@ monitor_resume (pid, step, sig)
    string which are passed down to monitor specific code.  */
 
 static void
    string which are passed down to monitor specific code.  */
 
 static void

-parse_register_dump (buf, len)
-     char *buf;
-     int len;
+parse_register_dump (char *buf, int len)

 {
   monitor_debug ("MON Parsing  register dump\n");
   while (1)
 {
   monitor_debug ("MON Parsing  register dump\n");
   while (1)


@@ -1025,8 +996,7 @@ parse_register_dump (buf, len)
    packet.  */
 
 static void
    packet.  */
 
 static void

-monitor_interrupt (signo)
-     int signo;
+monitor_interrupt (int signo)

 {
   /* If this doesn't work, try more severe steps.  */
   signal (signo, monitor_interrupt_twice);
 {
   /* If this doesn't work, try more severe steps.  */
   signal (signo, monitor_interrupt_twice);


@@ -1040,8 +1010,7 @@ monitor_interrupt (signo)
 /* The user typed ^C twice.  */
 
 static void
 /* The user typed ^C twice.  */
 
 static void

-monitor_interrupt_twice (signo)
-     int signo;
+monitor_interrupt_twice (int signo)

 {
   signal (signo, ofunc);
 
 {
   signal (signo, ofunc);
 


@@ -1053,7 +1022,7 @@ monitor_interrupt_twice (signo)
 /* Ask the user what to do when an interrupt is received.  */
 
 static void
 /* Ask the user what to do when an interrupt is received.  */
 
 static void

-monitor_interrupt_query ()
+monitor_interrupt_query (void)

 {
   target_terminal_ours ();
 
 {
   target_terminal_ours ();
 


@@ -1061,15 +1030,14 @@ monitor_interrupt_query ()
 Give up (and stop debugging it)? "))
     {
       target_mourn_inferior ();
 Give up (and stop debugging it)? "))
     {
       target_mourn_inferior ();

-      return_to_top_level (RETURN_QUIT);
+      deprecated_throw_reason (RETURN_QUIT);

     }
 
   target_terminal_inferior ();
 }
 
 static void
     }
 
   target_terminal_inferior ();
 }
 
 static void

-monitor_wait_cleanup (old_timeout)
-     void *old_timeout;
+monitor_wait_cleanup (void *old_timeout)

 {
   timeout = *(int *) old_timeout;
   signal (SIGINT, ofunc);
 {
   timeout = *(int *) old_timeout;
   signal (SIGINT, ofunc);


@@ -1078,12 +1046,11 @@ monitor_wait_cleanup (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


@@ -1114,10 +1081,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 (pid, status)
-     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];


@@ -1193,32 +1158,34 @@ monitor_wait (pid, 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
    errno value.  */
 
 static void
 }
 
 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
    errno value.  */
 
 static void

-monitor_fetch_register (regno)
-     int regno;
+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 ("No register known for %d\n", regno);
   monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
 
   if (!name || (*name == '\0'))
     {
       monitor_debug ("No register known for %d\n", regno);

-      supply_register (regno, zerobuf);
+      regcache_raw_supply (current_regcache, regno, zerobuf);

       return;
     }
 
       return;
     }
 


@@ -1253,7 +1220,7 @@ monitor_fetch_register (regno)
       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
        ;
       else
       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
        ;
       else

-       error ("Bad value returned from monitor while fetching register %x.",
+       error (_("Bad value returned from monitor while fetching register %x."),

               regno);
     }
 
               regno);
     }
 


@@ -1261,7 +1228,7 @@ monitor_fetch_register (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 < register_size (current_gdbarch, regno) * 2; i++)

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


@@ -1320,7 +1287,7 @@ monitor_dump_reg_block (char *block_cmd)
 /* Call the specific function if it has been provided */
 
 static void
 /* Call the specific function if it has been provided */
 
 static void

-monitor_dump_regs ()
+monitor_dump_regs (void)

 {
   char buf[TARGET_BUF_SIZE];
   int resp_len;
 {
   char buf[TARGET_BUF_SIZE];
   int resp_len;


@@ -1333,12 +1300,11 @@ monitor_dump_regs ()
       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

-monitor_fetch_registers (regno)
-     int regno;
+monitor_fetch_registers (int regno)

 {
   monitor_debug ("MON fetchregs\n");
   if (current_monitor->getreg.cmd)
 {
   monitor_debug ("MON fetchregs\n");
   if (current_monitor->getreg.cmd)


@@ -1361,13 +1327,16 @@ monitor_fetch_registers (regno)
 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
 
 static void
 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
 
 static void

-monitor_store_register (regno)
-     int regno;
+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");


@@ -1376,7 +1345,7 @@ monitor_store_register (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, register_size (current_gdbarch, regno)));

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


@@ -1387,6 +1356,13 @@ monitor_store_register (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");


@@ -1408,8 +1384,7 @@ monitor_store_register (regno)
 /* Store the remote registers.  */
 
 static void
 /* Store the remote registers.  */
 
 static void

-monitor_store_registers (regno)
-     int regno;
+monitor_store_registers (int regno)

 {
   if (regno >= 0)
     {
 {
   if (regno >= 0)
     {


@@ -1428,23 +1403,19 @@ monitor_store_registers (regno)
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-monitor_prepare_to_store ()
+monitor_prepare_to_store (void)

 {
   /* Do nothing, since we can store individual regs */
 }
 
 static void
 {
   /* Do nothing, since we can store individual regs */
 }
 
 static void

-monitor_files_info (ops)
-     struct target_ops *ops;
+monitor_files_info (struct target_ops *ops)

 {
   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
 }
 
 static int
 {
   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
 }
 
 static int

-monitor_write_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)

 {
   unsigned int val, hostval;
   char *cmd;
 {
   unsigned int val, hostval;
   char *cmd;


@@ -1518,6 +1489,12 @@ monitor_write_memory (memaddr, myaddr, 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");


@@ -1540,40 +1517,7 @@ monitor_write_memory (memaddr, myaddr, len)
 
 
 static int
 
 
 static int

-monitor_write_even_block (memaddr, myaddr, len)
-     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 (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)

 {
   unsigned char val;
   int written = 0;
 {
   unsigned char val;
   int written = 0;


@@ -1665,10 +1609,7 @@ longlong_hexchars (unsigned long long value,
    Which possably entails endian conversions
  */
 static int
    Which possably entails endian conversions
  */
 static int

-monitor_write_memory_longlongs (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)

 {
   static char hexstage[20];    /* At least 16 digits required, plus null */
   char *endstring;
 {
   static char hexstage[20];    /* At least 16 digits required, plus null */
   char *endstring;


@@ -1716,10 +1657,7 @@ monitor_write_memory_longlongs (memaddr, myaddr, len)
  */
 
 static int
  */
 
 static int

-monitor_write_memory_block (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)

 {
   int written;
   written = 0;
 {
   int written;
   written = 0;


@@ -1729,17 +1667,6 @@ monitor_write_memory_block (memaddr, myaddr, 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;


@@ -1749,16 +1676,12 @@ monitor_write_memory_block (memaddr, myaddr, len)
    which can only read a single byte/word/etc. at a time.  */
 
 static int
    which can only read a single byte/word/etc. at a time.  */
 
 static int

-monitor_read_memory_single (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)

 {
   unsigned int val;
   char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;
 {
   unsigned int val;
   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


@@ -1818,29 +1741,31 @@ monitor_read_memory_single (memaddr, myaddr, 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


@@ -1879,10 +1804,7 @@ monitor_read_memory_single (memaddr, myaddr, len)
    than 16 bytes at a time.  */
 
 static int
    than 16 bytes at a time.  */
 
 static int

-monitor_read_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)

 {
   unsigned int val;
   char buf[512];
 {
   unsigned int val;
   char buf[512];


@@ -1945,7 +1867,7 @@ monitor_read_memory (memaddr, myaddr, 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);
        }


@@ -2014,7 +1936,7 @@ monitor_read_memory (memaddr, myaddr, len)
          c = *p;
        }
       if (fetched == 0)
          c = *p;
        }
       if (fetched == 0)

-       error ("Failed to read via monitor");
+       error (_("Failed to read via monitor"));

       if (monitor_debug_p || remote_debug)
        fprintf_unfiltered (gdb_stdlog, "\n");
       return fetched;          /* Return the number of bytes actually read */
       if (monitor_debug_p || remote_debug)
        fprintf_unfiltered (gdb_stdlog, "\n");
       return fetched;          /* Return the number of bytes actually read */


@@ -2055,19 +1977,33 @@ monitor_read_memory (memaddr, myaddr, len)
   return len;
 }
 
   return len;
 }
 

+/* Transfer LEN bytes between target address MEMADDR and GDB address
+   MYADDR.  Returns 0 for success, errno code for failure. TARGET is
+   unused. */
+

 static int
 static int

-monitor_xfer_memory (memaddr, myaddr, len, write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *target;        /* ignored */
+monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+                    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

-monitor_kill ()
+monitor_kill (void)

 {
   return;                      /* ignore attempts to kill target system */
 }
 {
   return;                      /* ignore attempts to kill target system */
 }


@@ -2076,13 +2012,11 @@ monitor_kill ()
    the program at that point.  */
 
 static void
    the program at that point.  */
 
 static void

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

 {
   if (args && (*args != '\000'))
 {
   if (args && (*args != '\000'))

-    error ("Args are not supported by the monitor.");
+    error (_("Args are not supported by the monitor."));

 
   first_time = 1;
   clear_proceed_status ();
 
   first_time = 1;
   clear_proceed_status ();


@@ -2095,7 +2029,7 @@ monitor_create_inferior (exec_file, args, env)
    instructions.  */
 
 static void
    instructions.  */
 
 static void

-monitor_mourn_inferior ()
+monitor_mourn_inferior (void)

 {
   unpush_target (targ_ops);
   generic_mourn_inferior ();   /* Do all the proper things now */
 {
   unpush_target (targ_ops);
   generic_mourn_inferior ();   /* Do all the proper things now */


@@ -2104,23 +2038,21 @@ monitor_mourn_inferior ()
 /* Tell the monitor to add a breakpoint.  */
 
 static int
 /* Tell the monitor to add a breakpoint.  */
 
 static int

-monitor_insert_breakpoint (addr, shadow)
-     CORE_ADDR addr;
-     char *shadow;
+monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)

 {
   int i;
 {
   int i;

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

   int bplen;
 
   monitor_debug ("MON inst bkpt %s\n", paddr (addr));
   if (current_monitor->set_break == NULL)
   int bplen;
 
   monitor_debug ("MON inst bkpt %s\n", paddr (addr));
   if (current_monitor->set_break == NULL)

-    error ("No set_break defined for this monitor");
+    error (_("No set_break defined for this monitor"));

 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     addr = ADDR_BITS_REMOVE (addr);
 
   /* Determine appropriate breakpoint size for this address.  */
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     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++)
     {


@@ -2134,21 +2066,19 @@ monitor_insert_breakpoint (addr, shadow)
        }
     }
 
        }
     }
 

-  error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
+  error (_("Too many breakpoints (> %d) for monitor."), current_monitor->num_breakpoints);

 }
 
 /* Tell the monitor to remove a breakpoint.  */
 
 static int
 }
 
 /* Tell the monitor to remove a breakpoint.  */
 
 static int

-monitor_remove_breakpoint (addr, shadow)
-     CORE_ADDR addr;
-     char *shadow;
+monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)

 {
   int i;
 
   monitor_debug ("MON rmbkpt %s\n", paddr (addr));
   if (current_monitor->clr_break == NULL)
 {
   int i;
 
   monitor_debug ("MON rmbkpt %s\n", paddr (addr));
   if (current_monitor->clr_break == NULL)

-    error ("No clr_break defined for this monitor");
+    error (_("No clr_break defined for this monitor"));

 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     addr = ADDR_BITS_REMOVE (addr);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     addr = ADDR_BITS_REMOVE (addr);


@@ -2179,7 +2109,7 @@ monitor_remove_breakpoint (addr, shadow)
    an S-record.  Return non-zero if the ACK is received properly.  */
 
 static int
    an S-record.  Return non-zero if the ACK is received properly.  */
 
 static int

-monitor_wait_srec_ack ()
+monitor_wait_srec_ack (void)

 {
   int ch;
 
 {
   int ch;
 


@@ -2205,11 +2135,8 @@ monitor_wait_srec_ack ()
 /* monitor_load -- download a file. */
 
 static void
 /* monitor_load -- download a file. */
 
 static void

-monitor_load (file, from_tty)
-     char *file;
-     int from_tty;
+monitor_load (char *file, int from_tty)

 {
 {

-  dcache_flush (remote_dcache);

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


@@ -2239,28 +2166,31 @@ monitor_load (file, 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

-monitor_stop ()
+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);
 }


@@ -2278,7 +2208,7 @@ monitor_rcmd (char *command,
   char buf[1000];
 
   if (monitor_desc == NULL)
   char buf[1000];
 
   if (monitor_desc == NULL)

-    error ("monitor target not open.");
+    error (_("monitor target not open."));

 
   p = current_monitor->prompt;
 
 
   p = current_monitor->prompt;
 


@@ -2296,8 +2226,7 @@ monitor_rcmd (char *command,
 
 #if 0
 static int
 
 #if 0
 static int

-from_hex (a)
-     int a;
+from_hex (int a)

 {
   if (a >= '0' && a <= '9')
     return a - '0';
 {
   if (a >= '0' && a <= '9')
     return a - '0';


@@ -2306,12 +2235,12 @@ from_hex (a)
   if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
 
   if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
 

-  error ("Reply contains invalid hex digit 0x%x", a);
+  error (_("Reply contains invalid hex digit 0x%x"), a);

 }
 #endif
 
 char *
 }
 #endif
 
 char *

-monitor_get_dev_name ()
+monitor_get_dev_name (void)

 {
   return dev_name;
 }
 {
   return dev_name;
 }


@@ -2321,77 +2250,36 @@ 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;

-  monitor_ops.to_xfer_memory = monitor_xfer_memory;
+  monitor_ops.deprecated_xfer_memory = monitor_xfer_memory;

   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 */
 
 /* Init the target_ops structure pointed at by OPS */
 
 void
   monitor_ops.to_magic = OPS_MAGIC;
 }                              /* init_base_monitor_ops */
 
 /* Init the target_ops structure pointed at by OPS */
 
 void

-init_monitor_ops (ops)
-     struct target_ops *ops;
+init_monitor_ops (struct target_ops *ops)

 {
   if (monitor_ops.to_magic != OPS_MAGIC)
     init_base_monitor_ops ();
 {
   if (monitor_ops.to_magic != OPS_MAGIC)
     init_base_monitor_ops ();


@@ -2401,18 +2289,21 @@ init_monitor_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
 void

-_initialize_remote_monitors ()
+_initialize_remote_monitors (void)

 {
   init_base_monitor_ops ();
 {
   init_base_monitor_ops ();

-  add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
-                                 (char *) &hashmark,
-                                 "Set display of activity while downloading a file.\n\
+  deprecated_add_show_from_set
+    (add_set_cmd ("hash", no_class, var_boolean,
+                 (char *) &hashmark,
+                 "Set display of activity while downloading a file.\n\

 When enabled, a hashmark \'#\' is displayed.",
 When enabled, a hashmark \'#\' is displayed.",

-                                 &setlist),
-                    &showlist);
+                 &setlist),
+     &showlist);

 
 

-  add_show_from_set
+  deprecated_add_show_from_set

     (add_set_cmd ("monitor", no_class, var_zinteger,
                  (char *) &monitor_debug_p,
                  "Set debugging of remote monitor communication.\n\
     (add_set_cmd ("monitor", no_class, var_zinteger,
                  (char *) &monitor_debug_p,
                  "Set debugging of remote monitor communication.\n\