projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* gdb/fileio.h: New file.
[deliverable/binutils-gdb.git] / gdb / monitor.c
diff --git a/gdb/monitor.c b/gdb/monitor.c
index 44a46cbdcb03a83d6007acdf40fdc4ad3fcde24d..eabbbd938cc23258a4dfe3910fe083b207ad8107 100644 (file)
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -1,29 +1,32 @@
 /* Remote debugging interface for boot monitors, for GDB.
 /* Remote debugging interface for boot monitors, for GDB.
-   Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
-   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.
 
-This file is part of GDB.
+   This file is part of GDB.
 
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
 
 /* 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,12 +43,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
-#include "wait.h"
-#ifdef ANSI_PROTOTYPES
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_string.h"
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_string.h"
@@ -55,60 +52,58 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "monitor.h"
 #include "gdbcmd.h"
 #include "inferior.h"
 #include "monitor.h"
 #include "gdbcmd.h"
 #include "inferior.h"
-#include "gnu-regex.h"
-#include "dcache.h"
+#include "gdb_regex.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;
 
-static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
-
-static int readchar PARAMS ((int timeout));
-
-static void monitor_command PARAMS ((char *args, int fromtty));
-
-static void monitor_fetch_register PARAMS ((int regno));
-static void monitor_store_register PARAMS ((int regno));
-
-static int monitor_printable_string PARAMS ((char *newstr, char *oldstr));
-static void monitor_error PARAMS ((char *format, CORE_ADDR memaddr, int len, char *string, int final_char));
-static void monitor_detach PARAMS ((char *args, int from_tty));
-static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
-static void monitor_interrupt PARAMS ((int signo));
-static void monitor_interrupt_twice PARAMS ((int signo));
-static void monitor_interrupt_query PARAMS ((void));
-static void monitor_wait_cleanup PARAMS ((void *old_timeout));
-
-static int monitor_wait PARAMS ((int pid, struct target_waitstatus *status));
-static void monitor_fetch_registers PARAMS ((int regno));
-static void monitor_store_registers PARAMS ((int regno));
-static void monitor_prepare_to_store PARAMS ((void));
-static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target));
-static void monitor_files_info PARAMS ((struct target_ops *ops));
-static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
-static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
-static void monitor_kill PARAMS ((void));
-static void monitor_load PARAMS ((char *file, int from_tty));
-static void monitor_mourn_inferior PARAMS ((void));
-static void monitor_stop PARAMS ((void));
-
-static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
-static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
-static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
-                                              char *myaddr,int len));
-static int monitor_write_memory_block PARAMS((
-                                             CORE_ADDR memaddr ,
-                                             char * myaddr ,
-                                             int len)) ;
-static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat,
-                                         char *buf, int buflen));
-static void monitor_dump_regs PARAMS((void)) ;
+static void monitor_vsprintf (char *sndbuf, char *pattern, va_list args);
+
+static int readchar (int timeout);
+
+static void monitor_fetch_register (int regno);
+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_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 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,
+                               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_kill (void);
+static void monitor_load (char *file, int from_tty);
+static void monitor_mourn_inferior (void);
+static void monitor_stop (void);
+
+static int monitor_read_memory (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory_bytes (CORE_ADDR addr, char *myaddr, int len);
+static int monitor_write_memory_block (CORE_ADDR memaddr,
+                                      char *myaddr, int len);
+static int monitor_expect_regexp (struct re_pattern_buffer *pat,
+                                 char *buf, int buflen);
+static void monitor_dump_regs (void);
 #if 0
 #if 0
-static int from_hex PARAMS ((int a));
-static unsigned long get_hex_word PARAMS ((void));
+static int from_hex (int a);
+static unsigned long get_hex_word (void);
 #endif
 #endif
-static void parse_register_dump PARAMS ((char *, int));
+static void parse_register_dump (char *, int);
 
 static struct monitor_ops *current_monitor;
 
 
 static struct monitor_ops *current_monitor;
 
@@ -118,21 +113,15 @@ static int timeout = 30;
 
 static int in_monitor_wait = 0;        /* Non-zero means we are in monitor_wait() */
 
 
 static int in_monitor_wait = 0;        /* Non-zero means we are in monitor_wait() */
 
-static void (*ofunc)();                /* Old SIGINT signal handler */
+static void (*ofunc) ();       /* Old SIGINT signal handler */
 
 static CORE_ADDR *breakaddr;
 
 
 static CORE_ADDR *breakaddr;
 
-/* Extra remote debugging for developing a new rom monitor variation */
-#if ! defined(EXTRA_RDEBUG)
-#define EXTRA_RDEBUG 0
-#endif
-#define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
-
 /* Descriptor for I/O to remote machine.  Initialize it to NULL so
    that monitor_open knows that we don't have a file open when the
    program starts.  */
 
 /* Descriptor for I/O to remote machine.  Initialize it to NULL so
    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 */
 
@@ -142,28 +131,62 @@ 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? */
 
 
-/* Convert a string into a printable representation, Return # byte in the
-   new string.  */
+#define TARGET_BUF_SIZE 2048
 
 
-static int
-monitor_printable_string (newstr, oldstr)
-     char *newstr;
-     char *oldstr;
+/* Monitor specific debugging information.  Typically only useful to
+   the developer of a new monitor interface. */
+
+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
+   when determining if debug information is printed.  Perhaphs this
+   could be simplified. */
+
+static void
+monitor_debug (const char *fmt, ...)
+{
+  if (monitor_debug_p)
+    {
+      va_list args;
+      va_start (args, fmt);
+      vfprintf_filtered (gdb_stdlog, fmt, args);
+      va_end (args);
+    }
+}
+
+
+/* Convert a string into a printable representation, Return # byte in
+   the new string.  When LEN is >0 it specifies the size of the
+   string.  Otherwize strlen(oldstr) is used. */
+
+static void
+monitor_printable_string (char *newstr, char *oldstr, int len)
 {
 {
-  char *save = newstr;
   int ch;
   int ch;
+  int i;
 
 
-  while ((ch = *oldstr++) != '\0')
+  if (len <= 0)
+    len = strlen (oldstr);
+
+  for (i = 0; i < len; i++)
     {
     {
+      ch = oldstr[i];
       switch (ch)
       switch (ch)
-        {
+       {
        default:
          if (isprint (ch))
            *newstr++ = ch;
        default:
          if (isprint (ch))
            *newstr++ = ch;
@@ -175,57 +198,70 @@ monitor_printable_string (newstr, oldstr)
            }
          break;
 
            }
          break;
 
-       case '\\': *newstr++ = '\\'; *newstr++ = '\\';  break;
-       case '\b': *newstr++ = '\\'; *newstr++ = 'b';   break;
-       case '\f': *newstr++ = '\\'; *newstr++ = 't';   break;
-       case '\n': *newstr++ = '\\'; *newstr++ = 'n';   break;
-       case '\r': *newstr++ = '\\'; *newstr++ = 'r';   break;
-       case '\t': *newstr++ = '\\'; *newstr++ = 't';   break;
-       case '\v': *newstr++ = '\\'; *newstr++ = 'v';   break;
-        }
+       case '\\':
+         *newstr++ = '\\';
+         *newstr++ = '\\';
+         break;
+       case '\b':
+         *newstr++ = '\\';
+         *newstr++ = 'b';
+         break;
+       case '\f':
+         *newstr++ = '\\';
+         *newstr++ = 't';
+         break;
+       case '\n':
+         *newstr++ = '\\';
+         *newstr++ = 'n';
+         break;
+       case '\r':
+         *newstr++ = '\\';
+         *newstr++ = 'r';
+         break;
+       case '\t':
+         *newstr++ = '\\';
+         *newstr++ = 't';
+         break;
+       case '\v':
+         *newstr++ = '\\';
+         *newstr++ = 'v';
+         break;
+       }
     }
 
   *newstr++ = '\0';
     }
 
   *newstr++ = '\0';
-  return newstr - save;
 }
 
 /* Print monitor errors with a string, converting the string to printable
    representation.  */
 
 static void
 }
 
 /* Print monitor errors with a string, converting the string to printable
    representation.  */
 
 static void
-monitor_error (format, memaddr, len, string, final_char)
-     char *format;
-     CORE_ADDR memaddr;
-     int len;
-     char *string;
-     int final_char;
+monitor_error (char *function, char *message,
+              CORE_ADDR memaddr, int len, char *string, int final_char)
 {
 {
-  int real_len = (len == 0 && string != (char *)0) ? strlen (string) : len;
+  int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
   char *safe_string = alloca ((real_len * 4) + 1);
   char *safe_string = alloca ((real_len * 4) + 1);
-  char *p, *q;
-  int ch;
-  int safe_len = monitor_printable_string (safe_string, string);
+  monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)
 
   if (final_char)
-    error (format, (int)memaddr, p - safe_string, safe_string, final_char);
+    error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
   else
   else
-    error (format, (int)memaddr, p - safe_string, 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';
   else if (a >= 'a' && a <= 'f')
     return a - 'a' + 10;
 {
   if (a >= '0' && a <= '9')
     return a - '0';
   else if (a >= 'a' && a <= 'f')
     return a - 'a' + 10;
+  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
@@ -240,13 +276,10 @@ fromhex (a)
    argument is assumed to be a long integer.
 
    %% is also turned into a single %.
    argument is assumed to be a long integer.
 
    %% is also turned into a single %.
-*/
-  
+ */
+
 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;
@@ -266,7 +299,7 @@ monitor_vsprintf (sndbuf, pattern, args)
               i++, p++)
            format[i] = *p;
          format[i] = fmt = *p;
               i++, p++)
            format[i] = *p;
          format[i] = fmt = *p;
-         format[i+1] = '\0';
+         format[i + 1] = '\0';
 
          /* Fetch the next argument and print it.  */
          switch (fmt)
 
          /* Fetch the next argument and print it.  */
          switch (fmt)
@@ -300,43 +333,27 @@ monitor_vsprintf (sndbuf, pattern, args)
    Works just like printf.  */
 
 void
    Works just like printf.  */
 
 void
-#ifdef ANSI_PROTOTYPES
-monitor_printf_noecho (char *pattern, ...)
-#else
-monitor_printf_noecho (va_alist)
-     va_dcl
-#endif
+monitor_printf_noecho (char *pattern,...)
 {
   va_list args;
   char sndbuf[2000];
   int len;
 
 {
   va_list args;
   char sndbuf[2000];
   int len;
 
-#if ANSI_PROTOTYPES
   va_start (args, pattern);
   va_start (args, pattern);
-#else
-  char *pattern;
-  va_start (args);
-  pattern = va_arg (args, char *);
-#endif
 
   monitor_vsprintf (sndbuf, pattern, args);
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
 
   monitor_vsprintf (sndbuf, pattern, args);
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 
 
-#if 0
-  if (remote_debug > 0)
-    puts_debug ("sent -->", sndbuf, "<--");
-#endif
-  if (EXTRA_RDEBUG
-      && remote_debug)
+  if (monitor_debug_p)
     {
       char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
     {
       char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
-      monitor_printable_string (safe_string, sndbuf);
-      printf ("sent[%s]\n", safe_string);
+      monitor_printable_string (safe_string, sndbuf, 0);
+      fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
     }
     }
-  
+
   monitor_write (sndbuf, len);
 }
 
   monitor_write (sndbuf, len);
 }
 
@@ -344,41 +361,25 @@ monitor_printf_noecho (va_alist)
    printf.  */
 
 void
    printf.  */
 
 void
-#ifdef ANSI_PROTOTYPES
-monitor_printf (char *pattern, ...)
-#else
-monitor_printf (va_alist)
-     va_dcl
-#endif
+monitor_printf (char *pattern,...)
 {
   va_list args;
   char sndbuf[2000];
   int len;
 
 {
   va_list args;
   char sndbuf[2000];
   int len;
 
-#ifdef ANSI_PROTOTYPES
   va_start (args, pattern);
   va_start (args, pattern);
-#else
-  char *pattern;
-  va_start (args);
-  pattern = va_arg (args, char *);
-#endif
 
   monitor_vsprintf (sndbuf, pattern, args);
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
 
   monitor_vsprintf (sndbuf, pattern, args);
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
-    abort ();
+    internal_error (__FILE__, __LINE__, "failed internal consistency check");
 
 
-#if 0
-  if (remote_debug > 0)
-    puts_debug ("sent -->", sndbuf, "<--");
-#endif
-  if (EXTRA_RDEBUG
-      && remote_debug)
+  if (monitor_debug_p)
     {
       char *safe_string = (char *) alloca ((len * 4) + 1);
     {
       char *safe_string = (char *) alloca ((len * 4) + 1);
-      monitor_printable_string (safe_string, sndbuf);
-      printf ("sent[%s]\n", safe_string);
+      monitor_printable_string (safe_string, sndbuf, 0);
+      fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
     }
 
   monitor_write (sndbuf, len);
     }
 
   monitor_write (sndbuf, len);
@@ -387,20 +388,18 @@ monitor_printf (va_alist)
      just output, but sometimes some extra junk appeared before the characters
      we expected, like an extra prompt, or a portmaster sending telnet negotiations.
      So, just start searching for what we sent, and skip anything unknown.  */
      just output, but sometimes some extra junk appeared before the characters
      we expected, like an extra prompt, or a portmaster sending telnet negotiations.
      So, just start searching for what we sent, and skip anything unknown.  */
-  RDEBUG(("ExpectEcho\n"))
-  monitor_expect (sndbuf, (char *)0, 0);
+  monitor_debug ("ExpectEcho\n");
+  monitor_expect (sndbuf, (char *) 0, 0);
 }
 
 
 /* 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));
 }
 
@@ -410,7 +409,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;
@@ -418,10 +417,10 @@ monitor_readchar ()
   do
     {
       looping = 0;
   do
     {
       looping = 0;
-      c = SERIAL_READCHAR (monitor_desc, timeout);
+      c = serial_readchar (monitor_desc, timeout);
 
       if (c >= 0)
 
       if (c >= 0)
-       c &= 0xff;                      /* don't lose bit 7 */
+       c &= 0xff;              /* don't lose bit 7 */
     }
   while (looping);
 
     }
   while (looping);
 
@@ -429,7 +428,7 @@ 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");
 }
@@ -439,33 +438,34 @@ monitor_readchar ()
    timeout stuff.  */
 
 static int
    timeout stuff.  */
 
 static int
-readchar (timeout)
-     int timeout;
+readchar (int timeout)
 {
   int c;
 {
   int c;
-  static enum { last_random, last_nl, last_cr, last_crnl } state = last_random;
+  static enum
+    {
+      last_random, last_nl, last_cr, last_crnl
+    }
+  state = last_random;
   int looping;
 
   do
     {
       looping = 0;
   int looping;
 
   do
     {
       looping = 0;
-      c = SERIAL_READCHAR (monitor_desc, timeout);
+      c = serial_readchar (monitor_desc, timeout);
 
       if (c >= 0)
        {
          c &= 0x7f;
 
       if (c >= 0)
        {
          c &= 0x7f;
-#if 0
          /* This seems to interfere with proper function of the
             input stream */
          /* This seems to interfere with proper function of the
             input stream */
-         if (remote_debug > 0)
+         if (monitor_debug_p || remote_debug)
            {
              char buf[2];
              buf[0] = c;
              buf[1] = '\0';
              puts_debug ("read -->", buf, "<--");
            }
            {
              char buf[2];
              buf[0] = c;
              buf[1] = '\0';
              puts_debug ("read -->", buf, "<--");
            }
-         
-#endif   
+
        }
 
       /* Canonicialize \n\r combinations into one \r */
        }
 
       /* Canonicialize \n\r combinations into one \r */
@@ -516,25 +516,21 @@ 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;
   extern struct target_ops *targ_ops;
 
 {
   char *p = string;
   int obuflen = buflen;
   int c;
   extern struct target_ops *targ_ops;
 
-  if (EXTRA_RDEBUG
-      && remote_debug)
+  if (monitor_debug_p)
     {
       char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
     {
       char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
-      monitor_printable_string (safe_string, string);
-      printf ("MON Expecting '%s'\n", safe_string);
+      monitor_printable_string (safe_string, string, 0);
+      fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
     }
 
     }
 
-  immediate_quit = 1;
+  immediate_quit++;
   while (1)
     {
       if (buf)
   while (1)
     {
       if (buf)
@@ -542,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;
            }
 
@@ -556,13 +552,13 @@ monitor_expect (string, buf, buflen)
        c = readchar (timeout);
 
       /* Don't expect any ^C sent to be echoed */
        c = readchar (timeout);
 
       /* Don't expect any ^C sent to be echoed */
-       
+
       if (*p == '\003' || c == *p)
        {
          p++;
          if (*p == '\0')
            {
       if (*p == '\003' || c == *p)
        {
          p++;
          if (*p == '\0')
            {
-             immediate_quit = 0;
+             immediate_quit--;
 
              if (buf)
                {
 
              if (buf)
                {
@@ -573,17 +569,53 @@ 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;
-       }
+#if 0
+      // OBSOLETE       else if ((c == '\021' || c == '\023') &&
+      // OBSOLETE             (STREQ (targ_ops->to_shortname, "m32r")
+      // OBSOLETE              || STREQ (targ_ops->to_shortname, "mon2000")))
+      // OBSOLETE      {                       /* m32r monitor emits random DC1/DC3 chars */
+      // OBSOLETE        continue;
+      // OBSOLETE      }
+#endif
       else
        {
       else
        {
-         p = string;
-         if (c == *p)
-           p++;
+         /* We got a character that doesn't match the string.  We need to
+            back up p, but how far?  If we're looking for "..howdy" and the
+            monitor sends "...howdy"?  There's certainly a match in there,
+            but when we receive the third ".", we won't find it if we just
+            restart the matching at the beginning of the string.
+
+            This is a Boyer-Moore kind of situation.  We want to reset P to
+            the end of the longest prefix of STRING that is a suffix of
+            what we've read so far.  In the example above, that would be
+            ".." --- the longest prefix of "..howdy" that is a suffix of
+            "...".  This longest prefix could be the empty string, if C
+            is nowhere to be found in STRING.
+
+            If this longest prefix is not the empty string, it must contain
+            C, so let's search from the end of STRING for instances of C,
+            and see if the portion of STRING before that is a suffix of
+            what we read before C.  Actually, we can search backwards from
+            p, since we know no prefix can be longer than that.
+
+            Note that we can use STRING itself, along with C, as a record
+            of what we've received so far.  :) */
+         int i;
+
+         for (i = (p - string) - 1; i >= 0; i--)
+           if (string[i] == c)
+             {
+               /* Is this prefix a suffix of what we've read so far?
+                  In other words, does
+                     string[0 .. i-1] == string[p - i, p - 1]? */
+               if (! memcmp (string, p - i, i))
+                 {
+                   p = string + i + 1;
+                   break;
+                 }
+             }
+         if (i < 0)
+           p = string;
        }
     }
 }
        }
     }
 }
@@ -591,20 +623,17 @@ 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;
-  RDEBUG(("MON Expecting regexp\n")) ;
+  monitor_debug ("MON Expecting regexp\n");
   if (buf)
     mybuf = buf;
   else
     {
   if (buf)
     mybuf = buf;
   else
     {
-      mybuf = alloca (1024);
-      buflen = 1024;
+      mybuf = alloca (TARGET_BUF_SIZE);
+      buflen = TARGET_BUF_SIZE;
     }
 
   p = mybuf;
     }
 
   p = mybuf;
@@ -645,11 +674,9 @@ 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)
 {
 {
-  RDEBUG(("MON Expecting prompt\n"))
+  monitor_debug ("MON Expecting prompt\n");
   return monitor_expect (current_monitor->prompt, buf, buflen);
 }
 
   return monitor_expect (current_monitor->prompt, buf, buflen);
 }
 
@@ -658,7 +685,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;
@@ -666,7 +693,7 @@ get_hex_word ()
 
   do
     ch = readchar (timeout);
 
   do
     ch = readchar (timeout);
-  while (isspace(ch));
+  while (isspace (ch));
 
   val = from_hex (ch);
 
 
   val = from_hex (ch);
 
@@ -683,10 +710,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;
@@ -710,10 +735,7 @@ 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;
 {
   char *name;
   char **p;
@@ -740,33 +762,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_FLUSH_INPUT (monitor_desc);
+  serial_raw (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;
 
@@ -777,26 +807,26 @@ monitor_open (args, mon_ops, from_tty)
     {
       monitor_stop ();
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
     {
       monitor_stop ();
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
-        {
-         RDEBUG(("EXP Open echo\n")) ;
-         monitor_expect_prompt (NULL, 0); 
-      }
+       {
+         monitor_debug ("EXP Open echo\n");
+         monitor_expect_prompt (NULL, 0);
+       }
     }
 
   /* wake up the monitor and see if it's alive */
   for (p = mon_ops->init; *p != NULL; p++)
     {
       /* Some of the characters we send may not be echoed,
     }
 
   /* wake up the monitor and see if it's alive */
   for (p = mon_ops->init; *p != NULL; p++)
     {
       /* Some of the characters we send may not be echoed,
-        but we hope to get a prompt at the end of it all. */
-        
+         but we hope to get a prompt at the end of it all. */
+
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
-        monitor_printf(*p); 
+       monitor_printf (*p);
       else
       else
-        monitor_printf_noecho (*p);
+       monitor_printf_noecho (*p);
       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)
@@ -821,16 +851,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 ();
 }
 
@@ -838,16 +864,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;
     }
 
@@ -858,9 +883,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)
@@ -870,16 +893,36 @@ 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)
 {
 {
-  unsigned int val;
-  unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+  ULONGEST val;
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *p;
 
   char *p;
 
-  val = strtoul (valstr, &p, 16);
-  RDEBUG(("Supplying Register %d %s\n",regno,valstr)) ;
+  val = 0;
+  p = valstr;
+  while (p && *p != '\0')
+    {
+      if (*p == '\r' || *p == '\n')
+        {
+          while (*p != '\0') 
+              p++;
+          break;
+        }
+      if (isspace (*p))
+        {
+          p++;
+          continue;
+        }
+      if (!isxdigit (*p) && *p != 'x')
+        {
+          break;
+        }
+
+      val <<= 4;
+      val += fromhex (*p++);
+    }
+  monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 
   if (val == 0 && valstr == p)
     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.",
@@ -896,35 +939,27 @@ monitor_supply_register (regno, valstr)
 
 /* Tell the remote machine to resume.  */
 
 
 /* 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 */
 {
   /* Some monitors require a different command when starting a program */
-  RDEBUG(("MON resume\n")) ;
+  monitor_debug ("MON resume\n");
   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
     {
       first_time = 0;
       monitor_printf ("run\r");
       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
     {
       first_time = 0;
       monitor_printf ("run\r");
       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
-           dump_reg_flag = 1;
+       dump_reg_flag = 1;
       return;
     }
       return;
     }
-  dcache_flush (remote_dcache);
   if (step)
     monitor_printf (current_monitor->step);
   else
     {
       if (current_monitor->continue_hook)
   if (step)
     monitor_printf (current_monitor->step);
   else
     {
       if (current_monitor->continue_hook)
-       (*current_monitor->continue_hook)() ;
-      else monitor_printf (current_monitor->cont);
+       (*current_monitor->continue_hook) ();
+      else
+       monitor_printf (current_monitor->cont);
       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
        dump_reg_flag = 1;
     }
       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
        dump_reg_flag = 1;
     }
@@ -936,17 +971,15 @@ 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)
 {
 {
-  RDEBUG(("MON Parsing  register dump\n")) 
+  monitor_debug ("MON Parsing  register dump\n");
   while (1)
     {
       int regnamelen, vallen;
       char *regname, *val;
       /* Element 0 points to start of register name, and element 1
   while (1)
     {
       int regnamelen, vallen;
       char *regname, *val;
       /* Element 0 points to start of register name, and element 1
-        points to the start of the register value.  */
+         points to the start of the register value.  */
       struct re_registers register_strings;
 
       memset (&register_strings, 0, sizeof (struct re_registers));
       struct re_registers register_strings;
 
       memset (&register_strings, 0, sizeof (struct re_registers));
@@ -971,14 +1004,13 @@ 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);
-  
-  if (remote_debug)
-    printf_unfiltered ("monitor_interrupt called\n");
+
+  if (monitor_debug_p || remote_debug)
+    fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
 
   target_stop ();
 }
 
   target_stop ();
 }
@@ -986,11 +1018,10 @@ 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);
-  
+
   monitor_interrupt_query ();
 
   signal (signo, monitor_interrupt);
   monitor_interrupt_query ();
 
   signal (signo, monitor_interrupt);
@@ -999,7 +1030,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 ();
 
@@ -1007,34 +1038,34 @@ 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);
+      throw_exception (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;
+  timeout = *(int *) old_timeout;
   signal (SIGINT, ofunc);
   in_monitor_wait = 0;
 }
 
 
 
   signal (SIGINT, ofunc);
   in_monitor_wait = 0;
 }
 
 
 
-void monitor_wait_filter(char * buf,
-                        int bufmax,
-                        int * ext_resp_len, 
-                        struct target_waitstatus * status
-                        )
+void
+monitor_wait_filter (char *buf,
+                    int bufmax,
+                    int *ext_resp_len,
+                    struct target_waitstatus *status
+)
 {
 {
-  int resp_len ;
+  int resp_len;
   do
     {
       resp_len = monitor_expect_prompt (buf, bufmax);
   do
     {
       resp_len = monitor_expect_prompt (buf, bufmax);
-      * ext_resp_len =resp_len ;
+      *ext_resp_len = resp_len;
 
       if (resp_len <= 0)
        fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
 
       if (resp_len <= 0)
        fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
@@ -1043,8 +1074,8 @@ void monitor_wait_filter(char * buf,
 
   /* Print any output characters that were preceded by ^O.  */
   /* FIXME - This would be great as a user settabgle flag */
 
   /* Print any output characters that were preceded by ^O.  */
   /* FIXME - This would be great as a user settabgle flag */
-  if (remote_debug ||
-      current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+  if (monitor_debug_p || remote_debug
+      || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
     {
       int i;
 
     {
       int i;
 
@@ -1059,13 +1090,11 @@ void 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;
 {
   int old_timeout = timeout;
-  char buf[1024];
+  char buf[TARGET_BUF_SIZE];
   int resp_len;
   struct cleanup *old_chain;
 
   int resp_len;
   struct cleanup *old_chain;
 
@@ -1073,11 +1102,11 @@ monitor_wait (pid, status)
   status->value.integer = 0;
 
   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
   status->value.integer = 0;
 
   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
-  RDEBUG(("MON wait\n"))
+  monitor_debug ("MON wait\n");
 
 #if 0
 
 #if 0
-    /* This is somthing other than a maintenance command */
-  in_monitor_wait = 1;
+  /* This is somthing other than a maintenance command */
+    in_monitor_wait = 1;
   timeout = watchdog > 0 ? watchdog : -1;
 #else
   timeout = -1;                /* Don't time out -- user program is running. */
   timeout = watchdog > 0 ? watchdog : -1;
 #else
   timeout = -1;                /* Don't time out -- user program is running. */
@@ -1086,10 +1115,11 @@ monitor_wait (pid, status)
   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
 
   if (current_monitor->wait_filter)
   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
 
   if (current_monitor->wait_filter)
-    (*current_monitor->wait_filter)(buf,sizeof (buf),&resp_len,status) ;
-  else          monitor_wait_filter(buf,sizeof (buf),&resp_len,status) ;
-      
-#if 0 /* Transferred to monitor wait filter */
+    (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
+  else
+    monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
+
+#if 0                          /* Transferred to monitor wait filter */
   do
     {
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
   do
     {
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
@@ -1101,8 +1131,8 @@ monitor_wait (pid, status)
 
   /* Print any output characters that were preceded by ^O.  */
   /* FIXME - This would be great as a user settabgle flag */
 
   /* Print any output characters that were preceded by ^O.  */
   /* FIXME - This would be great as a user settabgle flag */
-  if (remote_debug ||
-      current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+  if (monitor_debug_p || remote_debug
+      || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
     {
       int i;
 
     {
       int i;
 
@@ -1110,7 +1140,7 @@ monitor_wait (pid, status)
        if (buf[i] == 0x0f)
          putchar_unfiltered (buf[++i]);
     }
        if (buf[i] == 0x0f)
          putchar_unfiltered (buf[++i]);
     }
-#endif  
+#endif
 
   signal (SIGINT, ofunc);
 
 
   signal (SIGINT, ofunc);
 
@@ -1126,9 +1156,9 @@ monitor_wait (pid, status)
   if (current_monitor->register_pattern)
     parse_register_dump (buf, resp_len);
 #else
   if (current_monitor->register_pattern)
     parse_register_dump (buf, resp_len);
 #else
-  RDEBUG(("Wait fetching registers after stop\n")) ;
-  monitor_dump_regs() ;
-#endif  
+  monitor_debug ("Wait fetching registers after stop\n");
+  monitor_dump_regs ();
+#endif
 
   status->kind = TARGET_WAITKIND_STOPPED;
   status->value.sig = TARGET_SIGNAL_TRAP;
 
   status->kind = TARGET_WAITKIND_STOPPED;
   status->value.sig = TARGET_SIGNAL_TRAP;
@@ -1137,27 +1167,33 @@ 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;
-  static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
-  char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
+  const char *name;
+  char *zerobuf;
+  char *regbuf;
   int i;
 
   int i;
 
-  name = current_monitor->regnames[regno];
-  RDEBUG(("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)")) 
+  regbuf  = alloca (MAX_REGISTER_SIZE * 2 + 1);
+  zerobuf = alloca (MAX_REGISTER_SIZE);
+  memset (zerobuf, 0, MAX_REGISTER_SIZE);
+
+  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'))
     {
 
   if (!name || (*name == '\0'))
     {
-      RDEBUG (("No register known for %d\n", regno))
+      monitor_debug ("No register known for %d\n", regno);
       supply_register (regno, zerobuf);
       return;
     }
       supply_register (regno, zerobuf);
       return;
     }
@@ -1172,18 +1208,19 @@ monitor_fetch_register (regno)
 
   if (current_monitor->getreg.resp_delim)
     {
 
   if (current_monitor->getreg.resp_delim)
     {
-      RDEBUG(("EXP getreg.resp_delim\n")) 
+      monitor_debug ("EXP getreg.resp_delim\n");
       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
       /* Handle case of first 32 registers listed in pairs.  */
       if (current_monitor->flags & MO_32_REGS_PAIRED
          && (regno & 1) != 0 && regno < 32)
       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
       /* Handle case of first 32 registers listed in pairs.  */
       if (current_monitor->flags & MO_32_REGS_PAIRED
          && (regno & 1) != 0 && regno < 32)
-       { RDEBUG(("EXP getreg.resp_delim\n")) ;
+       {
+         monitor_debug ("EXP getreg.resp_delim\n");
          monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
        }
     }
 
   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
          monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
        }
     }
 
   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
-  if (current_monitor->flags & MO_HEX_PREFIX) 
+  if (current_monitor->flags & MO_HEX_PREFIX)
     {
       int c;
       c = readchar (timeout);
     {
       int c;
       c = readchar (timeout);
@@ -1192,8 +1229,8 @@ 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.",
-                regno);
+       error ("Bad value returned from monitor while fetching register %x.",
+              regno);
     }
 
   /* Read upto the maximum number of hex digits for this register, skipping
     }
 
   /* Read upto the maximum number of hex digits for this register, skipping
@@ -1214,7 +1251,7 @@ monitor_fetch_register (regno)
     }
 
   regbuf[i] = '\000';          /* terminate the number */
     }
 
   regbuf[i] = '\000';          /* terminate the number */
-  RDEBUG(("REGVAL '%s'\n",regbuf)) ;
+  monitor_debug ("REGVAL '%s'\n", regbuf);
 
   /* 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
 
   /* 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
@@ -1223,17 +1260,18 @@ monitor_fetch_register (regno)
 
   if (current_monitor->getreg.term)
     {
 
   if (current_monitor->getreg.term)
     {
-      RDEBUG(("EXP getreg.term\n"))
-      monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
+      monitor_debug ("EXP getreg.term\n");
+      monitor_expect (current_monitor->getreg.term, NULL, 0);          /* get response */
     }
 
   if (current_monitor->getreg.term_cmd)
     }
 
   if (current_monitor->getreg.term_cmd)
-    { RDEBUG(("EMIT getreg.term.cmd\n"))
-       monitor_printf (current_monitor->getreg.term_cmd);
+    {
+      monitor_debug ("EMIT getreg.term.cmd\n");
+      monitor_printf (current_monitor->getreg.term_cmd);
     }
     }
-  if (! current_monitor->getreg.term ||    /* Already expected or */
-      current_monitor->getreg.term_cmd)    /* ack expected */
-    monitor_expect_prompt (NULL, 0); /* get response */
+  if (!current_monitor->getreg.term || /* Already expected or */
+      current_monitor->getreg.term_cmd)                /* ack expected */
+    monitor_expect_prompt (NULL, 0);   /* get response */
 
   monitor_supply_register (regno, regbuf);
 }
 
   monitor_supply_register (regno, regbuf);
 }
@@ -1241,15 +1279,16 @@ monitor_fetch_register (regno)
 /* Sometimes, it takes several commands to dump the registers */
 /* This is a primitive for use by variations of monitor interfaces in
    case they need to compose the operation.
 /* Sometimes, it takes several commands to dump the registers */
 /* This is a primitive for use by variations of monitor interfaces in
    case they need to compose the operation.
-   */
-int monitor_dump_reg_block(char * block_cmd)
+ */
+int
+monitor_dump_reg_block (char *block_cmd)
 {
 {
-  char buf[1024];
+  char buf[TARGET_BUF_SIZE];
   int resp_len;
   monitor_printf (block_cmd);
   resp_len = monitor_expect_prompt (buf, sizeof (buf));
   parse_register_dump (buf, resp_len);
   int resp_len;
   monitor_printf (block_cmd);
   resp_len = monitor_expect_prompt (buf, sizeof (buf));
   parse_register_dump (buf, resp_len);
-  return 1 ;
+  return 1;
 }
 
 
 }
 
 
@@ -1257,28 +1296,27 @@ int 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[1024];
+  char buf[TARGET_BUF_SIZE];
   int resp_len;
   if (current_monitor->dumpregs)
   int resp_len;
   if (current_monitor->dumpregs)
-     (*(current_monitor->dumpregs))() ; /* call supplied function */
-  else
-    if (current_monitor->dump_registers) /* default version */
-    { monitor_printf (current_monitor->dump_registers);
+    (*(current_monitor->dumpregs)) (); /* call supplied function */
+  else if (current_monitor->dump_registers)    /* default version */
+    {
+      monitor_printf (current_monitor->dump_registers);
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
       parse_register_dump (buf, resp_len);
     }
   else
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
       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)
 {
 {
-  RDEBUG(("MON fetchregs\n")) ;
-  if (current_monitor->getreg.cmd) 
+  monitor_debug ("MON fetchregs\n");
+  if (current_monitor->getreg.cmd)
     {
       if (regno >= 0)
        {
     {
       if (regno >= 0)
        {
@@ -1289,28 +1327,34 @@ monitor_fetch_registers (regno)
       for (regno = 0; regno < NUM_REGS; regno++)
        monitor_fetch_register (regno);
     }
       for (regno = 0; regno < NUM_REGS; regno++)
        monitor_fetch_register (regno);
     }
-  else {
-    monitor_dump_regs ();
-  }
+  else
+    {
+      monitor_dump_regs ();
+    }
 }
 
 /* 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;
-  unsigned int val;
-
-  name = current_monitor->regnames[regno];
+  const char *name;
+  ULONGEST val;
+  
+  if (current_monitor->regname != NULL)
+    name = current_monitor->regname (regno);
+  else
+    name = current_monitor->regnames[regno];
+  
   if (!name || (*name == '\0'))
   if (!name || (*name == '\0'))
-    { RDEBUG(("MON Cannot store unknown register\n"))
+    {
+      monitor_debug ("MON Cannot store unknown register\n");
       return;
     }
 
   val = read_register (regno);
       return;
     }
 
   val = read_register (regno);
-  RDEBUG(("MON storeg %d %08x\n",regno,(unsigned int)val))
+  monitor_debug ("MON storeg %d %s\n", regno,
+                phex (val, REGISTER_RAW_SIZE (regno)));
 
   /* send the register deposit command */
 
 
   /* send the register deposit command */
 
@@ -1321,27 +1365,35 @@ 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)
   if (current_monitor->setreg.term)
-    { RDEBUG(("EXP setreg.term\n"))
+    {
+      monitor_debug ("EXP setreg.term\n");
       monitor_expect (current_monitor->setreg.term, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
       monitor_expect (current_monitor->setreg.term, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-       monitor_printf ("%x\r", val);
+       monitor_printf ("%s\r", paddr_nz (val));
       monitor_expect_prompt (NULL, 0);
     }
   else
     monitor_expect_prompt (NULL, 0);
       monitor_expect_prompt (NULL, 0);
     }
   else
     monitor_expect_prompt (NULL, 0);
-  if (current_monitor->setreg.term_cmd) /* Mode exit required */
-    { RDEBUG(("EXP setreg_termcmd\n")) ;
-      monitor_printf("%s",current_monitor->setreg.term_cmd) ;
-      monitor_expect_prompt(NULL,0) ;
+  if (current_monitor->setreg.term_cmd)                /* Mode exit required */
+    {
+      monitor_debug ("EXP setreg_termcmd\n");
+      monitor_printf ("%s", current_monitor->setreg.term_cmd);
+      monitor_expect_prompt (NULL, 0);
     }
     }
-} /* monitor_store_register */
+}                              /* monitor_store_register */
 
 /* 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)
     {
@@ -1360,29 +1412,25 @@ 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 ;
+  unsigned int val, hostval;
   char *cmd;
   int i;
 
   char *cmd;
   int i;
 
-  RDEBUG(("MON write %d %08x\n",len,(unsigned long)memaddr))
+  monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
@@ -1397,11 +1445,11 @@ monitor_write_memory (memaddr, myaddr, len)
 
       if (i > 4)               /* More than 4 zeros is worth doing */
        {
 
       if (i > 4)               /* More than 4 zeros is worth doing */
        {
-         RDEBUG(("MON FILL %d\n",i))
-           if (current_monitor->flags & MO_FILL_USES_ADDR)
-             monitor_printf (current_monitor->fill, memaddr, (memaddr + i)-1, 0);
-           else
-             monitor_printf (current_monitor->fill, memaddr, i, 0);
+         monitor_debug ("MON FILL %d\n", i);
+         if (current_monitor->flags & MO_FILL_USES_ADDR)
+           monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
+         else
+           monitor_printf (current_monitor->fill, memaddr, i, 0);
 
          monitor_expect_prompt (NULL, 0);
 
 
          monitor_expect_prompt (NULL, 0);
 
@@ -1435,10 +1483,11 @@ monitor_write_memory (memaddr, myaddr, len)
     }
 
   val = extract_unsigned_integer (myaddr, len);
     }
 
   val = extract_unsigned_integer (myaddr, len);
-  
+
   if (len == 4)
   if (len == 4)
-    { hostval = * (unsigned int *) myaddr ;
-      RDEBUG(("Hostval(%08x) val(%08x)\n",hostval,val)) ;
+    {
+      hostval = *(unsigned int *) myaddr;
+      monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
     }
 
 
     }
 
 
@@ -1449,14 +1498,21 @@ 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)
       if (current_monitor->setmem.term)
-       { RDEBUG(("EXP setmem.term")) ;
+       {
+         monitor_debug ("EXP setmem.term");
          monitor_expect (current_monitor->setmem.term, NULL, 0);
          monitor_printf ("%x\r", val);
        }
       if (current_monitor->setmem.term_cmd)
          monitor_expect (current_monitor->setmem.term, NULL, 0);
          monitor_printf ("%x\r", val);
        }
       if (current_monitor->setmem.term_cmd)
-       { /* Emit this to get out of the memory editing state */
-         monitor_printf("%s",current_monitor->setmem.term_cmd) ;
+       {                       /* Emit this to get out of the memory editing state */
+         monitor_printf ("%s", current_monitor->setmem.term_cmd);
          /* Drop through to expecting a prompt */
        }
     }
          /* Drop through to expecting a prompt */
        }
     }
@@ -1470,150 +1526,155 @@ monitor_write_memory (memaddr, myaddr, len)
 
 
 static int
 
 
 static int
-monitor_write_even_block(memaddr,myaddr,len)
-     CORE_ADDR memaddr ;
-     char * myaddr ;
-     int len ;
+monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len)
 {
 {
-  unsigned int val ;
-  int written = 0 ;;
+  unsigned int val;
+  int written = 0;;
   /* Enter the sub mode */
   /* Enter the sub mode */
-  monitor_printf(current_monitor->setmem.cmdl,memaddr) ;
-  monitor_expect_prompt(NULL,0) ;
- 
+  monitor_printf (current_monitor->setmem.cmdl, memaddr);
+  monitor_expect_prompt (NULL, 0);
+
   while (len)
     {
   while (len)
     {
-      val = extract_unsigned_integer(myaddr,4) ; /* REALLY */
-      monitor_printf("%x\r",val) ;
-      myaddr += 4 ;
-      memaddr += 4 ;
-      written += 4 ;
-      RDEBUG((" @ %08x\n",memaddr))
+      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 */
       /* If we wanted to, here we could validate the address */
-      monitor_expect_prompt(NULL,0) ;
+      monitor_expect_prompt (NULL, 0);
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt(NULL,0) ;
-  return written ;
+  monitor_expect_prompt (NULL, 0);
+  return written;
 }
 
 
 }
 
 
-static int monitor_write_memory_bytes(memaddr,myaddr,len)
-     CORE_ADDR memaddr ;
-     char * myaddr ;
-     int len ;
+static int
+monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
 {
 {
-  unsigned char val ;
-  int written = 0 ;
-  if (len == 0) return 0 ;
+  unsigned char val;
+  int written = 0;
+  if (len == 0)
+    return 0;
   /* Enter the sub mode */
   /* Enter the sub mode */
-  monitor_printf(current_monitor->setmem.cmdb,memaddr) ;
-  monitor_expect_prompt(NULL,0) ;
+  monitor_printf (current_monitor->setmem.cmdb, memaddr);
+  monitor_expect_prompt (NULL, 0);
   while (len)
     {
   while (len)
     {
-      val = *myaddr ;
-      monitor_printf("%x\r",val) ;
-      myaddr++ ;
-      memaddr++ ;
-      written++ ;
+      val = *myaddr;
+      monitor_printf ("%x\r", val);
+      myaddr++;
+      memaddr++;
+      written++;
       /* If we wanted to, here we could validate the address */
       /* If we wanted to, here we could validate the address */
-      monitor_expect_prompt(NULL,0) ;
-      len-- ;
+      monitor_expect_prompt (NULL, 0);
+      len--;
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt(NULL,0) ;
-  return written ;
+  monitor_expect_prompt (NULL, 0);
+  return written;
 }
 
 
 static void
 }
 
 
 static void
-longlongendswap (unsigned char * a)
+longlongendswap (unsigned char *a)
 {
 {
-  int i,j ;
-  unsigned char x ;
-  i = 0 ; j = 7 ;
+  int i, j;
+  unsigned char x;
+  i = 0;
+  j = 7;
   while (i < 4)
   while (i < 4)
-    { x = *(a+i) ;
-      *(a+i) = *(a+j) ;
-      *(a+j) = x ;
-      i++ , j-- ;
+    {
+      x = *(a + i);
+      *(a + i) = *(a + j);
+      *(a + j) = x;
+      i++, j--;
     }
 }
 /* Format 32 chars of long long value, advance the pointer */
     }
 }
 /* Format 32 chars of long long value, advance the pointer */
-static char * hexlate = "0123456789abcdef" ;
-static char * longlong_hexchars(unsigned long long value,
-                                char * outbuff )
+static char *hexlate = "0123456789abcdef";
+static char *
+longlong_hexchars (unsigned long long value,
+                  char *outbuff)
 {
 {
-  if (value == 0) { *outbuff++ = '0' ; return outbuff ; }
+  if (value == 0)
+    {
+      *outbuff++ = '0';
+      return outbuff;
+    }
   else
   else
-    { static unsigned char disbuf[8] ; /* disassembly buffer */
-      unsigned char * scan , * limit ; /* loop controls */
-      unsigned char c , nib ;
-      int leadzero = 1 ;
-      scan = disbuf ; limit = scan + 8 ;
-      { unsigned long long * dp ;
-       dp = (unsigned long long *) scan ;
-       *dp = value ;
+    {
+      static unsigned char disbuf[8];  /* disassembly buffer */
+      unsigned char *scan, *limit;     /* loop controls */
+      unsigned char c, nib;
+      int leadzero = 1;
+      scan = disbuf;
+      limit = scan + 8;
+      {
+       unsigned long long *dp;
+       dp = (unsigned long long *) scan;
+       *dp = value;
       }
       }
-      longlongendswap(disbuf) ; /* FIXME: ONly on big endian hosts */
+      longlongendswap (disbuf);        /* FIXME: ONly on big endian hosts */
       while (scan < limit)
        {
       while (scan < limit)
        {
-         c = *scan++; /* a byte of our long long value */
+         c = *scan++;          /* a byte of our long long value */
          if (leadzero)
            {
              if (c == 0)
                continue;
              else
          if (leadzero)
            {
              if (c == 0)
                continue;
              else
-               leadzero = 0; /* henceforth we print even zeroes */
+               leadzero = 0;   /* henceforth we print even zeroes */
            }
            }
-         nib = c >> 4;        /* high nibble bits */
+         nib = c >> 4;         /* high nibble bits */
          *outbuff++ = hexlate[nib];
          *outbuff++ = hexlate[nib];
-         nib = c & 0x0f;      /* low nibble bits */
+         nib = c & 0x0f;       /* low nibble bits */
          *outbuff++ = hexlate[nib];
        }
          *outbuff++ = hexlate[nib];
        }
-      return outbuff ;
+      return outbuff;
     }
     }
-} /* longlong_hexchars */
+}                              /* longlong_hexchars */
 
 
 
 /* I am only going to call this when writing virtual byte streams.
    Which possably entails endian conversions
 
 
 
 /* I am only going to call this when writing virtual byte streams.
    Which possably entails endian conversions
-   */
-static int monitor_write_memory_longlongs(memaddr,myaddr,len)
-     CORE_ADDR memaddr ;
-     char * myaddr ;
-     int len ;
+ */
+static int
+monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
 {
 {
-  static char hexstage[20] ; /* At least 16 digits required, plus null */
-  char * endstring ;
-  long long * llptr ;
-  long long value ;
-  int written = 0 ;
-  llptr = (unsigned long long *) myaddr ;
-  if (len == 0 ) return 0 ;
-  monitor_printf(current_monitor->setmem.cmdll,memaddr) ;
-  monitor_expect_prompt(NULL,0) ;
-  while (len >= 8 )
-    {
-      value = *llptr ;
-      endstring = longlong_hexchars(*llptr,hexstage) ;
-      *endstring = '\0' ; /* NUll terminate for printf */
-      monitor_printf("%s\r",hexstage) ;
-      llptr++ ;
-      memaddr += 8 ;
-      written += 8 ;
+  static char hexstage[20];    /* At least 16 digits required, plus null */
+  char *endstring;
+  long long *llptr;
+  long long value;
+  int written = 0;
+  llptr = (unsigned long long *) myaddr;
+  if (len == 0)
+    return 0;
+  monitor_printf (current_monitor->setmem.cmdll, memaddr);
+  monitor_expect_prompt (NULL, 0);
+  while (len >= 8)
+    {
+      value = *llptr;
+      endstring = longlong_hexchars (*llptr, hexstage);
+      *endstring = '\0';       /* NUll terminate for printf */
+      monitor_printf ("%s\r", hexstage);
+      llptr++;
+      memaddr += 8;
+      written += 8;
       /* If we wanted to, here we could validate the address */
       /* If we wanted to, here we could validate the address */
-      monitor_expect_prompt(NULL,0) ;
-      len -= 8 ;
+      monitor_expect_prompt (NULL, 0);
+      len -= 8;
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
     }
   /* Now exit the sub mode */
   monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt(NULL,0) ;
-  return written ;
-} /* */
+  monitor_expect_prompt (NULL, 0);
+  return written;
+}                              /* */
 
 
 
 
 
 
@@ -1624,58 +1685,52 @@ static int monitor_write_memory_longlongs(memaddr,myaddr,len)
    Without this, we will end up calling monitor_write_memory many times
    and do the entry and exit of the sub mode many times
    This currently assumes...
    Without this, we will end up calling monitor_write_memory many times
    and do the entry and exit of the sub mode many times
    This currently assumes...
-     MO_SETMEM_INTERACTIVE
-     ! MO_NO_ECHO_ON_SETMEM
-     To use this, the you have to patch the monitor_cmds block with
-     this function. Otherwise, its not tuned up for use by all
-     monitor variations.
-   */
+   MO_SETMEM_INTERACTIVE
+   ! MO_NO_ECHO_ON_SETMEM
+   To use this, the you have to patch the monitor_cmds block with
+   this function. Otherwise, its not tuned up for use by all
+   monitor variations.
+ */
 
 
-static int monitor_write_memory_block(memaddr,myaddr,len)
-     CORE_ADDR memaddr ;
-     char * myaddr ;
-     int len ;
+static int
+monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
 {
 {
-  int written ;
-  written = 0 ;
+  int written;
+  written = 0;
   /* FIXME: This would be a good place to put the zero test */
   /* FIXME: This would be a good place to put the zero test */
-#if 1 
+#if 1
   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
-       {
-        return monitor_write_memory_longlongs(memaddr,myaddr,len) ;
-       }
-#endif  
-#if 0 
+    {
+      return monitor_write_memory_longlongs (memaddr, myaddr, len);
+    }
+#endif
+#if 0
   if (len > 4)
     {
   if (len > 4)
     {
-      int sublen ;
-      written = monitor_write_even_block(memaddr,myaddr,len) ;
+      int sublen;
+      written = monitor_write_even_block (memaddr, myaddr, len);
       /* Adjust calling parameters by written amount */
       /* Adjust calling parameters by written amount */
-      memaddr += written ;
-      myaddr += written ;
-      len -= written ;
+      memaddr += written;
+      myaddr += written;
+      len -= written;
     }
 #endif
     }
 #endif
-  written = monitor_write_memory_bytes(memaddr,myaddr,len) ;
-  return written ;
+  written = monitor_write_memory_bytes (memaddr, myaddr, len);
+  return written;
 }
 
 /* This is an alternate form of monitor_read_memory which is used for monitors
    which can only read a single byte/word/etc. at a time.  */
 
 static int
 }
 
 /* This is an alternate form of monitor_read_memory which is used for monitors
    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;
 {
   unsigned int val;
-  char membuf[sizeof(int) * 2 + 1];
+  char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;
   char *p;
   char *cmd;
-  int i;
 
 
-  RDEBUG(("MON read single\n")) ;
+  monitor_debug ("MON read single\n");
 #if 0
   /* Can't actually use long longs (nice idea, though).  In fact, the
      call to strtoul below will fail if it tries to convert a value
 #if 0
   /* Can't actually use long longs (nice idea, though).  In fact, the
      call to strtoul below will fail if it tries to convert a value
@@ -1712,7 +1767,8 @@ monitor_read_memory_single (memaddr, myaddr, len)
      searching from the start of the buf.  */
 
   if (current_monitor->getmem.resp_delim)
      searching from the start of the buf.  */
 
   if (current_monitor->getmem.resp_delim)
-    { RDEBUG(("EXP getmem.resp_delim\n")) ;
+    {
+      monitor_debug ("EXP getmem.resp_delim\n");
       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
     }
 
       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
     }
 
@@ -1720,7 +1776,7 @@ monitor_read_memory_single (memaddr, myaddr, len)
      skipping spaces.  */
 
   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
      skipping spaces.  */
 
   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
-  if (current_monitor->flags & MO_HEX_PREFIX) 
+  if (current_monitor->flags & MO_HEX_PREFIX)
     {
       int c;
 
     {
       int c;
 
@@ -1730,29 +1786,33 @@ monitor_read_memory_single (memaddr, myaddr, len)
       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
        ;
       else
       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
        ;
       else
-       monitor_error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
-                      memaddr, i, membuf, c);
+       monitor_error ("monitor_read_memory_single", 
+                      "bad response from monitor",
+                      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 (0x%x):  bad response from monitor: %.*s%c.",
-                        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
@@ -1760,7 +1820,7 @@ monitor_read_memory_single (memaddr, myaddr, len)
 
   if (current_monitor->getmem.term)
     {
 
   if (current_monitor->getmem.term)
     {
-      monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
+      monitor_expect (current_monitor->getmem.term, NULL, 0);  /* get response */
 
       if (current_monitor->getmem.term_cmd)
        {
 
       if (current_monitor->getmem.term_cmd)
        {
@@ -1769,13 +1829,14 @@ monitor_read_memory_single (memaddr, myaddr, len)
        }
     }
   else
        }
     }
   else
-    monitor_expect_prompt (NULL, 0); /* get response */
+    monitor_expect_prompt (NULL, 0);   /* get response */
 
   p = membuf;
   val = strtoul (membuf, &p, 16);
 
   if (val == 0 && membuf == p)
 
   p = membuf;
   val = strtoul (membuf, &p, 16);
 
   if (val == 0 && membuf == p)
-    monitor_error ("monitor_read_memory_single (0x%x):  bad value from monitor: %s.",
+    monitor_error ("monitor_read_memory_single",
+                  "bad value from monitor",
                   memaddr, 0, membuf, 0);
 
   /* supply register stores in target byte order, so swap here */
                   memaddr, 0, membuf, 0);
 
   /* supply register stores in target byte order, so swap here */
@@ -1790,10 +1851,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];
@@ -1804,12 +1862,12 @@ monitor_read_memory (memaddr, myaddr, len)
 
   if (len <= 0)
     {
 
   if (len <= 0)
     {
-      RDEBUG (("Zero length call to monitor_read_memory\n"));
+      monitor_debug ("Zero length call to monitor_read_memory\n");
       return 0;
     }
 
       return 0;
     }
 
-  if (remote_debug) printf("MON read block ta(%08x) ha(%08x) %d\n",
-         (unsigned long) memaddr , (unsigned long)myaddr, len);
+  monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
+                paddr_nz (memaddr), (long) myaddr, len);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
@@ -1822,10 +1880,10 @@ monitor_read_memory (memaddr, myaddr, len)
   /* Some dumpers align the first data with the preceeding 16
      byte boundary. Some print blanks and start at the
      requested boundary. EXACT_DUMPADDR
   /* Some dumpers align the first data with the preceeding 16
      byte boundary. Some print blanks and start at the
      requested boundary. EXACT_DUMPADDR
-     */
+   */
 
   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
 
   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
-    ? memaddr : memaddr & ~ 0x0f ;
+    ? memaddr : memaddr & ~0x0f;
 
   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
 
   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
@@ -1847,21 +1905,22 @@ monitor_read_memory (memaddr, myaddr, len)
 
   if (current_monitor->getmem.term)
     {
 
   if (current_monitor->getmem.term)
     {
-      resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
+      resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf);       /* get response */
 
       if (resp_len <= 0)
 
       if (resp_len <= 0)
-       monitor_error ("monitor_read_memory (0x%x):  excessive response from monitor: %.*s.",
+       monitor_error ("monitor_read_memory",
+                      "excessive response from monitor",
                       memaddr, resp_len, buf, 0);
 
       if (current_monitor->getmem.term_cmd)
        {
                       memaddr, resp_len, buf, 0);
 
       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);
        }
     }
   else
                        strlen (current_monitor->getmem.term_cmd));
          monitor_expect_prompt (NULL, 0);
        }
     }
   else
-    resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
+    resp_len = monitor_expect_prompt (buf, sizeof buf);                /* get response */
 
   p = buf;
 
 
   p = buf;
 
@@ -1873,7 +1932,7 @@ monitor_read_memory (memaddr, myaddr, len)
     {
       int retval, tmp;
       struct re_registers resp_strings;
     {
       int retval, tmp;
       struct re_registers resp_strings;
-      RDEBUG(("MON getmem.resp_delim %s\n",current_monitor->getmem.resp_delim)) ;
+      monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
 
       memset (&resp_strings, 0, sizeof (struct re_registers));
       tmp = strlen (p);
 
       memset (&resp_strings, 0, sizeof (struct re_registers));
       tmp = strlen (p);
@@ -1881,47 +1940,55 @@ monitor_read_memory (memaddr, myaddr, len)
                          &resp_strings);
 
       if (retval < 0)
                          &resp_strings);
 
       if (retval < 0)
-       monitor_error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
+       monitor_error ("monitor_read_memory",
+                      "bad response from monitor",
                       memaddr, resp_len, buf, 0);
 
       p += resp_strings.end[0];
 #if 0
       p = strstr (p, current_monitor->getmem.resp_delim);
       if (!p)
                       memaddr, resp_len, buf, 0);
 
       p += resp_strings.end[0];
 #if 0
       p = strstr (p, current_monitor->getmem.resp_delim);
       if (!p)
-       monitor_error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
+       monitor_error ("monitor_read_memory",
+                      "bad response from monitor",
                       memaddr, resp_len, buf, 0);
       p += strlen (current_monitor->getmem.resp_delim);
 #endif
     }
                       memaddr, resp_len, buf, 0);
       p += strlen (current_monitor->getmem.resp_delim);
 #endif
     }
-  if (remote_debug) printf("MON scanning  %d ,%08x '%s'\n",len,p,p) ;
+  monitor_debug ("MON scanning  %d ,%lx '%s'\n", len, (long) p, p);
   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
     {
   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
     {
-      char c ;
-      int fetched = 0 ;
+      char c;
+      int fetched = 0;
       i = len;
       i = len;
-      c = *p ;
+      c = *p;
 
 
-                           
-      while (!(c  == '\000' || c == '\n' || c == '\r') && i > 0)
-       { if (isxdigit (c))
-           { if ((dumpaddr >= memaddr) && (i > 0))
-               { val = fromhex (c) * 16 + fromhex (*(p+1));
+
+      while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
+       {
+         if (isxdigit (c))
+           {
+             if ((dumpaddr >= memaddr) && (i > 0))
+               {
+                 val = fromhex (c) * 16 + fromhex (*(p + 1));
                  *myaddr++ = val;
                  *myaddr++ = val;
-                 if (remote_debug) printf("[%02x]",val) ;
+                 if (monitor_debug_p || remote_debug)
+                   fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
                  --i;
                  --i;
-                 fetched++ ;
+                 fetched++;
                }
              ++dumpaddr;
              ++p;
            }
                }
              ++dumpaddr;
              ++p;
            }
-         ++p; /* skip a blank or other non hex char */
-         c = *p ;
+         ++p;                  /* skip a blank or other non hex char */
+         c = *p;
        }
        }
-      if (fetched == 0) error("Failed to read via monitor") ;
-      if (remote_debug) printf("\n") ;
-      return fetched ; /* Return the number of bytes actually read */
+      if (fetched == 0)
+       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 */
     }
     }
-  RDEBUG(("MON scanning bytes\n")) ;
+  monitor_debug ("MON scanning bytes\n");
 
   for (i = len; i > 0; i--)
     {
 
   for (i = len; i > 0; i--)
     {
@@ -1933,7 +2000,8 @@ monitor_read_memory (memaddr, myaddr, len)
            break;
 
          if (*p == '\000' || *p == '\n' || *p == '\r')
            break;
 
          if (*p == '\000' || *p == '\n' || *p == '\r')
-           monitor_error ("monitor_read_memory (0x%x):  badly terminated response from monitor: %.*s",
+           monitor_error ("monitor_read_memory",
+                          "badly terminated response from monitor",
                           memaddr, resp_len, buf, 0);
          p++;
        }
                           memaddr, resp_len, buf, 0);
          p++;
        }
@@ -1941,7 +2009,8 @@ monitor_read_memory (memaddr, myaddr, len)
       val = strtoul (p, &p1, 16);
 
       if (val == 0 && p == p1)
       val = strtoul (p, &p1, 16);
 
       if (val == 0 && p == p1)
-       monitor_error ("monitor_read_memory (0x%x):  bad value from monitor: %.*s.",
+       monitor_error ("monitor_read_memory",
+                      "bad value from monitor",
                       memaddr, resp_len, buf, 0);
 
       *myaddr++ = val;
                       memaddr, resp_len, buf, 0);
 
       *myaddr++ = val;
@@ -1955,31 +2024,42 @@ 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 */
 }
 
 /* All we actually do is set the PC to the start address of exec_bfd, and start
    the program at that point.  */
 
 static void
 }
 
 /* All we actually do is set the PC to the start address of exec_bfd, and start
    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)
 {
   if (args && (*args != '\000'))
     error ("Args are not supported by the monitor.");
 {
   if (args && (*args != '\000'))
     error ("Args are not supported by the monitor.");
@@ -1995,7 +2075,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 */
@@ -2004,15 +2084,13 @@ 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;
 
   int bplen;
 
-  RDEBUG(("MON inst bkpt %08x\n",addr)) 
+  monitor_debug ("MON inst bkpt %s\n", paddr (addr));
   if (current_monitor->set_break == NULL)
     error ("No set_break defined for this monitor");
 
   if (current_monitor->set_break == NULL)
     error ("No set_break defined for this monitor");
 
@@ -2020,7 +2098,7 @@ monitor_insert_breakpoint (addr, 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++)
     {
@@ -2040,13 +2118,11 @@ monitor_insert_breakpoint (addr, shadow)
 /* 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;
 
 {
   int i;
 
-  RDEBUG(("MON rmbkpt %08x\n",addr))
+  monitor_debug ("MON rmbkpt %s\n", paddr (addr));
   if (current_monitor->clr_break == NULL)
     error ("No clr_break defined for this monitor");
 
   if (current_monitor->clr_break == NULL)
     error ("No clr_break defined for this monitor");
 
@@ -2070,7 +2146,8 @@ monitor_remove_breakpoint (addr, shadow)
        }
     }
   fprintf_unfiltered (gdb_stderr,
        }
     }
   fprintf_unfiltered (gdb_stderr,
-                     "Can't find breakpoint associated with 0x%x\n", addr);
+                     "Can't find breakpoint associated with 0x%s\n",
+                     paddr_nz (addr));
   return 1;
 }
 
   return 1;
 }
 
@@ -2078,9 +2155,9 @@ 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 i, ch;
+  int ch;
 
   if (current_monitor->flags & MO_SREC_ACK_PLUS)
     {
 
   if (current_monitor->flags & MO_SREC_ACK_PLUS)
     {
@@ -2104,12 +2181,9 @@ 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);
-  RDEBUG(("MON load\n"))
+  monitor_debug ("MON load\n");
 
   if (current_monitor->load_routine)
     current_monitor->load_routine (monitor_desc, file, hashmark);
 
   if (current_monitor->load_routine)
     current_monitor->load_routine (monitor_desc, file, hashmark);
@@ -2133,45 +2207,47 @@ monitor_load (file, from_tty)
       load_srec (monitor_desc, file, (bfd_vma) load_offset,
                 32, SREC_ALL, hashmark,
                 current_monitor->flags & MO_SREC_ACK ?
       load_srec (monitor_desc, file, (bfd_vma) load_offset,
                 32, SREC_ALL, hashmark,
                 current_monitor->flags & MO_SREC_ACK ?
-                  monitor_wait_srec_ack : NULL);
+                monitor_wait_srec_ack : NULL);
 
       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)
 {
 {
-  RDEBUG(("MON stop\n")) ;
+  monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
   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);
 }
 
-/* Put a command string, in args, out to MONITOR.  Output from MONITOR
-   is placed on the users terminal until the prompt is seen. FIXME: We
-   read the characters ourseleves here cause of a nasty echo.  */
+/* Put a COMMAND string out to MONITOR.  Output from MONITOR is placed
+   in OUTPUT until the prompt is seen. FIXME: We read the characters
+   ourseleves here cause of a nasty echo.  */
 
 static void
 
 static void
-monitor_command (args, from_tty)
-     char *args;
-     int from_tty;
+monitor_rcmd (char *command,
+             struct ui_file *outbuf)
 {
   char *p;
   int resp_len;
 {
   char *p;
   int resp_len;
@@ -2185,20 +2261,19 @@ monitor_command (args, from_tty)
   /* Send the command.  Note that if no args were supplied, then we're
      just sending the monitor a newline, which is sometimes useful.  */
 
   /* Send the command.  Note that if no args were supplied, then we're
      just sending the monitor a newline, which is sometimes useful.  */
 
-  monitor_printf ("%s\r", (args ? args : ""));
+  monitor_printf ("%s\r", (command ? command : ""));
 
   resp_len = monitor_expect_prompt (buf, sizeof buf);
 
 
   resp_len = monitor_expect_prompt (buf, sizeof buf);
 
-  fputs_unfiltered (buf, gdb_stdout); /* Output the response */
+  fputs_unfiltered (buf, outbuf);      /* Output the response */
 }
 
 /* Convert hex digit A to a number.  */
 
 #if 0
 static int
 }
 
 /* Convert hex digit A to a number.  */
 
 #if 0
 static int
-from_hex (a)
-     int a;
-{  
+from_hex (int a)
+{
   if (a >= '0' && a <= '9')
     return a - '0';
   if (a >= 'a' && a <= 'f')
   if (a >= '0' && a <= '9')
     return a - '0';
   if (a >= 'a' && a <= 'f')
@@ -2211,7 +2286,7 @@ from_hex (a)
 #endif
 
 char *
 #endif
 
 char *
-monitor_get_dev_name ()
+monitor_get_dev_name (void)
 {
   return dev_name;
 }
 {
   return dev_name;
 }
@@ -2221,19 +2296,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;
@@ -2241,56 +2307,25 @@ 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_stop = monitor_stop;
-  monitor_ops.to_pid_to_exec_file = NULL;
-  monitor_ops.to_core_file_to_sym_file = NULL;
+  monitor_ops.to_rcmd = monitor_rcmd;
   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;
   monitor_ops.to_magic = OPS_MAGIC;
-} /* init_base_monitor_ops */
+}                              /* init_base_monitor_ops */
 
 /* Init the target_ops structure pointed at by OPS */
 
 void
 
 /* 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 ();
@@ -2301,18 +2336,21 @@ init_monitor_ops (ops)
 /* Define additional commands that are usually only used by monitors.  */
 
 void
 /* Define additional commands that are usually only used by monitors.  */
 
 void
-_initialize_remote_monitors ()
+_initialize_remote_monitors (void)
 {
   init_base_monitor_ops ();
   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
 {
   init_base_monitor_ops ();
   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
-                                  (char *)&hashmark,
+                                 (char *) &hashmark,
                                  "Set display of activity while downloading a file.\n\
 When enabled, a hashmark \'#\' is displayed.",
                                  "Set display of activity while downloading a file.\n\
 When enabled, a hashmark \'#\' is displayed.",
-                                  &setlist),
+                                 &setlist),
                     &showlist);
 
                     &showlist);
 
-  add_com ("monitor", class_obscure, monitor_command,
-          "Send a command to the debug monitor."); 
+  add_show_from_set
+    (add_set_cmd ("monitor", no_class, var_zinteger,
+                 (char *) &monitor_debug_p,
+                 "Set debugging of remote monitor communication.\n\
+When enabled, communication between GDB and the remote monitor\n\
+is displayed.", &setdebuglist),
+     &showdebuglist);
 }
 }
-
-
GDB Binutils - Deliverables
This page took 0.056991 seconds and 4 git commands to generate.