OSDN Git Service

Add fast tracepoints.
[pf3gnuchains/pf3gnuchains3x.git] / gdb / monitor.c
index 0603806..aca34cc 100644 (file)
@@ -1,6 +1,9 @@
 /* Remote debugging interface for boot monitors, for GDB.
-   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2000, 2001 Free Software Foundation, Inc.
+
+   Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001, 2002, 2006, 2007, 2008, 2009, 2010
+   Free Software Foundation, Inc.
+
    Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
    Resurrected from the ashes by Stu Grossman.
 
@@ -8,7 +11,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
-   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,
@@ -17,9 +20,7 @@
    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
@@ -41,6 +42,7 @@
 #include "defs.h"
 #include "gdbcore.h"
 #include "target.h"
+#include "exceptions.h"
 #include <signal.h>
 #include <ctype.h>
 #include "gdb_string.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 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);
+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);
-static unsigned long get_hex_word (void);
 #endif
-static void parse_register_dump (char *, int);
 
 static struct monitor_ops *current_monitor;
 
@@ -141,6 +107,13 @@ static int dump_reg_flag;  /* Non-zero means do a dump_registers cmd when
 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
@@ -151,7 +124,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
-   when determining if debug information is printed.  Perhaphs this
+   when determining if debug information is printed.  Perhaps this
    could be simplified. */
 
 static void
@@ -242,9 +215,13 @@ monitor_error (char *function, char *message,
   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
-    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.  */
@@ -259,7 +236,7 @@ fromhex (int a)
   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
@@ -279,6 +256,7 @@ fromhex (int a)
 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;
@@ -307,7 +285,7 @@ monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
              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 *);
@@ -343,7 +321,7 @@ monitor_printf_noecho (char *pattern,...)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
-    internal_error (__FILE__, __LINE__, "failed internal consistency check");
+    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 
   if (monitor_debug_p)
     {
@@ -371,7 +349,7 @@ monitor_printf (char *pattern,...)
 
   len = strlen (sndbuf);
   if (len + 1 > sizeof sndbuf)
-    internal_error (__FILE__, __LINE__, "failed internal consistency check");
+    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 
   if (monitor_debug_p)
     {
@@ -426,9 +404,9 @@ monitor_readchar (void)
     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"));
 }
 
 
@@ -497,13 +475,13 @@ readchar (int timeout)
     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
-      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-
@@ -519,7 +497,6 @@ monitor_expect (char *string, char *buf, int buflen)
   char *p = string;
   int obuflen = buflen;
   int c;
-  extern struct target_ops *targ_ops;
 
   if (monitor_debug_p)
     {
@@ -567,12 +544,6 @@ monitor_expect (char *string, char *buf, int buflen)
                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
@@ -721,7 +692,7 @@ compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
   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);
@@ -735,16 +706,17 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
 {
   char *name;
   char **p;
+  struct inferior *inf;
 
   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)
-    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);
 
@@ -801,7 +773,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
 
   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");
@@ -843,17 +815,24 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int 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);
 
-  inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */
+  /* Start afresh.  */
+  init_thread_list ();
+
+  /* Make run command think we are busy...  */
+  inferior_ptid = monitor_ptid;
+  inf = current_inferior ();
+  inferior_appeared (inf, ptid_get_pid (inferior_ptid));
+  add_thread_silent (inferior_ptid);
 
   /* 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
@@ -873,26 +852,31 @@ monitor_close (int quitting)
     }
 
   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
-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)
-    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 *
-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;
-  unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+  unsigned char regbuf[MAX_REGISTER_SIZE];
   char *p;
 
   val = 0;
@@ -921,14 +905,15 @@ monitor_supply_register (int regno, char *valstr)
   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
 
   if (val == 0 && valstr == p)
-    error ("monitor_supply_register (%d):  bad value from monitor: %s.",
+    error (_("monitor_supply_register (%d):  bad value from monitor: %s."),
           regno, valstr);
 
   /* supply register stores in target byte order, so swap here */
 
-  store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+  store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
+                         val);
 
-  supply_register (regno, regbuf);
+  regcache_raw_supply (regcache, regno, regbuf);
 
   return p;
 }
@@ -936,7 +921,8 @@ monitor_supply_register (int regno, char *valstr)
 /* Tell the remote machine to resume.  */
 
 static void
-monitor_resume (ptid_t ptid, 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");
@@ -967,7 +953,7 @@ monitor_resume (ptid_t ptid, int step, enum target_signal sig)
    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)
@@ -989,7 +975,8 @@ parse_register_dump (char *buf, int len)
       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];
@@ -1008,7 +995,7 @@ monitor_interrupt (int signo)
   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.  */
@@ -1030,11 +1017,11 @@ monitor_interrupt_query (void)
 {
   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 ();
-      return_to_top_level (RETURN_QUIT);
+      deprecated_throw_reason (RETURN_QUIT);
     }
 
   target_terminal_inferior ();
@@ -1050,12 +1037,11 @@ monitor_wait_cleanup (void *old_timeout)
 
 
 
-void
+static void
 monitor_wait_filter (char *buf,
                     int bufmax,
                     int *ext_resp_len,
-                    struct target_waitstatus *status
-)
+                    struct target_waitstatus *status)
 {
   int resp_len;
   do
@@ -1087,7 +1073,8 @@ monitor_wait_filter (char *buf,
    status just as `wait' would.  */
 
 static ptid_t
-monitor_wait (ptid_t ptid, struct target_waitstatus *status)
+monitor_wait (struct target_ops *ops,
+             ptid_t ptid, struct target_waitstatus *status, int options)
 {
   int old_timeout = timeout;
   char buf[TARGET_BUF_SIZE];
@@ -1150,10 +1137,10 @@ monitor_wait (ptid_t ptid, struct target_waitstatus *status)
     }
 
   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");
-  monitor_dump_regs ();
+  monitor_dump_regs (get_current_regcache ());
 #endif
 
   status->kind = TARGET_WAITKIND_STOPPED;
@@ -1170,24 +1157,27 @@ monitor_wait (ptid_t ptid, struct target_waitstatus *status)
    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;
 
-  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);
-      supply_register (regno, zerobuf);
+      regcache_raw_supply (regcache, regno, zerobuf);
       return;
     }
 
@@ -1222,7 +1212,7 @@ monitor_fetch_register (int regno)
       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);
     }
 
@@ -1230,7 +1220,7 @@ monitor_fetch_register (int regno)
      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);
@@ -1266,7 +1256,7 @@ monitor_fetch_register (int regno)
       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 */
@@ -1274,13 +1264,13 @@ monitor_fetch_register (int regno)
    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));
-  parse_register_dump (buf, resp_len);
+  parse_register_dump (regcache, buf, resp_len);
   return 1;
 }
 
@@ -1289,61 +1279,67 @@ monitor_dump_reg_block (char *block_cmd)
 /* 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)
-    (*(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));
-      parse_register_dump (buf, resp_len);
+      parse_register_dump (regcache, buf, resp_len);
     }
   else
-    internal_error (__FILE__, __LINE__, "failed internal consistency check");                  /* Need some way to read registers */
+    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));                       /* Need some way to read registers */
 }
 
 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_fetch_register (regno);
+         monitor_fetch_register (regcache, regno);
          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
     {
-      monitor_dump_regs ();
+      monitor_dump_regs (regcache);
     }
 }
 
 /* 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;
-
-  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;
     }
 
-  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 */
 
@@ -1359,14 +1355,14 @@ monitor_store_register (int regno)
       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));
+       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)
-       monitor_printf ("%s\r", paddr_nz (val));
+       monitor_printf ("%s\r", phex_nz (val, reg_size));
       monitor_expect_prompt (NULL, 0);
     }
   else
@@ -1382,16 +1378,18 @@ monitor_store_register (int regno)
 /* 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)
     {
-      monitor_store_register (regno);
+      monitor_store_register (regcache, regno);
       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
@@ -1401,7 +1399,7 @@ monitor_store_registers (int regno)
    debugged.  */
 
 static void
-monitor_prepare_to_store (void)
+monitor_prepare_to_store (struct regcache *regcache)
 {
   /* Do nothing, since we can store individual regs */
 }
@@ -1409,20 +1407,21 @@ monitor_prepare_to_store (void)
 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)
 {
+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
   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)
-    memaddr = ADDR_BITS_REMOVE (memaddr);
+    memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
 
   /* Use memory fill command for leading 0 bytes.  */
 
@@ -1471,7 +1470,7 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
       cmd = current_monitor->setmem.cmdb;
     }
 
-  val = extract_unsigned_integer (myaddr, len);
+  val = extract_unsigned_integer (myaddr, len, byte_order);
 
   if (len == 4)
     {
@@ -1515,33 +1514,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)
 {
   unsigned char val;
@@ -1693,17 +1665,6 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int 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;
 }
@@ -1714,6 +1675,7 @@ monitor_write_memory_block (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;
@@ -1830,7 +1792,7 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
 
   /* 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;
 }
@@ -1856,10 +1818,10 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
     }
 
   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)
-    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);
@@ -1972,7 +1934,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
          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 */
@@ -2018,9 +1980,8 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
    unused. */
 
 static int
-monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
-                    struct mem_attrib *attrib ATTRIBUTE_UNUSED,
-                    struct target_ops *target ATTRIBUTE_UNUSED)
+monitor_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+                    struct mem_attrib *attrib, struct target_ops *target)
 {
   int res;
 
@@ -2040,23 +2001,24 @@ monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 }
 
 static void
-monitor_kill (void)
+monitor_kill (struct target_ops *ops)
 {
   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
-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'))
-    error ("Args are not supported by the monitor.");
+    error (_("Args are not supported by the monitor."));
 
   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.
@@ -2065,59 +2027,61 @@ monitor_create_inferior (char *exec_file, char *args, char **env)
    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 */
+  delete_thread_silent (monitor_ptid);
 }
 
 /* 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;
-  unsigned char *bp;
   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)
-    error ("No set_break defined for this monitor");
+    error (_("No set_break defined for this monitor"));
 
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    addr = ADDR_BITS_REMOVE (addr);
+    addr = gdbarch_addr_bits_remove (gdbarch, addr);
 
   /* 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;
-         monitor_read_memory (addr, shadow, bplen);
          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
-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;
 
-  monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+  monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
   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++)
     {
@@ -2136,8 +2100,8 @@ monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
        }
     }
   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;
 }
 
@@ -2204,21 +2168,26 @@ monitor_load (char *file, int from_tty)
 
   /* Finally, make the PC point at the start address */
   if (exec_bfd)
-    write_pc (bfd_get_start_address (exec_bfd));
-
-  inferior_ptid = null_ptid ;  /* 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
-monitor_stop (void)
+monitor_stop (ptid_t ptid)
 {
   monitor_debug ("MON stop\n");
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
@@ -2240,7 +2209,7 @@ monitor_rcmd (char *command,
   char buf[1000];
 
   if (monitor_desc == NULL)
-    error ("monitor target not open.");
+    error (_("monitor target not open."));
 
   p = current_monitor->prompt;
 
@@ -2267,7 +2236,7 @@ from_hex (int a)
   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
 
@@ -2277,73 +2246,66 @@ monitor_get_dev_name (void)
   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)
 {
-  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_attach = NULL;
-  monitor_ops.to_post_attach = NULL;
-  monitor_ops.to_require_attach = NULL;
   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_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_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_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_lookup_symbol = 0;
   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_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_pid_to_exec_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.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 */
 
@@ -2360,22 +2322,30 @@ init_monitor_ops (struct target_ops *ops)
 
 /* 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 ();
-  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\
-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);
 }