2009-07-07 Tristan Gingold <gingold@adacore.com>

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

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

-   Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
+
+   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001, 2002, 2006, 2007, 2008, 2009 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.
 


@@ -7,7 +10,7 @@
 
    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
 
    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
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +19,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

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


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

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

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


@@ -52,53 +53,20 @@
 #include "inferior.h"
 #include "gdb_regex.h"
 #include "srec.h"
 #include "inferior.h"
 #include "gdb_regex.h"
 #include "srec.h"

+#include "regcache.h"
+#include "gdbthread.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 (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 (int pid, 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_interrupt_query (void);

-static void monitor_wait_cleanup (void *old_timeout);
-
-static int monitor_wait (int pid, 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 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);
+static void monitor_interrupt_twice (int);
+static void monitor_stop (ptid_t);
+static void monitor_dump_regs (struct regcache *regcache);
+

 #if 0
 static int from_hex (int a);
 #if 0
 static int from_hex (int a);

-static unsigned long get_hex_word (void);

 #endif
 #endif

-static void parse_register_dump (char *, int);

 
 static struct monitor_ops *current_monitor;
 
 
 static struct monitor_ops *current_monitor;
 


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

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

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


@@ -126,12 +94,25 @@ 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 first_time = 0;     /* is this the first time we're executing after 
                                   gaving created the child proccess? */
 
 static int dump_reg_flag;      /* Non-zero means do a dump_registers cmd when
                                   monitor_wait wakes up.  */
 
 static int first_time = 0;     /* is this the first time we're executing after 
                                   gaving created the child proccess? */
 

+
+/* This is the ptid we use while we're connected to a monitor.  Its
+   value is arbitrary, as monitor targets don't have a notion of
+   processes or threads, but we need something non-null to place in
+   inferior_ptid.  */
+static ptid_t monitor_ptid;
+

 #define TARGET_BUF_SIZE 2048
 
 /* Monitor specific debugging information.  Typically only useful to
 #define TARGET_BUF_SIZE 2048
 
 /* Monitor specific debugging information.  Typically only useful to


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

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

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


@@ -233,9 +214,13 @@ monitor_error (char *function, char *message,
   monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)
   monitor_printable_string (safe_string, string, real_len);
 
   if (final_char)

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

   else
   else

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

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


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

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

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


@@ -270,6 +255,7 @@ fromhex (int a)
 static void
 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
 {
 static void
 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
 {

+  int addr_bit = gdbarch_addr_bit (target_gdbarch);

   char format[10];
   char fmt;
   char *p;
   char format[10];
   char fmt;
   char *p;


@@ -298,7 +284,7 @@ monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
              break;
            case 'A':
              arg_addr = va_arg (args, CORE_ADDR);
              break;
            case 'A':
              arg_addr = va_arg (args, CORE_ADDR);

-             strcpy (sndbuf, paddr_nz (arg_addr));
+             strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));

              break;
            case 's':
              arg_string = va_arg (args, char *);
              break;
            case 's':
              arg_string = va_arg (args, char *);


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

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

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


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

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

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


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

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

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


@@ -406,7 +392,7 @@ monitor_readchar (void)
   do
     {
       looping = 0;
   do
     {
       looping = 0;

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

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


@@ -417,9 +403,9 @@ monitor_readchar (void)
     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"));

 }
 
 
 }
 
 


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

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

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


@@ -488,13 +474,13 @@ readchar (int timeout)
     if (in_monitor_wait)       /* Watchdog went off */
       {
        target_mourn_inferior ();
     if (in_monitor_wait)       /* Watchdog went off */
       {
        target_mourn_inferior ();

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

       }
     else
 #endif
       }
     else
 #endif

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

 
 

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

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


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

-  extern struct target_ops *targ_ops;

 
   if (monitor_debug_p)
     {
 
   if (monitor_debug_p)
     {


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

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

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


@@ -712,7 +691,7 @@ compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
   re_set_syntax (tmp);
 
   if (val)
   re_set_syntax (tmp);
 
   if (val)

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

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


@@ -728,14 +707,14 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
   char **p;
 
   if (mon_ops->magic != MONITOR_OPS_MAGIC)
   char **p;
 
   if (mon_ops->magic != MONITOR_OPS_MAGIC)

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

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

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

 
   target_preopen (from_tty);
 
 
   target_preopen (from_tty);
 


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

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

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

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

 
 

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

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

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

        {
        {

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

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

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

 
 

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

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

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

 
   current_monitor = mon_ops;
 
 
   current_monitor = mon_ops;
 


@@ -784,7 +771,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
 
   if (current_monitor->stop)
     {
 
   if (current_monitor->stop)
     {

-      monitor_stop ();
+      monitor_stop (inferior_ptid);

       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
        {
          monitor_debug ("EXP Open echo\n");
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
        {
          monitor_debug ("EXP Open echo\n");


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

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

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


@@ -826,17 +813,23 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
     }
 
   if (from_tty)
     }
 
   if (from_tty)

-    printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
+    printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name);

 
   push_target (targ_ops);
 
 
   push_target (targ_ops);
 

-  inferior_pid = 42000;                /* Make run command think we are busy... */
+  /* Start afresh.  */
+  init_thread_list ();
+
+  /* Make run command think we are busy...  */
+  inferior_ptid = monitor_ptid;
+  add_inferior_silent (ptid_get_pid (inferior_ptid));
+  add_thread_silent (inferior_ptid);

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

-  start_remote ();
+  start_remote (from_tty);

 }
 
 /* Close out all files and local state before this target loses
 }
 
 /* Close out all files and local state before this target loses


@@ -846,36 +839,41 @@ void
 monitor_close (int quitting)
 {
   if (monitor_desc)
 monitor_close (int quitting)
 {
   if (monitor_desc)

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

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

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

       breakaddr = NULL;
     }
 
   monitor_desc = NULL;
       breakaddr = NULL;
     }
 
   monitor_desc = NULL;

+
+  delete_thread_silent (monitor_ptid);
+  delete_inferior_silent (ptid_get_pid (monitor_ptid));

 }
 
 /* Terminate the open connection to the remote debugger.  Use this
    when you want to detach and do something else with your gdb.  */
 
 static void
 }
 
 /* Terminate the open connection to the remote debugger.  Use this
    when you want to detach and do something else with your gdb.  */
 
 static void

-monitor_detach (char *args, int from_tty)
+monitor_detach (struct target_ops *ops, 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)

-    printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
+    printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);

 }
 
 /* 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 (int regno, char *valstr)
+monitor_supply_register (struct regcache *regcache, int regno, char *valstr)

 {
 {

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

   ULONGEST val;
   ULONGEST val;

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

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


@@ -903,15 +901,16 @@ monitor_supply_register (int regno, char *valstr)
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 
     }
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 

-  if (*p != '\0')
-    error ("monitor_supply_register (%d):  bad value from monitor: %s.",
+  if (val == 0 && valstr == p)
+    error (_("monitor_supply_register (%d):  bad value from monitor: %s."),

           regno, valstr);
 
   /* supply register stores in target byte order, so swap here */
 
           regno, valstr);
 
   /* supply register stores in target byte order, so swap here */
 

-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+  store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
+                         val);

 
 

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

 
   return p;
 }
 
   return p;
 }


@@ -919,7 +918,8 @@ monitor_supply_register (int regno, char *valstr)
 /* Tell the remote machine to resume.  */
 
 static void
 /* Tell the remote machine to resume.  */
 
 static void

-monitor_resume (int pid, int step, enum target_signal sig)
+monitor_resume (struct target_ops *ops,
+               ptid_t ptid, int step, enum target_signal sig)

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


@@ -950,7 +950,7 @@ monitor_resume (int pid, int step, enum target_signal 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 (char *buf, int len)
+parse_register_dump (struct regcache *regcache, char *buf, int len)

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


@@ -972,7 +972,8 @@ parse_register_dump (char *buf, int len)
       vallen = register_strings.end[2] - register_strings.start[2];
       val = buf + register_strings.start[2];
 
       vallen = register_strings.end[2] - register_strings.start[2];
       val = buf + register_strings.start[2];
 

-      current_monitor->supply_register (regname, regnamelen, val, vallen);
+      current_monitor->supply_register (regcache, regname, regnamelen,
+                                       val, vallen);

 
       buf += register_strings.end[0];
       len -= register_strings.end[0];
 
       buf += register_strings.end[0];
       len -= register_strings.end[0];


@@ -991,7 +992,7 @@ monitor_interrupt (int signo)
   if (monitor_debug_p || remote_debug)
     fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
 
   if (monitor_debug_p || remote_debug)
     fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
 

-  target_stop ();
+  target_stop (inferior_ptid);

 }
 
 /* The user typed ^C twice.  */
 }
 
 /* The user typed ^C twice.  */


@@ -1013,11 +1014,11 @@ monitor_interrupt_query (void)
 {
   target_terminal_ours ();
 
 {
   target_terminal_ours ();
 

-  if (query ("Interrupted while waiting for the program.\n\
-Give up (and stop debugging it)? "))
+  if (query (_("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? ")))

     {
       target_mourn_inferior ();
     {
       target_mourn_inferior ();

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

     }
 
   target_terminal_inferior ();
     }
 
   target_terminal_inferior ();


@@ -1033,12 +1034,11 @@ monitor_wait_cleanup (void *old_timeout)
 
 
 
 
 
 

-void
+static void

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

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

 {
   int resp_len;
   do
 {
   int resp_len;
   do


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

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

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


@@ -1133,10 +1134,10 @@ monitor_wait (int pid, struct target_waitstatus *status)
     }
 
   if (current_monitor->register_pattern)
     }
 
   if (current_monitor->register_pattern)

-    parse_register_dump (buf, resp_len);
+    parse_register_dump (get_current_regcache (), buf, resp_len);

 #else
   monitor_debug ("Wait fetching registers after stop\n");
 #else
   monitor_debug ("Wait fetching registers after stop\n");

-  monitor_dump_regs ();
+  monitor_dump_regs (get_current_regcache ());

 #endif
 
   status->kind = TARGET_WAITKIND_STOPPED;
 #endif
 
   status->kind = TARGET_WAITKIND_STOPPED;


@@ -1146,31 +1147,34 @@ monitor_wait (int pid, struct target_waitstatus *status)
 
   in_monitor_wait = 0;
 
 
   in_monitor_wait = 0;
 

-  return inferior_pid;
+  return inferior_ptid;

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

-monitor_fetch_register (int regno)
+monitor_fetch_register (struct regcache *regcache, int regno)

 {
 {

-  char *name;
+  const char *name;

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

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

 
 

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

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

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

       return;
     }
 
       return;
     }
 


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

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

               regno);
     }
 
               regno);
     }
 


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

-  for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+  for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)

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


@@ -1249,7 +1253,7 @@ monitor_fetch_register (int regno)
       current_monitor->getreg.term_cmd)                /* ack expected */
     monitor_expect_prompt (NULL, 0);   /* get response */
 
       current_monitor->getreg.term_cmd)                /* ack expected */
     monitor_expect_prompt (NULL, 0);   /* get response */
 

-  monitor_supply_register (regno, regbuf);
+  monitor_supply_register (regcache, regno, regbuf);

 }
 
 /* Sometimes, it takes several commands to dump the registers */
 }
 
 /* Sometimes, it takes several commands to dump the registers */


@@ -1257,13 +1261,13 @@ monitor_fetch_register (int regno)
    case they need to compose the operation.
  */
 int
    case they need to compose the operation.
  */
 int

-monitor_dump_reg_block (char *block_cmd)
+monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)

 {
   char buf[TARGET_BUF_SIZE];
   int resp_len;
   monitor_printf (block_cmd);
   resp_len = monitor_expect_prompt (buf, sizeof (buf));
 {
   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);
+  parse_register_dump (regcache, buf, resp_len);

   return 1;
 }
 
   return 1;
 }
 


@@ -1272,61 +1276,67 @@ 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 (void)
+monitor_dump_regs (struct regcache *regcache)

 {
   char buf[TARGET_BUF_SIZE];
   int resp_len;
   if (current_monitor->dumpregs)
 {
   char buf[TARGET_BUF_SIZE];
   int resp_len;
   if (current_monitor->dumpregs)

-    (*(current_monitor->dumpregs)) (); /* call supplied function */
+    (*(current_monitor->dumpregs)) (regcache); /* 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));
   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);
+      parse_register_dump (regcache, buf, resp_len);

     }
   else
     }
   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 (int regno)
+monitor_fetch_registers (struct target_ops *ops,
+                        struct regcache *regcache, int regno)

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

-         monitor_fetch_register (regno);
+         monitor_fetch_register (regcache, regno);

          return;
        }
 
          return;
        }
 

-      for (regno = 0; regno < NUM_REGS; regno++)
-       monitor_fetch_register (regno);
+      for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
+          regno++)
+       monitor_fetch_register (regcache, regno);

     }
   else
     {
     }
   else
     {

-      monitor_dump_regs ();
+      monitor_dump_regs (regcache);

     }
 }
 
 /* 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 (int regno)
+monitor_store_register (struct regcache *regcache, int regno)

 {
 {

-  char *name;
+  int reg_size = register_size (get_regcache_arch (regcache), regno);
+  const char *name;

   ULONGEST val;
   ULONGEST val;

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

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

-  val = read_register (regno);
-  monitor_debug ("MON storeg %d %s\n", regno,
-                phex (val, REGISTER_RAW_SIZE (regno)));
+  regcache_cooked_read_unsigned (regcache, regno, &val);
+  monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));

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


@@ -1337,12 +1347,19 @@ monitor_store_register (int regno)
   else
     monitor_printf (current_monitor->setreg.cmd, name, val);
 
   else
     monitor_printf (current_monitor->setreg.cmd, name, val);
 

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

   if (current_monitor->setreg.term)
     {
       monitor_debug ("EXP setreg.term\n");
       monitor_expect (current_monitor->setreg.term, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
   if (current_monitor->setreg.term)
     {
       monitor_debug ("EXP setreg.term\n");
       monitor_expect (current_monitor->setreg.term, NULL, 0);
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)

-       monitor_printf ("%s\r", paddr_nz (val));
+       monitor_printf ("%s\r", phex_nz (val, reg_size));

       monitor_expect_prompt (NULL, 0);
     }
   else
       monitor_expect_prompt (NULL, 0);
     }
   else


@@ -1358,16 +1375,18 @@ monitor_store_register (int regno)
 /* Store the remote registers.  */
 
 static void
 /* Store the remote registers.  */
 
 static void

-monitor_store_registers (int regno)
+monitor_store_registers (struct target_ops *ops,
+                        struct regcache *regcache, int regno)

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

-      monitor_store_register (regno);
+      monitor_store_register (regcache, regno);

       return;
     }
 
       return;
     }
 

-  for (regno = 0; regno < NUM_REGS; regno++)
-    monitor_store_register (regno);
+  for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
+       regno++)
+    monitor_store_register (regcache, regno);

 }
 
 /* Get ready to modify the registers array.  On machines which store
 }
 
 /* Get ready to modify the registers array.  On machines which store


@@ -1377,7 +1396,7 @@ monitor_store_registers (int regno)
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-monitor_prepare_to_store (void)
+monitor_prepare_to_store (struct regcache *regcache)

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


@@ -1385,20 +1404,21 @@ monitor_prepare_to_store (void)
 static void
 monitor_files_info (struct target_ops *ops)
 {
 static void
 monitor_files_info (struct target_ops *ops)
 {

-  printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
+  printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);

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

+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);

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

-  monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
+  monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, memaddr));

 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)

-    memaddr = ADDR_BITS_REMOVE (memaddr);
+    memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);

 
   /* Use memory fill command for leading 0 bytes.  */
 
 
   /* Use memory fill command for leading 0 bytes.  */
 


@@ -1447,7 +1467,7 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
       cmd = current_monitor->setmem.cmdb;
     }
 
       cmd = current_monitor->setmem.cmdb;
     }
 

-  val = extract_unsigned_integer (myaddr, len);
+  val = extract_unsigned_integer (myaddr, len, byte_order);

 
   if (len == 4)
     {
 
   if (len == 4)
     {


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

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

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


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

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

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


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

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

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


@@ -1684,11 +1672,11 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
 static int
 monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
 {
 static int
 monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);

   unsigned int val;
   char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;
   unsigned int val;
   char membuf[sizeof (int) * 2 + 1];
   char *p;
   char *cmd;

-  int i;

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


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

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

     }
     }

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

 
 

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

 
 

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

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

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

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


@@ -1799,7 +1789,7 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
 
   /* supply register stores in target byte order, so swap here */
 
 
   /* supply register stores in target byte order, so swap here */
 

-  store_unsigned_integer (myaddr, len, val);
+  store_unsigned_integer (myaddr, len, byte_order, val);

 
   return len;
 }
 
   return len;
 }


@@ -1825,10 +1815,10 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
     }
 
   monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
     }
 
   monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",

-                paddr_nz (memaddr), (long) myaddr, len);
+                paddress (target_gdbarch, memaddr), (long) myaddr, len);

 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)

-    memaddr = ADDR_BITS_REMOVE (memaddr);
+    memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);

 
   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
     return monitor_read_memory_single (memaddr, myaddr, len);
 
   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
     return monitor_read_memory_single (memaddr, myaddr, len);


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

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

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


@@ -1941,7 +1931,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
          c = *p;
        }
       if (fetched == 0)
          c = *p;
        }
       if (fetched == 0)

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

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


@@ -1987,8 +1977,8 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
    unused. */
 
 static int
    unused. */
 
 static int

-monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
-                    struct target_ops *target)
+monitor_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+                    struct mem_attrib *attrib, struct target_ops *target)

 {
   int res;
 
 {
   int res;
 


@@ -2008,23 +1998,24 @@ monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 }
 
 static void
 }
 
 static void

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

 {
   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.  */
+/* All we actually do is set the PC to the start address of exec_bfd.  */

 
 static void
 
 static void

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

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

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

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

-  proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
+  regcache_write_pc (get_current_regcache (),
+                    bfd_get_start_address (exec_bfd));

 }
 
 /* Clean up when a program exits.
 }
 
 /* Clean up when a program exits.


@@ -2033,59 +2024,61 @@ monitor_create_inferior (char *exec_file, char *args, char **env)
    instructions.  */
 
 static void
    instructions.  */
 
 static void

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

 {
   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 */

+  delete_thread_silent (monitor_ptid);

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

-monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
+monitor_insert_breakpoint (struct gdbarch *gdbarch,
+                          struct bp_target_info *bp_tgt)

 {
 {

+  CORE_ADDR addr = bp_tgt->placed_address;

   int i;
   int i;

-  unsigned char *bp;

   int bplen;
 
   int bplen;
 

-  monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+  monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));

   if (current_monitor->set_break == NULL)
   if (current_monitor->set_break == NULL)

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

 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)

-    addr = ADDR_BITS_REMOVE (addr);
+    addr = gdbarch_addr_bits_remove (gdbarch, addr);

 
   /* Determine appropriate breakpoint size for this address.  */
 
   /* Determine appropriate breakpoint size for this address.  */

-  bp = memory_breakpoint_from_pc (&addr, &bplen);
+  gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
+  bp_tgt->placed_address = addr;
+  bp_tgt->placed_size = bplen;

 
   for (i = 0; i < current_monitor->num_breakpoints; i++)
     {
       if (breakaddr[i] == 0)
        {
          breakaddr[i] = addr;
 
   for (i = 0; i < current_monitor->num_breakpoints; i++)
     {
       if (breakaddr[i] == 0)
        {
          breakaddr[i] = addr;

-         monitor_read_memory (addr, shadow, bplen);

          monitor_printf (current_monitor->set_break, addr);
          monitor_expect_prompt (NULL, 0);
          return 0;
        }
     }
 
          monitor_printf (current_monitor->set_break, addr);
          monitor_expect_prompt (NULL, 0);
          return 0;
        }
     }
 

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

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

-monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
+monitor_remove_breakpoint (struct gdbarch *gdbarch,
+                          struct bp_target_info *bp_tgt)

 {
 {

+  CORE_ADDR addr = bp_tgt->placed_address;

   int i;
 
   int i;
 

-  monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+  monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));

   if (current_monitor->clr_break == NULL)
   if (current_monitor->clr_break == NULL)

-    error ("No clr_break defined for this monitor");
-
-  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    addr = ADDR_BITS_REMOVE (addr);
+    error (_("No clr_break defined for this monitor"));

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


@@ -2104,8 +2097,8 @@ monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
        }
     }
   fprintf_unfiltered (gdb_stderr,
        }
     }
   fprintf_unfiltered (gdb_stderr,

-                     "Can't find breakpoint associated with 0x%s\n",
-                     paddr_nz (addr));
+                     "Can't find breakpoint associated with %s\n",
+                     paddress (gdbarch, addr));

   return 1;
 }
 
   return 1;
 }
 


@@ -2170,28 +2163,32 @@ monitor_load (char *file, int from_tty)
       monitor_expect_prompt (NULL, 0);
     }
 
       monitor_expect_prompt (NULL, 0);
     }
 

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

   if (exec_bfd)
   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 ();
+    regcache_write_pc (get_current_regcache (),
+                      bfd_get_start_address (exec_bfd));
+
+  /* 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 (void)
+monitor_stop (ptid_t ptid)

 {
   monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
 {
   monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)

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

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


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

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

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


@@ -2236,7 +2233,7 @@ from_hex (int a)
   if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
 
   if (a >= 'A' && a <= 'F')
     return a - 'A' + 10;
 

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

 }
 #endif
 
 }
 #endif
 


@@ -2246,74 +2243,66 @@ monitor_get_dev_name (void)
   return dev_name;
 }
 
   return dev_name;
 }
 

+/* Check to see if a thread is still alive.  */
+
+static int
+monitor_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+  if (ptid_equal (ptid, monitor_ptid))
+    /* The monitor's task is always alive.  */
+    return 1;
+
+  return 0;
+}
+
+/* Convert a thread ID to a string.  Returns the string in a static
+   buffer.  */
+
+static char *
+monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  static char buf[64];
+
+  if (ptid_equal (monitor_ptid, ptid))
+    {
+      xsnprintf (buf, sizeof buf, "Thread <main>");
+      return buf;
+    }
+
+  return normal_pid_to_str (ptid);
+}
+

 static struct target_ops monitor_ops;
 
 static void
 init_base_monitor_ops (void)
 {
 static struct target_ops monitor_ops;
 
 static void
 init_base_monitor_ops (void)
 {

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

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

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

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

-  monitor_ops.to_require_detach = NULL;

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

-  monitor_ops.to_post_wait = NULL;

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

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

   monitor_ops.to_files_info = monitor_files_info;
   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
   monitor_ops.to_files_info = monitor_files_info;
   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;

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

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

-  monitor_ops.to_lookup_symbol = 0;

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

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

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

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

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

-  monitor_ops.to_pid_to_exec_file = NULL;
-  monitor_ops.to_core_file_to_sym_file = NULL;
+  monitor_ops.to_log_command = serial_log_command;
+  monitor_ops.to_thread_alive = monitor_thread_alive;
+  monitor_ops.to_pid_to_str = monitor_pid_to_str;

   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_sections = 0;
-  monitor_ops.to_sections_end = 0;
+  monitor_ops.to_has_all_memory = default_child_has_all_memory;
+  monitor_ops.to_has_memory = default_child_has_memory;
+  monitor_ops.to_has_stack = default_child_has_stack;
+  monitor_ops.to_has_registers = default_child_has_registers;
+  monitor_ops.to_has_execution = default_child_has_execution;

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


@@ -2330,22 +2319,30 @@ init_monitor_ops (struct target_ops *ops)
 
 /* Define additional commands that are usually only used by monitors.  */
 
 
 /* Define additional commands that are usually only used by monitors.  */
 

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

 void
 _initialize_remote_monitors (void)
 {
   init_base_monitor_ops ();
 void
 _initialize_remote_monitors (void)
 {
   init_base_monitor_ops ();

-  add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
-                                 (char *) &hashmark,
-                                 "Set display of activity while downloading a file.\n\
-When enabled, a hashmark \'#\' is displayed.",
-                                 &setlist),
-                    &showlist);
-
-  add_show_from_set
-    (add_set_cmd ("monitor", no_class, var_zinteger,
-                 (char *) &monitor_debug_p,
-                 "Set debugging of remote monitor communication.\n\
+  add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
+Set display of activity while downloading a file."), _("\
+Show display of activity while downloading a file."), _("\
+When enabled, a hashmark \'#\' is displayed."),
+                          NULL,
+                          NULL, /* FIXME: i18n: */
+                          &setlist, &showlist);
+
+  add_setshow_zinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
+Set debugging of remote monitor communication."), _("\
+Show debugging of remote monitor communication."), _("\

 When enabled, communication between GDB and the remote monitor\n\
 When enabled, communication between GDB and the remote monitor\n\

-is displayed.", &setdebuglist),
-     &showdebuglist);
+is displayed."),
+                           NULL,
+                           NULL, /* FIXME: i18n: */
+                           &setdebuglist, &showdebuglist);
+
+  /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
+     isn't 0.  */
+  monitor_ptid = ptid_build (42000, 0, 42000);

 }
 }