run copyright.sh for 2011.

[thirdparty/binutils-gdb.git] / gdb / remote-mips.c

diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index c9a7ddfed107200061d088dec10593ed1c452086..7ea13656be242b233924a6a24524e88ba1a9a4a2 100644 (file)
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -1,7 +1,8 @@
 /* Remote debugging interface for MIPS remote debugging protocol.
 
 /* Remote debugging interface for MIPS remote debugging protocol.
 

-   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
-   2002 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+   2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011
+   Free Software Foundation, Inc.

 
    Contributed by Cygnus Support.  Written by Ian Lance Taylor
    <ian@cygnus.com>.
 
    Contributed by Cygnus Support.  Written by Ian Lance Taylor
    <ian@cygnus.com>.


@@ -10,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
 
    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,


@@ -19,9 +20,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/>.  */

 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"


@@ -31,11 +30,13 @@
 #include "gdbcore.h"
 #include "serial.h"
 #include "target.h"
 #include "gdbcore.h"
 #include "serial.h"
 #include "target.h"

-#include "remote-utils.h"
+#include "exceptions.h"

 #include "gdb_string.h"
 #include "gdb_stat.h"
 #include "regcache.h"
 #include <ctype.h>
 #include "gdb_string.h"
 #include "gdb_stat.h"
 #include "regcache.h"
 #include <ctype.h>

+#include "mips-tdep.h"
+#include "gdbthread.h"

 \f
 
 /* Breakpoint types.  Values 0, 1, and 2 must agree with the watch
 \f
 
 /* Breakpoint types.  Values 0, 1, and 2 must agree with the watch


@@ -85,37 +86,27 @@ static void lsi_open (char *name, int from_tty);
 
 static void mips_close (int quitting);
 
 
 static void mips_close (int quitting);
 

-static void mips_detach (char *args, int from_tty);
+static void mips_detach (struct target_ops *ops, char *args, int from_tty);

 
 

-static void mips_resume (ptid_t ptid, int step,
-                         enum target_signal siggnal);
+static int mips_map_regno (struct gdbarch *, int);

 
 

-static ptid_t mips_wait (ptid_t ptid,
-                               struct target_waitstatus *status);
+static void mips_set_register (int regno, ULONGEST value);

 
 

-static int mips_map_regno (int regno);
+static void mips_prepare_to_store (struct regcache *regcache);

 
 

-static void mips_fetch_registers (int regno);
-
-static void mips_prepare_to_store (void);
-
-static void mips_store_registers (int regno);
-
-static unsigned int mips_fetch_word (CORE_ADDR addr);
+static int mips_fetch_word (CORE_ADDR addr, unsigned int *valp);

 
 static int mips_store_word (CORE_ADDR addr, unsigned int value,
 
 static int mips_store_word (CORE_ADDR addr, unsigned int value,

-                           char *old_contents);
+                           int *old_contents);

 
 

-static int mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
+static int mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,

                             int write, 
                             struct mem_attrib *attrib,
                             struct target_ops *target);
 
 static void mips_files_info (struct target_ops *ignore);
 
                             int write, 
                             struct mem_attrib *attrib,
                             struct target_ops *target);
 
 static void mips_files_info (struct target_ops *ignore);
 

-static void mips_create_inferior (char *execfile, char *args, char **env);
-
-static void mips_mourn_inferior (void);
+static void mips_mourn_inferior (struct target_ops *ops);

 
 static int pmon_makeb64 (unsigned long v, char *p, int n, int *chksum);
 
 
 static int pmon_makeb64 (unsigned long v, char *p, int n, int *chksum);
 


@@ -143,17 +134,19 @@ static void mips_load (char *file, int from_tty);
 static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
                           unsigned char *myaddr, int len);
 
 static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
                           unsigned char *myaddr, int len);
 

-static int set_breakpoint (CORE_ADDR addr, int len, enum break_type type);
+static int mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type);

 
 

-static int clear_breakpoint (CORE_ADDR addr, int len, enum break_type type);
+static int mips_clear_breakpoint (CORE_ADDR addr, int len,
+                                 enum break_type type);

 
 

-static int common_breakpoint (int set, CORE_ADDR addr, int len,
-                             enum break_type type);
+static int mips_common_breakpoint (int set, CORE_ADDR addr, int len,
+                                  enum break_type type);

 
 /* Forward declarations.  */
 extern struct target_ops mips_ops;
 extern struct target_ops pmon_ops;
 extern struct target_ops ddb_ops;
 
 /* Forward declarations.  */
 extern struct target_ops mips_ops;
 extern struct target_ops pmon_ops;
 extern struct target_ops ddb_ops;

+extern struct target_ops rockhopper_ops;

 \f/* *INDENT-OFF* */
 /* The MIPS remote debugging interface is built on top of a simple
    packet protocol.  Each packet is organized as follows:
 \f/* *INDENT-OFF* */
 /* The MIPS remote debugging interface is built on top of a simple
    packet protocol.  Each packet is organized as follows:


@@ -299,7 +292,7 @@ extern struct target_ops ddb_ops;
    These are initialized with code in _initialize_remote_mips instead
    of static initializers, to make it easier to extend the target_ops
    vector later.  */
    These are initialized with code in _initialize_remote_mips instead
    of static initializers, to make it easier to extend the target_ops
    vector later.  */

-struct target_ops mips_ops, pmon_ops, ddb_ops, lsi_ops;
+struct target_ops mips_ops, pmon_ops, ddb_ops, rockhopper_ops, lsi_ops;

 
 enum mips_monitor_type
   {
 
 enum mips_monitor_type
   {


@@ -309,6 +302,7 @@ enum mips_monitor_type
     MON_PMON,                  /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov  9 1995 17:19:50 */
     MON_DDB,                   /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems,  Thu Jun 6 09:28:40 PDT 1996 */
     MON_LSI,                   /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
     MON_PMON,                  /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov  9 1995 17:19:50 */
     MON_DDB,                   /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems,  Thu Jun 6 09:28:40 PDT 1996 */
     MON_LSI,                   /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */

+    MON_ROCKHOPPER,

     /* Last and unused value, for sizing vectors, etc. */
     MON_LAST
   };
     /* Last and unused value, for sizing vectors, etc. */
     MON_LAST
   };


@@ -452,6 +446,14 @@ struct lsi_error lsi_error_table[] =
    of warnings returned by PMON when hardware breakpoints are used.  */
 static int monitor_warnings;
 
    of warnings returned by PMON when hardware breakpoints are used.  */
 static int monitor_warnings;
 

+/* This is the ptid we use while we're connected to the remote.  Its
+   value is arbitrary, as the remote-mips target doesn't have a notion of
+   processes or threads, but we need something non-null to place in
+   inferior_ptid.  */
+static ptid_t remote_mips_ptid;
+
+/* Close any ports which might be open.  Reset certain globals indicating
+   the state of those ports.  */

 
 static void
 close_ports (void)
 
 static void
 close_ports (void)


@@ -472,7 +474,7 @@ close_ports (void)
    all hell to break loose--the rest of GDB will tend to get left in an
    inconsistent state.  */
 
    all hell to break loose--the rest of GDB will tend to get left in an
    inconsistent state.  */
 

-static NORETURN void
+static void ATTRIBUTE_NORETURN

 mips_error (char *string,...)
 {
   va_list args;
 mips_error (char *string,...)
 {
   va_list args;


@@ -495,9 +497,10 @@ mips_error (char *string,...)
   close_ports ();
 
   printf_unfiltered ("Ending remote MIPS debugging.\n");
   close_ports ();
 
   printf_unfiltered ("Ending remote MIPS debugging.\n");

-  target_mourn_inferior ();
+  if (!ptid_equal (inferior_ptid, null_ptid))
+    target_mourn_inferior ();

 
 

-  throw_exception (RETURN_ERROR);
+  deprecated_throw_reason (RETURN_ERROR);

 }
 
 /* putc_readable - print a character, displaying non-printable chars in
 }
 
 /* putc_readable - print a character, displaying non-printable chars in


@@ -532,6 +535,33 @@ fputs_readable (const char *string, struct ui_file *file)
 }
 
 
 }
 
 

+/* Read P as a hex value.  Return true if every character made sense,
+   storing the result in *RESULT.  Leave *RESULT unchanged otherwise.  */
+
+static int
+read_hex_value (const char *p, ULONGEST *result)
+{
+  ULONGEST retval;
+
+  retval = 0;
+  while (*p != 0)
+    {
+      retval <<= 4;
+      if (*p >= '0' && *p <= '9')
+       retval |= *p - '0';
+      else if (*p >= 'A' && *p <= 'F')
+       retval |= *p - 'A' + 10;
+      else if (*p >= 'a' && *p <= 'f')
+       retval |= *p - 'a' + 10;
+      else
+       return 0;
+      p++;
+    }
+  *result = retval;
+  return 1;
+}
+
+

 /* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
    timed out.  TIMEOUT specifies timeout value in seconds.
  */
 /* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
    timed out.  TIMEOUT specifies timeout value in seconds.
  */


@@ -598,35 +628,6 @@ mips_expect (const char *string)
   return mips_expect_timeout (string, remote_timeout);
 }
 
   return mips_expect_timeout (string, remote_timeout);
 }
 

-/* Read the required number of characters into the given buffer (which
-   is assumed to be large enough). The only failure is a timeout. */
-static int
-mips_getstring (char *string, int n)
-{
-  char *p = string;
-  int c;
-
-  immediate_quit++;
-  while (n > 0)
-    {
-      c = serial_readchar (mips_desc, remote_timeout);
-
-      if (c == SERIAL_TIMEOUT)
-       {
-         fprintf_unfiltered (gdb_stderr,
-                "Failed to read %d characters from target (TIMEOUT)\n", n);
-         immediate_quit--;
-         return 0;
-       }
-
-      *p++ = c;
-      n--;
-    }
-
-  immediate_quit--;
-  return 1;
-}
-

 /* Read a character from the remote, aborting on error.  Returns
    SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
    returns).  FIXME: If we see the string mips_monitor_prompt from the
 /* Read a character from the remote, aborting on error.  Returns
    SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
    returns).  FIXME: If we see the string mips_monitor_prompt from the


@@ -648,7 +649,7 @@ mips_readchar (int timeout)
   static int state = 0;
   int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
 
   static int state = 0;
   int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
 

-  {
+  { /* FIXME this whole block is dead code! */

     int i;
 
     i = timeout;
     int i;
 
     i = timeout;


@@ -1228,12 +1229,14 @@ mips_request (int cmd,
              int timeout,
              char *buff)
 {
              int timeout,
              char *buff)
 {

+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;

   char myBuff[DATA_MAXLEN + 1];
   char myBuff[DATA_MAXLEN + 1];

+  char response_string[17];

   int len;
   int rpid;
   char rcmd;
   int rerrflg;
   int len;
   int rpid;
   char rcmd;
   int rerrflg;

-  unsigned long rresponse;
+  ULONGEST rresponse;

 
   if (buff == (char *) NULL)
     buff = myBuff;
 
   if (buff == (char *) NULL)
     buff = myBuff;


@@ -1242,8 +1245,16 @@ mips_request (int cmd,
     {
       if (mips_need_reply)
        internal_error (__FILE__, __LINE__,
     {
       if (mips_need_reply)
        internal_error (__FILE__, __LINE__,

-                       "mips_request: Trying to send command before reply");
-      sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
+                       _("mips_request: Trying to send command before reply"));
+      /* 'T' sets a register to a 64-bit value, so make sure we use
+        the right conversion function.  */
+      if (cmd == 'T')
+       sprintf (buff, "0x0 %c 0x%s 0x%s", cmd,
+                phex_nz (addr, addr_size), phex_nz (data, 8));
+      else
+       sprintf (buff, "0x0 %c 0x%s 0x%s", cmd,
+                phex_nz (addr, addr_size), phex_nz (data, addr_size));
+

       mips_send_packet (buff, 1);
       mips_need_reply = 1;
     }
       mips_send_packet (buff, 1);
       mips_need_reply = 1;
     }


@@ -1253,15 +1264,16 @@ mips_request (int cmd,
 
   if (!mips_need_reply)
     internal_error (__FILE__, __LINE__,
 
   if (!mips_need_reply)
     internal_error (__FILE__, __LINE__,

-                   "mips_request: Trying to get reply before command");
+                   _("mips_request: Trying to get reply before command"));

 
   mips_need_reply = 0;
 
   len = mips_receive_packet (buff, 1, timeout);
   buff[len] = '\0';
 
 
   mips_need_reply = 0;
 
   len = mips_receive_packet (buff, 1, timeout);
   buff[len] = '\0';
 

-  if (sscanf (buff, "0x%x %c 0x%x 0x%lx",
-             &rpid, &rcmd, &rerrflg, &rresponse) != 4
+  if (sscanf (buff, "0x%x %c 0x%x 0x%16s",
+             &rpid, &rcmd, &rerrflg, response_string) != 4
+      || !read_hex_value (response_string, &rresponse)

       || (cmd != '\0' && rcmd != cmd))
     mips_error ("Bad response from remote board");
 
       || (cmd != '\0' && rcmd != cmd))
     mips_error ("Bad response from remote board");
 


@@ -1282,18 +1294,25 @@ mips_request (int cmd,
   return rresponse;
 }
 
   return rresponse;
 }
 

+/* Cleanup associated with mips_initialize().  */
+

 static void
 mips_initialize_cleanups (void *arg)
 {
   mips_initializing = 0;
 }
 
 static void
 mips_initialize_cleanups (void *arg)
 {
   mips_initializing = 0;
 }
 

+/* Cleanup associated with mips_exit_debug().  */
+

 static void
 mips_exit_cleanups (void *arg)
 {
   mips_exiting = 0;
 }
 
 static void
 mips_exit_cleanups (void *arg)
 {
   mips_exiting = 0;
 }
 

+/* Send a command and wait for that command to be echoed back.  Wait,
+   too, for the following prompt.  */
+

 static void
 mips_send_command (const char *cmd, int prompt)
 {
 static void
 mips_send_command (const char *cmd, int prompt)
 {


@@ -1305,6 +1324,7 @@ mips_send_command (const char *cmd, int prompt)
 }
 
 /* Enter remote (dbx) debug mode: */
 }
 
 /* Enter remote (dbx) debug mode: */

+

 static void
 mips_enter_debug (void)
 {
 static void
 mips_enter_debug (void)
 {


@@ -1329,12 +1349,14 @@ mips_enter_debug (void)
 
   {
     char buff[DATA_MAXLEN + 1];
 
   {
     char buff[DATA_MAXLEN + 1];

+

     if (mips_receive_packet (buff, 1, 3) < 0)
       mips_error ("Failed to initialize (didn't receive packet).");
   }
 }
 
 /* Exit remote (dbx) debug mode, returning to the monitor prompt: */
     if (mips_receive_packet (buff, 1, 3) < 0)
       mips_error ("Failed to initialize (didn't receive packet).");
   }
 }
 
 /* Exit remote (dbx) debug mode, returning to the monitor prompt: */

+

 static int
 mips_exit_debug (void)
 {
 static int
 mips_exit_debug (void)
 {


@@ -1343,7 +1365,7 @@ mips_exit_debug (void)
 
   mips_exiting = 1;
 
 
   mips_exiting = 1;
 

-  if (mips_monitor != MON_IDT)
+  if (mips_monitor != MON_IDT && mips_monitor != MON_ROCKHOPPER)

     {
       /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
          so we do not get a reply to this command: */
     {
       /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
          so we do not get a reply to this command: */


@@ -1482,7 +1504,7 @@ mips_initialize (void)
 
   /* Clear all breakpoints: */
   if ((mips_monitor == MON_IDT
 
   /* Clear all breakpoints: */
   if ((mips_monitor == MON_IDT

-       && clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
+       && mips_clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)

       || mips_monitor == MON_LSI)
     monitor_supports_breakpoints = 1;
   else
       || mips_monitor == MON_LSI)
     monitor_supports_breakpoints = 1;
   else


@@ -1494,13 +1516,10 @@ mips_initialize (void)
      the request itself succeeds or fails.  */
 
   mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
      the request itself succeeds or fails.  */
 
   mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);

-  /* FIXME: cagney/2002-11-29: Force the update of selected frame.
-     This shouldn't be necessary, only many many places still refer to
-     selected_frame directly (instead of using get_selected_frame().  */
-  get_selected_frame (); /* Hack!!!  */

 }
 
 /* Open a connection to the remote board.  */
 }
 
 /* Open a connection to the remote board.  */

+

 static void
 common_open (struct target_ops *ops, char *name, int from_tty,
             enum mips_monitor_type new_monitor,
 static void
 common_open (struct target_ops *ops, char *name, int from_tty,
             enum mips_monitor_type new_monitor,


@@ -1525,8 +1544,7 @@ device is attached to the target board (e.g., /dev/ttya).\n"
 
   /* Parse the serial port name, the optional TFTP name, and the
      optional local TFTP name.  */
 
   /* Parse the serial port name, the optional TFTP name, and the
      optional local TFTP name.  */

-  if ((argv = buildargv (name)) == NULL)
-    nomem (0);
+  argv = gdb_buildargv (name);

   make_cleanup_freeargv (argv);
 
   serial_port_name = xstrdup (argv[0]);
   make_cleanup_freeargv (argv);
 
   serial_port_name = xstrdup (argv[0]);


@@ -1607,33 +1625,35 @@ device is attached to the target board (e.g., /dev/ttya).\n"
   /* Switch to using remote target now.  */
   push_target (ops);
 
   /* Switch to using remote target now.  */
   push_target (ops);
 

-  /* FIXME: Should we call start_remote here?  */
+  inferior_ptid = remote_mips_ptid;
+  inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
+  add_thread_silent (inferior_ptid);

 
   /* Try to figure out the processor model if possible.  */
 
   /* Try to figure out the processor model if possible.  */

-  ptype = mips_read_processor_type ();
-  if (ptype)
-    mips_set_processor_type_command (xstrdup (ptype), 0);
+  deprecated_mips_set_processor_regs_hack ();

 
   /* This is really the job of start_remote however, that makes an
      assumption that the target is about to print out a status message
      of some sort.  That doesn't happen here (in fact, it may not be
      possible to get the monitor to send the appropriate packet).  */
 
 
   /* This is really the job of start_remote however, that makes an
      assumption that the target is about to print out a status message
      of some sort.  That doesn't happen here (in fact, it may not be
      possible to get the monitor to send the appropriate packet).  */
 

-  flush_cached_frames ();
+  reinit_frame_cache ();

   registers_changed ();
   registers_changed ();

-  stop_pc = read_pc ();
-  print_stack_frame (get_selected_frame (), -1, 1);
+  stop_pc = regcache_read_pc (get_current_regcache ());
+  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);

   xfree (serial_port_name);
 }
 
   xfree (serial_port_name);
 }
 

+/* Open a connection to an IDT board.  */
+

 static void
 mips_open (char *name, int from_tty)
 {
   const char *monitor_prompt = NULL;
 static void
 mips_open (char *name, int from_tty)
 {
   const char *monitor_prompt = NULL;

-  if (TARGET_ARCHITECTURE != NULL
-      && TARGET_ARCHITECTURE->arch == bfd_arch_mips)
+  if (gdbarch_bfd_arch_info (target_gdbarch) != NULL
+      && gdbarch_bfd_arch_info (target_gdbarch)->arch == bfd_arch_mips)

     {
     {

-    switch (TARGET_ARCHITECTURE->mach)
+    switch (gdbarch_bfd_arch_info (target_gdbarch)->mach)

       {
       case bfd_mach_mips4100:
       case bfd_mach_mips4300:
       {
       case bfd_mach_mips4100:
       case bfd_mach_mips4300:


@@ -1649,18 +1669,32 @@ mips_open (char *name, int from_tty)
   common_open (&mips_ops, name, from_tty, MON_IDT, monitor_prompt);
 }
 
   common_open (&mips_ops, name, from_tty, MON_IDT, monitor_prompt);
 }
 

+/* Open a connection to a PMON board.  */
+

 static void
 pmon_open (char *name, int from_tty)
 {
   common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
 }
 
 static void
 pmon_open (char *name, int from_tty)
 {
   common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
 }
 

+/* Open a connection to a DDB board.  */
+

 static void
 ddb_open (char *name, int from_tty)
 {
   common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
 }
 
 static void
 ddb_open (char *name, int from_tty)
 {
   common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
 }
 

+/* Open a connection to a rockhopper board.  */
+
+static void
+rockhopper_open (char *name, int from_tty)
+{
+  common_open (&rockhopper_ops, name, from_tty, MON_ROCKHOPPER, "NEC01>");
+}
+
+/* Open a connection to an LSI board.  */
+

 static void
 lsi_open (char *name, int from_tty)
 {
 static void
 lsi_open (char *name, int from_tty)
 {


@@ -1685,12 +1719,14 @@ mips_close (int quitting)
 
       close_ports ();
     }
 
       close_ports ();
     }

+
+  generic_mourn_inferior ();

 }
 
 /* Detach from the remote board.  */
 
 static void
 }
 
 /* Detach from the remote board.  */
 
 static void

-mips_detach (char *args, int from_tty)
+mips_detach (struct target_ops *ops, char *args, int from_tty)

 {
   if (args)
     error ("Argument given to \"detach\" when remotely debugging.");
 {
   if (args)
     error ("Argument given to \"detach\" when remotely debugging.");


@@ -1708,7 +1744,8 @@ mips_detach (char *args, int from_tty)
    where PMON does return a reply.  */
 
 static void
    where PMON does return a reply.  */
 
 static void

-mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
+mips_resume (struct target_ops *ops,
+            ptid_t ptid, int step, enum target_signal siggnal)

 {
   int err;
 
 {
   int err;
 


@@ -1721,6 +1758,7 @@ mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
 
 /* Return the signal corresponding to SIG, where SIG is the number which
    the MIPS protocol uses for the signal.  */
 
 /* Return the signal corresponding to SIG, where SIG is the number which
    the MIPS protocol uses for the signal.  */

+

 static enum target_signal
 mips_signal_from_protocol (int sig)
 {
 static enum target_signal
 mips_signal_from_protocol (int sig)
 {


@@ -1738,16 +1776,45 @@ mips_signal_from_protocol (int sig)
   return (enum target_signal) sig;
 }
 
   return (enum target_signal) sig;
 }
 

+/* Set the register designated by REGNO to the value designated by VALUE.  */
+
+static void
+mips_set_register (int regno, ULONGEST value)
+{
+  char buf[MAX_REGISTER_SIZE];
+  struct regcache *regcache = get_current_regcache ();
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+  /* We got the number the register holds, but gdb expects to see a
+     value in the target byte ordering.  */
+
+  if (mips_monitor != MON_ROCKHOPPER
+      && (regno == mips_regnum (gdbarch)->pc || regno < 32))
+    /* Some 64-bit boards have monitors that only send the bottom 32 bits.
+       In such cases we can only really debug 32-bit code properly so,
+       when reading a GPR or the PC, assume that the full 64-bit
+       value is the sign extension of the lower 32 bits.  */
+    store_signed_integer (buf, register_size (gdbarch, regno), byte_order,
+                          value);
+  else
+    store_unsigned_integer (buf, register_size (gdbarch, regno), byte_order,
+                            value);
+
+  regcache_raw_supply (regcache, regno, buf);
+}
+

 /* Wait until the remote stops, and return a wait status.  */
 
 static ptid_t
 /* Wait until the remote stops, and return a wait status.  */
 
 static ptid_t

-mips_wait (ptid_t ptid, struct target_waitstatus *status)
+mips_wait (struct target_ops *ops,
+          ptid_t ptid, struct target_waitstatus *status, int options)

 {
   int rstatus;
   int err;
   char buff[DATA_MAXLEN];
 {
   int rstatus;
   int err;
   char buff[DATA_MAXLEN];

-  int rpc, rfp, rsp;
-  char flags[20];
+  ULONGEST rpc, rfp, rsp;
+  char pc_string[17], fp_string[17], sp_string[17], flags[20];

   int nfields;
   int i;
 
   int nfields;
   int i;
 


@@ -1787,23 +1854,19 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
 
   /* See if we got back extended status.  If so, pick out the pc, fp, sp, etc... */
 
 
   /* See if we got back extended status.  If so, pick out the pc, fp, sp, etc... */
 

-  nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
-                   &rpc, &rfp, &rsp, flags);
-  if (nfields >= 3)
+  nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%16s 0x%16s 0x%16s 0x%*x %s",
+                   pc_string, fp_string, sp_string, flags);
+  if (nfields >= 3
+      && read_hex_value (pc_string, &rpc)
+      && read_hex_value (fp_string, &rfp)
+      && read_hex_value (sp_string, &rsp))

     {
     {

-      char buf[MAX_REGISTER_SIZE];
-
-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rpc);
-      supply_register (PC_REGNUM, buf);
-
-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (PC_REGNUM), rfp);
-      supply_register (30, buf);       /* This register they are avoiding and so it is unnamed */
+      struct regcache *regcache = get_current_regcache ();
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);

 
 

-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp);
-      supply_register (SP_REGNUM, buf);
-
-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
-      supply_register (DEPRECATED_FP_REGNUM, buf);
+      mips_set_register (gdbarch_pc_regnum (gdbarch), rpc);
+      mips_set_register (30, rfp);
+      mips_set_register (gdbarch_sp_regnum (gdbarch), rsp);

 
       if (nfields == 9)
        {
 
       if (nfields == 9)
        {


@@ -1827,7 +1890,7 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
          fetch breakpoint, not a data watchpoint.  FIXME when PMON
          provides some way to tell us what type of breakpoint it is.  */
       int i;
          fetch breakpoint, not a data watchpoint.  FIXME when PMON
          provides some way to tell us what type of breakpoint it is.  */
       int i;

-      CORE_ADDR pc = read_pc ();
+      CORE_ADDR pc = regcache_read_pc (get_current_regcache ());

 
       hit_watchpoint = 1;
       for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
 
       hit_watchpoint = 1;
       for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)


@@ -1878,7 +1941,7 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
        {
          char *func_name;
          CORE_ADDR func_start;
        {
          char *func_name;
          CORE_ADDR func_start;

-         CORE_ADDR pc = read_pc ();
+         CORE_ADDR pc = regcache_read_pc (get_current_regcache ());

 
          find_pc_partial_function (pc, &func_name, &func_start, NULL);
          if (func_name != NULL && strcmp (func_name, "_exit") == 0
 
          find_pc_partial_function (pc, &func_name, &func_start, NULL);
          if (func_name != NULL && strcmp (func_name, "_exit") == 0


@@ -1896,62 +1959,64 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
 }
 
 /* We have to map between the register numbers used by gdb and the
 }
 
 /* We have to map between the register numbers used by gdb and the

-   register numbers used by the debugging protocol.  This function
-   assumes that we are using tm-mips.h.  */
+   register numbers used by the debugging protocol.  */

 
 #define REGNO_OFFSET 96
 
 static int
 
 #define REGNO_OFFSET 96
 
 static int

-mips_map_regno (int regno)
+mips_map_regno (struct gdbarch *gdbarch, int regno)

 {
   if (regno < 32)
     return regno;
 {
   if (regno < 32)
     return regno;

-  if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32)
-    return regno - FP0_REGNUM + 32;
-  switch (regno)
-    {
-    case PC_REGNUM:
-      return REGNO_OFFSET + 0;
-    case CAUSE_REGNUM:
-      return REGNO_OFFSET + 1;
-    case HI_REGNUM:
-      return REGNO_OFFSET + 2;
-    case LO_REGNUM:
-      return REGNO_OFFSET + 3;
-    case FCRCS_REGNUM:
-      return REGNO_OFFSET + 4;
-    case FCRIR_REGNUM:
-      return REGNO_OFFSET + 5;
-    default:
-      /* FIXME: Is there a way to get the status register?  */
-      return 0;
-    }
+  if (regno >= mips_regnum (gdbarch)->fp0
+      && regno < mips_regnum (gdbarch)->fp0 + 32)
+    return regno - mips_regnum (gdbarch)->fp0 + 32;
+  else if (regno == mips_regnum (gdbarch)->pc)
+    return REGNO_OFFSET + 0;
+  else if (regno == mips_regnum (gdbarch)->cause)
+    return REGNO_OFFSET + 1;
+  else if (regno == mips_regnum (gdbarch)->hi)
+    return REGNO_OFFSET + 2;
+  else if (regno == mips_regnum (gdbarch)->lo)
+    return REGNO_OFFSET + 3;
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
+    return REGNO_OFFSET + 4;
+  else if (regno == mips_regnum (gdbarch)->fp_implementation_revision)
+    return REGNO_OFFSET + 5;
+  else
+    /* FIXME: Is there a way to get the status register?  */
+    return 0;

 }
 
 /* Fetch the remote registers.  */
 
 static void
 }
 
 /* Fetch the remote registers.  */
 
 static void

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

 {
 {

-  unsigned LONGEST val;
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+  ULONGEST val;

   int err;
 
   if (regno == -1)
     {
   int err;
 
   if (regno == -1)
     {

-      for (regno = 0; regno < NUM_REGS; regno++)
-       mips_fetch_registers (regno);
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+       mips_fetch_registers (ops, regcache, regno);

       return;
     }
 
       return;
     }
 

-  if (regno == DEPRECATED_FP_REGNUM || regno == ZERO_REGNUM)
-    /* DEPRECATED_FP_REGNUM on the mips is a hack which is just
+  if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
+      || regno == MIPS_ZERO_REGNUM)
+    /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just

        supposed to read zero (see also mips-nat.c).  */
     val = 0;
   else
     {
       /* If PMON doesn't support this register, don't waste serial
          bandwidth trying to read it.  */
        supposed to read zero (see also mips-nat.c).  */
     val = 0;
   else
     {
       /* If PMON doesn't support this register, don't waste serial
          bandwidth trying to read it.  */

-      int pmon_reg = mips_map_regno (regno);
+      int pmon_reg = mips_map_regno (gdbarch, regno);
+

       if (regno != 0 && pmon_reg == 0)
        val = 0;
       else
       if (regno != 0 && pmon_reg == 0)
        val = 0;
       else


@@ -1959,9 +2024,9 @@ mips_fetch_registers (int regno)
          /* Unfortunately the PMON version in the Vr4300 board has been
             compiled without the 64bit register access commands. This
             means we cannot get hold of the full register width. */
          /* Unfortunately the PMON version in the Vr4300 board has been
             compiled without the 64bit register access commands. This
             means we cannot get hold of the full register width. */

-         if (mips_monitor == MON_DDB)
-           val = (unsigned) mips_request ('t', pmon_reg, 0,
-                                          &err, mips_receive_wait, NULL);
+         if (mips_monitor == MON_DDB || mips_monitor == MON_ROCKHOPPER)
+           val = mips_request ('t', pmon_reg, 0,
+                               &err, mips_receive_wait, NULL);

          else
            val = mips_request ('r', pmon_reg, 0,
                                &err, mips_receive_wait, NULL);
          else
            val = mips_request ('r', pmon_reg, 0,
                                &err, mips_receive_wait, NULL);


@@ -1971,64 +2036,60 @@ mips_fetch_registers (int regno)
        }
     }
 
        }
     }
 

-  {
-    char buf[MAX_REGISTER_SIZE];
-
-    /* We got the number the register holds, but gdb expects to see a
-       value in the target byte ordering.  */
-    store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (regno), val);
-    supply_register (regno, buf);
-  }
+  mips_set_register (regno, val);

 }
 
 /* Prepare to store registers.  The MIPS protocol can store individual
    registers, so this function doesn't have to do anything.  */
 
 static void
 }
 
 /* Prepare to store registers.  The MIPS protocol can store individual
    registers, so this function doesn't have to do anything.  */
 
 static void

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

 {
 }
 
 /* Store remote register(s).  */
 
 static void
 {
 }
 
 /* Store remote register(s).  */
 
 static void

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

 {
 {

+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  ULONGEST val;

   int err;
 
   if (regno == -1)
     {
   int err;
 
   if (regno == -1)
     {

-      for (regno = 0; regno < NUM_REGS; regno++)
-       mips_store_registers (regno);
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+       mips_store_registers (ops, regcache, regno);

       return;
     }
 
       return;
     }
 

-  mips_request ('R', mips_map_regno (regno),
-               read_register (regno),
+  regcache_cooked_read_unsigned (regcache, regno, &val);
+  mips_request (mips_monitor == MON_ROCKHOPPER ? 'T' : 'R',
+               mips_map_regno (gdbarch, regno),
+               val,

                &err, mips_receive_wait, NULL);
   if (err)
     mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
 }
 
                &err, mips_receive_wait, NULL);
   if (err)
     mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
 }
 

-/* Fetch a word from the target board.  */
+/* Fetch a word from the target board.  Return word fetched in location
+   addressed by VALP.  Return 0 when successful; return positive error
+   code when not.  */

 
 

-static unsigned int
-mips_fetch_word (CORE_ADDR addr)
+static int
+mips_fetch_word (CORE_ADDR addr, unsigned int *valp)

 {
 {

-  unsigned int val;

   int err;
 
   int err;
 

-  val = mips_request ('d', addr, 0, &err, mips_receive_wait, NULL);
+  *valp = mips_request ('d', addr, 0, &err, mips_receive_wait, NULL);

   if (err)
     {
       /* Data space failed; try instruction space.  */
   if (err)
     {
       /* Data space failed; try instruction space.  */

-      val = mips_request ('i', addr, 0, &err,
-                         mips_receive_wait, NULL);
-      if (err)
-       mips_error ("Can't read address 0x%s: %s",
-                   paddr_nz (addr), safe_strerror (errno));
+      *valp = mips_request ('i', addr, 0, &err,
+                           mips_receive_wait, NULL);

     }
     }

-  return val;
+  return err;

 }
 
 /* Store a word to the target board.  Returns errno code or zero for
 }
 
 /* Store a word to the target board.  Returns errno code or zero for


@@ -2037,7 +2098,7 @@ mips_fetch_word (CORE_ADDR addr)
 
 /* FIXME! make sure only 32-bit quantities get stored! */
 static int
 
 /* FIXME! make sure only 32-bit quantities get stored! */
 static int

-mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
+mips_store_word (CORE_ADDR addr, unsigned int val, int *old_contents)

 {
   int err;
   unsigned int oldcontents;
 {
   int err;
   unsigned int oldcontents;


@@ -2053,7 +2114,7 @@ mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
        return errno;
     }
   if (old_contents != NULL)
        return errno;
     }
   if (old_contents != NULL)

-    store_unsigned_integer (old_contents, 4, oldcontents);
+    *old_contents = oldcontents;

   return 0;
 }
 
   return 0;
 }
 


@@ -2067,9 +2128,10 @@ mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
 static int mask_address_p = 1;
 
 static int
 static int mask_address_p = 1;
 
 static int

-mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,

                  struct mem_attrib *attrib, struct target_ops *target)
 {
                  struct mem_attrib *attrib, struct target_ops *target)
 {

+  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);

   int i;
   CORE_ADDR addr;
   int count;
   int i;
   CORE_ADDR addr;
   int count;


@@ -2093,16 +2155,25 @@ mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
       /* Fill start and end extra bytes of buffer with existing data.  */
       if (addr != memaddr || len < 4)
        {
       /* Fill start and end extra bytes of buffer with existing data.  */
       if (addr != memaddr || len < 4)
        {

+         unsigned int val;
+
+         if (mips_fetch_word (addr, &val))
+           return 0;
+

          /* Need part of initial word -- fetch it.  */
          /* Need part of initial word -- fetch it.  */

-         store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
+         store_unsigned_integer (&buffer[0], 4, byte_order, val);

        }
 
       if (count > 1)
        {
        }
 
       if (count > 1)
        {

+         unsigned int val;
+

          /* Need part of last word -- fetch it.  FIXME: we do this even
             if we don't need it.  */
          /* Need part of last word -- fetch it.  FIXME: we do this even
             if we don't need it.  */

-         store_unsigned_integer (&buffer[(count - 1) * 4], 4,
-                                 mips_fetch_word (addr + (count - 1) * 4));
+         if (mips_fetch_word (addr + (count - 1) * 4, &val))
+           return 0;
+
+         store_unsigned_integer (&buffer[(count - 1) * 4], 4, byte_order, val);

        }
 
       /* Copy data to be written over corresponding part of buffer */
        }
 
       /* Copy data to be written over corresponding part of buffer */


@@ -2113,9 +2184,10 @@ mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 
       for (i = 0; i < count; i++, addr += 4)
        {
 
       for (i = 0; i < count; i++, addr += 4)
        {

-         status = mips_store_word (addr,
-                              extract_unsigned_integer (&buffer[i * 4], 4),
-                                   NULL);
+         int word;
+
+         word = extract_unsigned_integer (&buffer[i * 4], 4, byte_order);
+         status = mips_store_word (addr, word, NULL);

          /* Report each kilobyte (we download 32-bit words at a time) */
          if (i % 256 == 255)
            {
          /* Report each kilobyte (we download 32-bit words at a time) */
          if (i % 256 == 255)
            {


@@ -2137,7 +2209,12 @@ mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
       /* Read all the longwords */
       for (i = 0; i < count; i++, addr += 4)
        {
       /* Read all the longwords */
       for (i = 0; i < count; i++, addr += 4)
        {

-         store_unsigned_integer (&buffer[i * 4], 4, mips_fetch_word (addr));
+         unsigned int val;
+
+         if (mips_fetch_word (addr, &val))
+           return 0;
+
+         store_unsigned_integer (&buffer[i * 4], 4, byte_order, val);

          QUIT;
        }
 
          QUIT;
        }
 


@@ -2161,10 +2238,13 @@ mips_files_info (struct target_ops *ignore)
    right port, we could interrupt the process with a break signal.  */
 
 static void
    right port, we could interrupt the process with a break signal.  */
 
 static void

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

 {
   if (!mips_wait_flag)
 {
   if (!mips_wait_flag)

-    return;
+    {
+      target_mourn_inferior ();
+      return;
+    }

 
   interrupt_count++;
 
 
   interrupt_count++;
 


@@ -2174,8 +2254,8 @@ mips_kill (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)? ")))

        {
          /* Clean up in such a way that mips_close won't try to talk to the
             board (it almost surely won't work since we weren't able to talk to
        {
          /* Clean up in such a way that mips_close won't try to talk to the
             board (it almost surely won't work since we weren't able to talk to


@@ -2186,7 +2266,7 @@ Give up (and stop debugging it)? "))
          printf_unfiltered ("Ending remote MIPS debugging.\n");
          target_mourn_inferior ();
 
          printf_unfiltered ("Ending remote MIPS debugging.\n");
          target_mourn_inferior ();
 

-         throw_exception (RETURN_QUIT);
+         deprecated_throw_reason (RETURN_QUIT);

        }
 
       target_terminal_inferior ();
        }
 
       target_terminal_inferior ();


@@ -2197,6 +2277,8 @@ Give up (and stop debugging it)? "))
 
   serial_send_break (mips_desc);
 
 
   serial_send_break (mips_desc);
 

+  target_mourn_inferior ();
+

 #if 0
   if (mips_is_open)
     {
 #if 0
   if (mips_is_open)
     {


@@ -2214,7 +2296,8 @@ Give up (and stop debugging it)? "))
 /* Start running on the target board.  */
 
 static void
 /* Start running on the target board.  */
 
 static void

-mips_create_inferior (char *execfile, char *args, char **env)
+mips_create_inferior (struct target_ops *ops, char *execfile,
+                     char *args, char **env, int from_tty)

 {
   CORE_ADDR entry_pt;
 
 {
   CORE_ADDR entry_pt;
 


@@ -2233,19 +2316,17 @@ Can't pass arguments to remote MIPS board; arguments ignored.");
 
   init_wait_for_inferior ();
 
 
   init_wait_for_inferior ();
 

-  /* FIXME: Should we set inferior_ptid here?  */
-
-  proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
+  regcache_write_pc (get_current_regcache (), entry_pt);

 }
 
 }
 

-/* Clean up after a process.  Actually nothing to do.  */
+/* Clean up after a process. The bulk of the work is done in mips_close(),
+   which is called when unpushing the target.  */

 
 static void
 
 static void

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

 {
   if (current_ops != NULL)
     unpush_target (current_ops);
 {
   if (current_ops != NULL)
     unpush_target (current_ops);

-  generic_mourn_inferior ();

 }
 \f
 /* We can write a breakpoint and read the shadow contents in one
 }
 \f
 /* We can write a breakpoint and read the shadow contents in one


@@ -2254,155 +2335,37 @@ mips_mourn_inferior (void)
 /* Insert a breakpoint.  On targets that don't have built-in
    breakpoint support, we read the contents of the target location and
    stash it, then overwrite it with a breakpoint instruction.  ADDR is
 /* Insert a breakpoint.  On targets that don't have built-in
    breakpoint support, we read the contents of the target location and
    stash it, then overwrite it with a breakpoint instruction.  ADDR is

-   the target location in the target machine.  CONTENTS_CACHE is a
-   pointer to memory allocated for saving the target contents.  It is
-   guaranteed by the caller to be long enough to save the breakpoint
-   length returned by BREAKPOINT_FROM_PC.  */
+   the target location in the target machine.  BPT is the breakpoint
+   being inserted or removed, which contains memory for saving the
+   target contents.  */

 
 static int
 
 static int

-mips_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
+mips_insert_breakpoint (struct gdbarch *gdbarch,
+                       struct bp_target_info *bp_tgt)

 {
   if (monitor_supports_breakpoints)
 {
   if (monitor_supports_breakpoints)

-    return set_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
+    return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
+                               BREAK_FETCH);

   else
   else

-    return memory_insert_breakpoint (addr, contents_cache);
+    return memory_insert_breakpoint (gdbarch, bp_tgt);

 }
 
 }
 

-static int
-mips_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-  if (monitor_supports_breakpoints)
-    return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
-  else
-    return memory_remove_breakpoint (addr, contents_cache);
-}
-
-#if 0                          /* currently not used */
-/* PMON does not currently provide support for the debug mode 'b'
-   commands to manipulate breakpoints. However, if we wanted to use
-   the monitor breakpoints (rather than the GDB BREAK_INSN version)
-   then this code performs the work needed to leave debug mode,
-   set/clear the breakpoint, and then return to debug mode. */
-
-#define PMON_MAX_BP (33)       /* 32 SW, 1 HW */
-static CORE_ADDR mips_pmon_bp_info[PMON_MAX_BP];
-/* NOTE: The code relies on this vector being zero-initialised by the system */
-
-static int
-pmon_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-  int status;
-
-  if (monitor_supports_breakpoints)
-    {
-      char tbuff[12];          /* space for breakpoint command */
-      int bpnum;
-      CORE_ADDR bpaddr;
-
-      /* PMON does not support debug level breakpoint set/remove: */
-      if (mips_exit_debug ())
-       mips_error ("Failed to exit debug mode");
-
-      sprintf (tbuff, "b %08x\r", addr);
-      mips_send_command (tbuff, 0);
-
-      mips_expect ("Bpt ");
-
-      if (!mips_getstring (tbuff, remote_timeout))
-       return 1;
-      tbuff[2] = '\0';         /* terminate the string */
-      if (sscanf (tbuff, "%d", &bpnum) != 1)
-       {
-         fprintf_unfiltered (gdb_stderr,
-             "Invalid decimal breakpoint number from target: %s\n", tbuff);
-         return 1;
-       }
-
-      mips_expect (" = ");
-
-      /* Lead in the hex number we are expecting: */
-      tbuff[0] = '0';
-      tbuff[1] = 'x';
-
-      /* FIXME!! only 8 bytes!  need to expand for Bfd64; 
-         which targets return 64-bit addresses?  PMON returns only 32! */
-      if (!mips_getstring (&tbuff[2], 8))
-       return 1;
-      tbuff[10] = '\0';                /* terminate the string */
-
-      if (sscanf (tbuff, "0x%08x", &bpaddr) != 1)
-       {
-         fprintf_unfiltered (gdb_stderr,
-                           "Invalid hex address from target: %s\n", tbuff);
-         return 1;
-       }
-
-      if (bpnum >= PMON_MAX_BP)
-       {
-         fprintf_unfiltered (gdb_stderr,
-                             "Error: Returned breakpoint number %d outside acceptable range (0..%d)\n",
-                             bpnum, PMON_MAX_BP - 1);
-         return 1;
-       }
-
-      if (bpaddr != addr)
-       fprintf_unfiltered (gdb_stderr, "Warning: Breakpoint addresses do not match: 0x%x != 0x%x\n", addr, bpaddr);
-
-      mips_pmon_bp_info[bpnum] = bpaddr;
-
-      mips_expect ("\r\n");
-      mips_expect (mips_monitor_prompt);
-
-      mips_enter_debug ();
-
-      return 0;
-    }
-
-  return mips_store_word (addr, BREAK_INSN, contents_cache);
-}
+/* Remove a breakpoint.  */

 
 static int
 
 static int

-pmon_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
+mips_remove_breakpoint (struct gdbarch *gdbarch,
+                       struct bp_target_info *bp_tgt)

 {
   if (monitor_supports_breakpoints)
 {
   if (monitor_supports_breakpoints)

-    {
-      int bpnum;
-      char tbuff[7];           /* enough for delete breakpoint command */
-
-      for (bpnum = 0; bpnum < PMON_MAX_BP; bpnum++)
-       if (mips_pmon_bp_info[bpnum] == addr)
-         break;
-
-      if (bpnum >= PMON_MAX_BP)
-       {
-         fprintf_unfiltered (gdb_stderr,
-                             "pmon_remove_breakpoint: Failed to find breakpoint at address 0x%s\n",
-                             paddr_nz (addr));
-         return 1;
-       }
-
-      if (mips_exit_debug ())
-       mips_error ("Failed to exit debug mode");
-
-      sprintf (tbuff, "db %02d\r", bpnum);
-
-      mips_send_command (tbuff, -1);
-      /* NOTE: If the breakpoint does not exist then a "Bpt <dd> not
-         set" message will be returned. */
-
-      mips_enter_debug ();
-
-      return 0;
-    }
-
-  return target_write_memory (addr, contents_cache, BREAK_INSN_SIZE);
+    return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
+                                 BREAK_FETCH);
+  else
+    return memory_remove_breakpoint (gdbarch, bp_tgt);

 }
 }

-#endif
-

 
 /* Tell whether this target can support a hardware breakpoint.  CNT
    is the number of hardware breakpoints already installed.  This
 
 /* Tell whether this target can support a hardware breakpoint.  CNT
    is the number of hardware breakpoints already installed.  This

-   implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
+   implements the target_can_use_hardware_watchpoint macro.  */

 
 int
 mips_can_use_watchpoint (int type, int cnt, int othertype)
 
 int
 mips_can_use_watchpoint (int type, int cnt, int othertype)


@@ -2434,53 +2397,35 @@ calculate_mask (CORE_ADDR addr, int len)
 }
 
 
 }
 
 

-/* Insert a hardware breakpoint.  This works only on LSI targets, which
-   implement ordinary breakpoints using hardware facilities.  */
-
-static int
-remote_mips_insert_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-  if (strcmp (target_shortname, "lsi") == 0)
-    return mips_insert_breakpoint (addr, contents_cache);
-  else
-    return -1;
-}
-
-
-/* Remove a hardware breakpoint.  This works only on LSI targets, which
-   implement ordinary breakpoints using hardware facilities.  */
-
-static int
-remote_mips_remove_hw_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-  if (strcmp (target_shortname, "lsi") == 0)
-    return mips_remove_breakpoint (addr, contents_cache);
-  else
-    return -1;
-}
-

 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
    watchpoint. */
 
 int
 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
    watchpoint. */
 
 int

-mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
+mips_insert_watchpoint (CORE_ADDR addr, int len, int type,
+                       struct expression *cond)

 {
 {

-  if (set_breakpoint (addr, len, type))
+  if (mips_set_breakpoint (addr, len, type))

     return -1;
 
   return 0;
 }
 
     return -1;
 
   return 0;
 }
 

+/* Remove a watchpoint.  */
+

 int
 int

-mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
+mips_remove_watchpoint (CORE_ADDR addr, int len, int type,
+                       struct expression *cond)

 {
 {

-  if (clear_breakpoint (addr, len, type))
+  if (mips_clear_breakpoint (addr, len, type))

     return -1;
 
   return 0;
 }
 
     return -1;
 
   return 0;
 }
 

+/* Test to see if a watchpoint has been hit.  Return 1 if so; return 0,
+   if not.  */
+

 int
 mips_stopped_by_watchpoint (void)
 {
 int
 mips_stopped_by_watchpoint (void)
 {


@@ -2491,18 +2436,18 @@ mips_stopped_by_watchpoint (void)
 /* Insert a breakpoint.  */
 
 static int
 /* Insert a breakpoint.  */
 
 static int

-set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
+mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type)

 {
 {

-  return common_breakpoint (1, addr, len, type);
+  return mips_common_breakpoint (1, addr, len, type);

 }
 
 
 /* Clear a breakpoint.  */
 
 static int
 }
 
 
 /* Clear a breakpoint.  */
 
 static int

-clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
+mips_clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)

 {
 {

-  return common_breakpoint (0, addr, len, type);
+  return mips_common_breakpoint (0, addr, len, type);

 }
 
 
 }
 
 


@@ -2511,13 +2456,13 @@ clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
    print the warning text and return 0.  If it's an error, print
    the error text and return 1.  <ADDR> is the address of the breakpoint
    that was being set.  <RERRFLG> is the error code returned by PMON. 
    print the warning text and return 0.  If it's an error, print
    the error text and return 1.  <ADDR> is the address of the breakpoint
    that was being set.  <RERRFLG> is the error code returned by PMON. 

-   This is a helper function for common_breakpoint.  */
+   This is a helper function for mips_common_breakpoint.  */

 
 static int
 
 static int

-check_lsi_error (CORE_ADDR addr, int rerrflg)
+mips_check_lsi_error (CORE_ADDR addr, int rerrflg)

 {
   struct lsi_error *err;
 {
   struct lsi_error *err;

-  char *saddr = paddr_nz (addr);       /* printable address string */
+  const char *saddr = paddress (target_gdbarch, addr);

 
   if (rerrflg == 0)            /* no error */
     return 0;
 
   if (rerrflg == 0)            /* no error */
     return 0;


@@ -2528,20 +2473,21 @@ check_lsi_error (CORE_ADDR addr, int rerrflg)
       if (monitor_warnings)
        {
          int found = 0;
       if (monitor_warnings)
        {
          int found = 0;

+

          for (err = lsi_warning_table; err->code != 0; err++)
            {
              if ((err->code & rerrflg) == err->code)
                {
                  found = 1;
          for (err = lsi_warning_table; err->code != 0; err++)
            {
              if ((err->code & rerrflg) == err->code)
                {
                  found = 1;

-                 fprintf_unfiltered (gdb_stderr,
-                                 "common_breakpoint (0x%s): Warning: %s\n",
+                 fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (%s): Warning: %s\n",

                                      saddr,
                                      err->string);
                }
            }
          if (!found)
                                      saddr,
                                      err->string);
                }
            }
          if (!found)

-           fprintf_unfiltered (gdb_stderr,
-                       "common_breakpoint (0x%s): Unknown warning: 0x%x\n",
+           fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (%s): Unknown warning: 0x%x\n",

                                saddr,
                                rerrflg);
        }
                                saddr,
                                rerrflg);
        }


@@ -2553,15 +2499,15 @@ check_lsi_error (CORE_ADDR addr, int rerrflg)
     {
       if ((err->code & rerrflg) == err->code)
        {
     {
       if ((err->code & rerrflg) == err->code)
        {

-         fprintf_unfiltered (gdb_stderr,
-                             "common_breakpoint (0x%s): Error: %s\n",
+         fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (%s): Error: %s\n",

                              saddr,
                              err->string);
          return 1;
        }
     }
                              saddr,
                              err->string);
          return 1;
        }
     }

-  fprintf_unfiltered (gdb_stderr,
-                     "common_breakpoint (0x%s): Unknown error: 0x%x\n",
+  fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (%s): Unknown error: 0x%x\n",

                      saddr,
                      rerrflg);
   return 1;
                      saddr,
                      rerrflg);
   return 1;


@@ -2582,14 +2528,15 @@ check_lsi_error (CORE_ADDR addr, int rerrflg)
    Return 0 if successful; otherwise 1.  */
 
 static int
    Return 0 if successful; otherwise 1.  */
 
 static int

-common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
+mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)

 {
 {

+  int addr_size = gdbarch_addr_bit (target_gdbarch) / 8;

   char buf[DATA_MAXLEN + 1];
   char cmd, rcmd;
   int rpid, rerrflg, rresponse, rlen;
   int nfields;
 
   char buf[DATA_MAXLEN + 1];
   char cmd, rcmd;
   int rpid, rerrflg, rresponse, rlen;
   int nfields;
 

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

 
   if (mips_monitor == MON_LSI)
     {
 
   if (mips_monitor == MON_LSI)
     {


@@ -2615,8 +2562,9 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
          /* Clear the table entry and tell PMON to clear the breakpoint.  */
          if (i == MAX_LSI_BREAKPOINTS)
            {
          /* Clear the table entry and tell PMON to clear the breakpoint.  */
          if (i == MAX_LSI_BREAKPOINTS)
            {

-             warning ("common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
-                      paddr_nz (addr));
+             warning ("\
+mips_common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
+                      paddress (target_gdbarch, addr));

              return 1;
            }
 
              return 1;
            }
 


@@ -2629,9 +2577,11 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
 
          nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
          if (nfields != 2)
 
          nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
          if (nfields != 2)

-           mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
+           mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",
+                       buf);

 
 

-         return (check_lsi_error (addr, rerrflg));
+         return (mips_check_lsi_error (addr, rerrflg));

        }
       else
        /* set a breakpoint */
        }
       else
        /* set a breakpoint */


@@ -2663,15 +2613,16 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
          if (type == BREAK_FETCH)      /* instruction breakpoint */
            {
              cmd = 'B';
          if (type == BREAK_FETCH)      /* instruction breakpoint */
            {
              cmd = 'B';

-             sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
+             sprintf (buf, "0x0 B 0x%s 0x0", phex_nz (addr, addr_size));

            }
          else
            /* watchpoint */
            {
              cmd = 'A';
            }
          else
            /* watchpoint */
            {
              cmd = 'A';

-             sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
-                    type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
-                      paddr_nz (addr + len - 1));
+             sprintf (buf, "0x0 A 0x%s 0x%x 0x%s",
+                      phex_nz (addr, addr_size),
+                      type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
+                      phex_nz (addr + len - 1, addr_size));

            }
          mips_send_packet (buf, 1);
 
            }
          mips_send_packet (buf, 1);
 


@@ -2681,10 +2632,12 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
          nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
                            &rpid, &rcmd, &rresponse, &rerrflg);
          if (nfields != 4 || rcmd != cmd || rresponse > 255)
          nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
                            &rpid, &rcmd, &rresponse, &rerrflg);
          if (nfields != 4 || rcmd != cmd || rresponse > 255)

-           mips_error ("common_breakpoint: Bad response from remote board: %s", buf);
+           mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",
+                       buf);

 
          if (rerrflg != 0)
 
          if (rerrflg != 0)

-           if (check_lsi_error (addr, rerrflg))
+           if (mips_check_lsi_error (addr, rerrflg))

              return 1;
 
          /* rresponse contains PMON's breakpoint number.  Record the
              return 1;
 
          /* rresponse contains PMON's breakpoint number.  Record the


@@ -2711,6 +2664,7 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
       if (set)                 /* set a breakpoint */
        {
          char *flags;
       if (set)                 /* set a breakpoint */
        {
          char *flags;

+

          switch (type)
            {
            case BREAK_WRITE:   /* write */
          switch (type)
            {
            case BREAK_WRITE:   /* write */


@@ -2726,17 +2680,17 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
              flags = "f";
              break;
            default:
              flags = "f";
              break;
            default:

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

            }
 
          cmd = 'B';
            }
 
          cmd = 'B';

-         sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
-                  paddr_nz (mask), flags);
+         sprintf (buf, "0x0 B 0x%s 0x%s %s", phex_nz (addr, addr_size),
+                  phex_nz (mask, addr_size), flags);

        }
       else
        {
          cmd = 'b';
        }
       else
        {
          cmd = 'b';

-         sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
+         sprintf (buf, "0x0 b 0x%s", phex_nz (addr, addr_size));

        }
 
       mips_send_packet (buf, 1);
        }
 
       mips_send_packet (buf, 1);


@@ -2748,7 +2702,8 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
                        &rpid, &rcmd, &rerrflg, &rresponse);
 
       if (nfields != 4 || rcmd != cmd)
                        &rpid, &rcmd, &rerrflg, &rresponse);
 
       if (nfields != 4 || rcmd != cmd)

-       mips_error ("common_breakpoint: Bad response from remote board: %s",
+       mips_error ("\
+mips_common_breakpoint: Bad response from remote board: %s",

                    buf);
 
       if (rerrflg != 0)
                    buf);
 
       if (rerrflg != 0)


@@ -2758,15 +2713,20 @@ common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
          if (mips_monitor == MON_DDB)
            rresponse = rerrflg;
          if (rresponse != 22)  /* invalid argument */
          if (mips_monitor == MON_DDB)
            rresponse = rerrflg;
          if (rresponse != 22)  /* invalid argument */

-           fprintf_unfiltered (gdb_stderr,
-                            "common_breakpoint (0x%s):  Got error: 0x%x\n",
-                               paddr_nz (addr), rresponse);
+           fprintf_unfiltered (gdb_stderr, "\
+mips_common_breakpoint (%s):  Got error: 0x%x\n",
+                               paddress (target_gdbarch, addr), rresponse);

          return 1;
        }
     }
   return 0;
 }
 \f
          return 1;
        }
     }
   return 0;
 }
 \f

+/* Send one S record as specified by SREC of length LEN, starting
+   at ADDR.  Note, however, that ADDR is not used except to provide
+   a useful message to the user in the event that a NACK is received
+   from the board.  */
+

 static void
 send_srec (char *srec, int len, CORE_ADDR addr)
 {
 static void
 send_srec (char *srec, int len, CORE_ADDR addr)
 {


@@ -2786,7 +2746,8 @@ send_srec (char *srec, int len, CORE_ADDR addr)
        case 0x6:               /* ACK */
          return;
        case 0x15:              /* NACK */
        case 0x6:               /* ACK */
          return;
        case 0x15:              /* NACK */

-         fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s!  Retrying.\n", paddr_u (addr));
+         fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s!  Retrying.\n",
+                             paddress (target_gdbarch, addr));

          continue;
        default:
          error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
          continue;
        default:
          error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);


@@ -2834,20 +2795,21 @@ mips_load_srec (char *args)
          /* FIXME!  vma too small????? */
          printf_filtered ("%s\t: 0x%4lx .. 0x%4lx  ", s->name,
                           (long) s->vma,
          /* FIXME!  vma too small????? */
          printf_filtered ("%s\t: 0x%4lx .. 0x%4lx  ", s->name,
                           (long) s->vma,

-                          (long) (s->vma + s->_raw_size));
+                          (long) (s->vma + bfd_get_section_size (s)));

          gdb_flush (gdb_stdout);
 
          gdb_flush (gdb_stdout);
 

-         for (i = 0; i < s->_raw_size; i += numbytes)
+         for (i = 0; i < bfd_get_section_size (s); i += numbytes)

            {
            {

-             numbytes = min (srec_frame, s->_raw_size - i);
+             numbytes = min (srec_frame, bfd_get_section_size (s) - i);

 
              bfd_get_section_contents (abfd, s, buffer, i, numbytes);
 
 
              bfd_get_section_contents (abfd, s, buffer, i, numbytes);
 

-             reclen = mips_make_srec (srec, '3', s->vma + i, buffer, numbytes);
+             reclen = mips_make_srec (srec, '3', s->vma + i, 
+                                      buffer, numbytes);

              send_srec (srec, reclen, s->vma + i);
 
              send_srec (srec, reclen, s->vma + i);
 

-             if (ui_load_progress_hook)
-               ui_load_progress_hook (s->name, i);
+             if (deprecated_ui_load_progress_hook)
+               deprecated_ui_load_progress_hook (s->name, i);

 
              if (hashmark)
                {
 
              if (hashmark)
                {


@@ -2985,6 +2947,7 @@ static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01
    at a time (range 0..63).  Keep a checksum if required (passed
    pointer non-NULL). The function returns the number of encoded
    characters written into the buffer. */
    at a time (range 0..63).  Keep a checksum if required (passed
    pointer non-NULL). The function returns the number of encoded
    characters written into the buffer. */

+

 static int
 pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
 {
 static int
 pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
 {


@@ -3029,6 +2992,7 @@ pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
 
 /* Shorthand function (that could be in-lined) to output the zero-fill
    escape sequence into the data stream. */
 
 /* Shorthand function (that could be in-lined) to output the zero-fill
    escape sequence into the data stream. */

+

 static int
 pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
 {
 static int
 pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
 {


@@ -3041,6 +3005,20 @@ pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
   return (recsize + count + 2);
 }
 
   return (recsize + count + 2);
 }
 

+/* Add the checksum specified by *VALUE to end of the record under
+   construction.  *BUF specifies the location at which to begin
+   writing characters comprising the checksum information.  RECSIZE
+   specifies the size of the record constructed thus far.  (A trailing
+   NUL character may be present in the buffer holding the record, but
+   the record size does not include this character.)
+
+   Return the total size of the record after adding the checksum escape,
+   the checksum itself, and the trailing newline.
+   
+   The checksum specified by *VALUE is zeroed out prior to returning. 
+   Additionally, *BUF is updated to refer to the location just beyond
+   the record elements added by this call.  */
+

 static int
 pmon_checkset (int recsize, char **buff, int *value)
 {
 static int
 pmon_checkset (int recsize, char **buff, int *value)
 {


@@ -3071,6 +3049,32 @@ pmon_checkset (int recsize, char **buff, int *value)
 /* NOTE: This constant depends on the monitor being used. This value
    is for PMON 5.x on the Cogent Vr4300 board. */
 
 /* NOTE: This constant depends on the monitor being used. This value
    is for PMON 5.x on the Cogent Vr4300 board. */
 

+/* Create a FastLoad format record.
+
+   *OUTBUF is the buffer into which a FastLoad formatted record is
+   written.  On return, the pointer position represented by *OUTBUF
+   is updated to point at the end of the data, i.e. the next position
+   in the buffer that may be written.  No attempt is made to NUL-
+   terminate this portion of the record written to the buffer.
+   
+   INBUF contains the binary input data from which the FastLoad
+   formatted record will be built.  *INPTR is an index into this
+   buffer.  *INPTR is updated as the input is consumed.  Thus, on
+   return, the caller has access to the position of the next input
+   byte yet to be processed.  INAMOUNT is the size, in bytes, of the
+   input data.
+
+   *RECSIZE will be written with the size of the record written to the
+   output buffer prior to returning.  This size does not include a
+   NUL-termination byte as none is written to the output buffer.
+
+   *CSUM is the output buffer checksum.  It is updated as data is
+   written to the output buffer.
+   
+   *ZEROFILL is the current number of 3-byte zero sequences that have
+   been encountered.  It is both an input and an output to this
+   function.  */
+

 static void
 pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
                   int inamount, int *recsize, unsigned int *csum,
 static void
 pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
                   int inamount, int *recsize, unsigned int *csum,


@@ -3099,6 +3103,7 @@ pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
       else
        {
          unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
       else
        {
          unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);

+

          /* Simple check for zero data. TODO: A better check would be
             to check the last, and then the middle byte for being zero
             (if the first byte is not). We could then check for
          /* Simple check for zero data. TODO: A better check would be
             to check the last, and then the middle byte for being zero
             (if the first byte is not). We could then check for


@@ -3128,6 +3133,10 @@ pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
   return;
 }
 
   return;
 }
 

+/* Attempt to read an ACK.  If an ACK is not read in a timely manner,
+   output the message specified by MESG.  Return -1 for failure, 0
+   for success.  */
+

 static int
 pmon_check_ack (char *mesg)
 {
 static int
 pmon_check_ack (char *mesg)
 {


@@ -3170,6 +3179,12 @@ pmon_start_download (void)
     }
 }
 
     }
 }
 

+/* Look for the string specified by STRING sent from the target board
+   during a download operation.  If the string in question is not
+   seen, output an error message, remove the temporary file, if
+   appropriate, and return 0.  Otherwise, return 1 to indicate
+   success.  */
+

 static int
 mips_expect_download (char *string)
 {
 static int
 mips_expect_download (char *string)
 {


@@ -3184,26 +3199,48 @@ mips_expect_download (char *string)
     return 1;
 }
 
     return 1;
 }
 

+/* Look for messages from the target board associated with the entry
+   address.
+
+   NOTE: This function doesn't indicate success or failure, so we
+   have no way to determine whether or not the output from the board
+   was correctly seen.  However, given that other items are checked
+   after this, it seems unlikely that those checks will pass if this
+   check doesn't first (silently) pass.  */
+

 static void
 pmon_check_entry_address (char *entry_address, int final)
 {
   char hexnumber[9];           /* includes '\0' space */
 static void
 pmon_check_entry_address (char *entry_address, int final)
 {
   char hexnumber[9];           /* includes '\0' space */

+

   mips_expect_timeout (entry_address, tftp_in_use ? 15 : remote_timeout);
   sprintf (hexnumber, "%x", final);
   mips_expect (hexnumber);
   mips_expect ("\r\n");
 }
 
   mips_expect_timeout (entry_address, tftp_in_use ? 15 : remote_timeout);
   sprintf (hexnumber, "%x", final);
   mips_expect (hexnumber);
   mips_expect ("\r\n");
 }
 

+/* Look for messages from the target board showing the total number of
+   bytes downloaded to the board.  Output 1 for success if the tail
+   end of the message was read correctly, 0 otherwise.  */
+

 static int
 pmon_check_total (int bintotal)
 {
   char hexnumber[9];           /* includes '\0' space */
 static int
 pmon_check_total (int bintotal)
 {
   char hexnumber[9];           /* includes '\0' space */

+

   mips_expect ("\r\ntotal = 0x");
   sprintf (hexnumber, "%x", bintotal);
   mips_expect (hexnumber);
   return mips_expect_download (" bytes\r\n");
 }
 
   mips_expect ("\r\ntotal = 0x");
   sprintf (hexnumber, "%x", bintotal);
   mips_expect (hexnumber);
   return mips_expect_download (" bytes\r\n");
 }
 

+/* Look for the termination messages associated with the end of
+   a download to the board.
+
+   Also, when `tftp_in_use' is set, issue the load command to the
+   board causing the file to be transferred.  (This is done prior
+   to looking for the above mentioned termination messages.)  */
+   

 static void
 pmon_end_download (int final, int bintotal)
 {
 static void
 pmon_end_download (int final, int bintotal)
 {


@@ -3224,7 +3261,8 @@ pmon_end_download (int final, int bintotal)
        chmod (tftp_localname, stbuf.st_mode | S_IROTH);
 
       /* Must reinitialize the board to prevent PMON from crashing.  */
        chmod (tftp_localname, stbuf.st_mode | S_IROTH);
 
       /* Must reinitialize the board to prevent PMON from crashing.  */

-      mips_send_command ("initEther\r", -1);
+      if (mips_monitor != MON_ROCKHOPPER)
+       mips_send_command ("initEther\r", -1);

 
       /* Send the load command.  */
       cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
 
       /* Send the load command.  */
       cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);


@@ -3252,6 +3290,11 @@ pmon_end_download (int final, int bintotal)
       if (!pmon_check_total (bintotal))
        return;
       break;
       if (!pmon_check_total (bintotal))
        return;
       break;

+    case MON_ROCKHOPPER:
+      if (!pmon_check_total (bintotal))
+       return;
+      pmon_check_entry_address ("Entry Address  = ", final);
+      break;

     default:
       pmon_check_entry_address ("Entry Address  = ", final);
       pmon_check_ack ("termination");
     default:
       pmon_check_entry_address ("Entry Address  = ", final);
       pmon_check_ack ("termination");


@@ -3264,6 +3307,10 @@ pmon_end_download (int final, int bintotal)
     remove (tftp_localname);   /* Remove temporary file */
 }
 
     remove (tftp_localname);   /* Remove temporary file */
 }
 

+/* Write the buffer specified by BUFFER of length LENGTH to either
+   the board or the temporary file that'll eventually be transferred
+   to the board.  */
+

 static void
 pmon_download (char *buffer, int length)
 {
 static void
 pmon_download (char *buffer, int length)
 {


@@ -3273,6 +3320,9 @@ pmon_download (char *buffer, int length)
     serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
 }
 
     serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
 }
 

+/* Open object or executable file, FILE, and send it to the board
+   using the FastLoad format.  */
+

 static void
 pmon_load_fast (char *file)
 {
 static void
 pmon_load_fast (char *file)
 {


@@ -3321,11 +3371,11 @@ pmon_load_fast (char *file)
   for (s = abfd->sections; s && !finished; s = s->next)
     if (s->flags & SEC_LOAD)   /* only deal with loadable sections */
       {
   for (s = abfd->sections; s && !finished; s = s->next)
     if (s->flags & SEC_LOAD)   /* only deal with loadable sections */
       {

-       bintotal += s->_raw_size;
-       final = (s->vma + s->_raw_size);
+       bintotal += bfd_get_section_size (s);
+       final = (s->vma + bfd_get_section_size (s));

 
        printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, (unsigned int) s->vma,
 
        printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, (unsigned int) s->vma,

-                        (unsigned int) (s->vma + s->_raw_size));
+                        (unsigned int) (s->vma + bfd_get_section_size (s)));

        gdb_flush (gdb_stdout);
 
        /* Output the starting address */
        gdb_flush (gdb_stdout);
 
        /* Output the starting address */


@@ -3346,11 +3396,13 @@ pmon_load_fast (char *file)
 
            reclen = 0;
 
 
            reclen = 0;
 

-           for (i = 0; ((i < s->_raw_size) && !finished); i += binamount)
+           for (i = 0;
+                i < bfd_get_section_size (s) && !finished;
+                i += binamount)

              {
                int binptr = 0;
 
              {
                int binptr = 0;
 

-               binamount = min (BINCHUNK, s->_raw_size - i);
+               binamount = min (BINCHUNK, bfd_get_section_size (s) - i);

 
                bfd_get_section_contents (abfd, s, binbuf, i, binamount);
 
 
                bfd_get_section_contents (abfd, s, binbuf, i, binamount);
 


@@ -3358,7 +3410,8 @@ pmon_load_fast (char *file)
                   the line: */
                for (; ((binamount - binptr) > 0);)
                  {
                   the line: */
                for (; ((binamount - binptr) > 0);)
                  {

-                   pmon_make_fastrec (&bp, binbuf, &binptr, binamount, &reclen, &csum, &zerofill);
+                   pmon_make_fastrec (&bp, binbuf, &binptr, binamount, 
+                                      &reclen, &csum, &zerofill);

                    if (reclen >= (MAXRECSIZE - CHECKSIZE))
                      {
                        reclen = pmon_checkset (reclen, &bp, &csum);
                    if (reclen >= (MAXRECSIZE - CHECKSIZE))
                      {
                        reclen = pmon_checkset (reclen, &bp, &csum);


@@ -3370,8 +3423,8 @@ pmon_load_fast (char *file)
                            break;
                          }
 
                            break;
                          }
 

-                       if (ui_load_progress_hook)
-                         ui_load_progress_hook (s->name, i);
+                       if (deprecated_ui_load_progress_hook)
+                         deprecated_ui_load_progress_hook (s->name, i);

 
                        if (hashmark)
                          {
 
                        if (hashmark)
                          {


@@ -3426,6 +3479,8 @@ pmon_load_fast (char *file)
 static void
 mips_load (char *file, int from_tty)
 {
 static void
 mips_load (char *file, int from_tty)
 {

+  struct regcache *regcache;
+

   /* Get the board out of remote debugging mode.  */
   if (mips_exit_debug ())
     error ("mips_load:  Couldn't get into monitor mode.");
   /* Get the board out of remote debugging mode.  */
   if (mips_exit_debug ())
     error ("mips_load:  Couldn't get into monitor mode.");


@@ -3438,27 +3493,47 @@ mips_load (char *file, int from_tty)
   mips_initialize ();
 
   /* Finally, make the PC point at the start address */
   mips_initialize ();
 
   /* Finally, make the PC point at the start address */

+  regcache = get_current_regcache ();

   if (mips_monitor != MON_IDT)
     {
       /* Work around problem where PMON monitor updates the PC after a load
          to a different value than GDB thinks it has. The following ensures
   if (mips_monitor != MON_IDT)
     {
       /* Work around problem where PMON monitor updates the PC after a load
          to a different value than GDB thinks it has. The following ensures

-         that the write_pc() WILL update the PC value: */
-      deprecated_register_valid[PC_REGNUM] = 0;
+         that the regcache_write_pc() WILL update the PC value: */
+      regcache_invalidate (regcache,
+                          mips_regnum (get_regcache_arch (regcache))->pc);

     }
   if (exec_bfd)
     }
   if (exec_bfd)

-    write_pc (bfd_get_start_address (exec_bfd));
-
-  inferior_ptid = null_ptid;   /* No process now */
+    regcache_write_pc (regcache, bfd_get_start_address (exec_bfd));
+}

 
 

-/* 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... */
+/* Check to see if a thread is still alive.  */
+ 
+static int
+mips_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+  if (ptid_equal (ptid, remote_mips_ptid))
+    /* The monitor's task is always alive.  */
+    return 1;

 
 

-  clear_symtab_users ();
+  return 0;

 }
 
 }
 

+/* Convert a thread ID to a string.  Returns the string in a static
+   buffer.  */
+
+static char *
+mips_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  static char buf[64];
+
+  if (ptid_equal (ptid, remote_mips_ptid))
+    {
+      xsnprintf (buf, sizeof buf, "Thread <main>");
+      return buf;
+    }
+
+  return normal_pid_to_str (ptid);
+}

 
 /* Pass the command argument as a packet to PMON verbatim.  */
 
 
 /* Pass the command argument as a packet to PMON verbatim.  */
 


@@ -3479,6 +3554,10 @@ pmon_command (char *args, int from_tty)
 \f
 extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
 
 \f
 extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
 

+/* Initialize mips_ops, lsi_ops, ddb_ops, pmon_ops, and rockhopper_ops.
+   Create target specific commands and perform other initializations
+   specific to this file.  */
+

 void
 _initialize_remote_mips (void)
 {
 void
 _initialize_remote_mips (void)
 {


@@ -3490,7 +3569,7 @@ _initialize_remote_mips (void)
   mips_ops.to_fetch_registers = mips_fetch_registers;
   mips_ops.to_store_registers = mips_store_registers;
   mips_ops.to_prepare_to_store = mips_prepare_to_store;
   mips_ops.to_fetch_registers = mips_fetch_registers;
   mips_ops.to_store_registers = mips_store_registers;
   mips_ops.to_prepare_to_store = mips_prepare_to_store;

-  mips_ops.to_xfer_memory = mips_xfer_memory;
+  mips_ops.deprecated_xfer_memory = mips_xfer_memory;

   mips_ops.to_files_info = mips_files_info;
   mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
   mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
   mips_ops.to_files_info = mips_files_info;
   mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
   mips_ops.to_remove_breakpoint = mips_remove_breakpoint;


@@ -3502,16 +3581,19 @@ _initialize_remote_mips (void)
   mips_ops.to_load = mips_load;
   mips_ops.to_create_inferior = mips_create_inferior;
   mips_ops.to_mourn_inferior = mips_mourn_inferior;
   mips_ops.to_load = mips_load;
   mips_ops.to_create_inferior = mips_create_inferior;
   mips_ops.to_mourn_inferior = mips_mourn_inferior;

+  mips_ops.to_thread_alive = mips_thread_alive;
+  mips_ops.to_pid_to_str = mips_pid_to_str;
+  mips_ops.to_log_command = serial_log_command;

   mips_ops.to_stratum = process_stratum;
   mips_ops.to_stratum = process_stratum;

-  mips_ops.to_has_all_memory = 1;
-  mips_ops.to_has_memory = 1;
-  mips_ops.to_has_stack = 1;
-  mips_ops.to_has_registers = 1;
-  mips_ops.to_has_execution = 1;
+  mips_ops.to_has_all_memory = default_child_has_all_memory;
+  mips_ops.to_has_memory = default_child_has_memory;
+  mips_ops.to_has_stack = default_child_has_stack;
+  mips_ops.to_has_registers = default_child_has_registers;
+  mips_ops.to_has_execution = default_child_has_execution;

   mips_ops.to_magic = OPS_MAGIC;
 
   /* Copy the common fields to all four target vectors.  */
   mips_ops.to_magic = OPS_MAGIC;
 
   /* Copy the common fields to all four target vectors.  */

-  pmon_ops = ddb_ops = lsi_ops = mips_ops;
+  rockhopper_ops = pmon_ops = ddb_ops = lsi_ops = mips_ops;

 
   /* Initialize target-specific fields in the target vectors.  */
   mips_ops.to_shortname = "mips";
 
   /* Initialize target-specific fields in the target vectors.  */
   mips_ops.to_shortname = "mips";


@@ -3541,6 +3623,11 @@ of the TFTP temporary file, if it differs from the filename seen by the board.";
   ddb_ops.to_open = ddb_open;
   ddb_ops.to_wait = mips_wait;
 
   ddb_ops.to_open = ddb_open;
   ddb_ops.to_wait = mips_wait;
 

+  rockhopper_ops.to_shortname = "rockhopper";
+  rockhopper_ops.to_doc = ddb_ops.to_doc;
+  rockhopper_ops.to_open = rockhopper_open;
+  rockhopper_ops.to_wait = mips_wait;
+

   lsi_ops.to_shortname = "lsi";
   lsi_ops.to_doc = pmon_ops.to_doc;
   lsi_ops.to_open = lsi_open;
   lsi_ops.to_shortname = "lsi";
   lsi_ops.to_doc = pmon_ops.to_doc;
   lsi_ops.to_open = lsi_open;


@@ -3551,55 +3638,63 @@ of the TFTP temporary file, if it differs from the filename seen by the board.";
   add_target (&pmon_ops);
   add_target (&ddb_ops);
   add_target (&lsi_ops);
   add_target (&pmon_ops);
   add_target (&ddb_ops);
   add_target (&lsi_ops);

-
-  add_show_from_set (
-                     add_set_cmd ("timeout", no_class, var_zinteger,
-                                  (char *) &mips_receive_wait,
-                      "Set timeout in seconds for remote MIPS serial I/O.",
-                                  &setlist),
-                     &showlist);
-
-  add_show_from_set (
-                 add_set_cmd ("retransmit-timeout", no_class, var_zinteger,
-                              (char *) &mips_retransmit_wait,
-                              "Set retransmit timeout in seconds for remote MIPS serial I/O.\n\
+  add_target (&rockhopper_ops);
+
+  add_setshow_zinteger_cmd ("timeout", no_class, &mips_receive_wait, _("\
+Set timeout in seconds for remote MIPS serial I/O."), _("\
+Show timeout in seconds for remote MIPS serial I/O."), NULL,
+                           NULL,
+                           NULL, /* FIXME: i18n: */
+                           &setlist, &showlist);
+
+  add_setshow_zinteger_cmd ("retransmit-timeout", no_class,
+                           &mips_retransmit_wait, _("\
+Set retransmit timeout in seconds for remote MIPS serial I/O."), _("\
+Show retransmit timeout in seconds for remote MIPS serial I/O."), _("\

 This is the number of seconds to wait for an acknowledgement to a packet\n\
 This is the number of seconds to wait for an acknowledgement to a packet\n\

-before resending the packet.", &setlist),
-                     &showlist);
-
-  add_show_from_set (
-                  add_set_cmd ("syn-garbage-limit", no_class, var_zinteger,
-                               (char *) &mips_syn_garbage,
-                               "Set the maximum number of characters to ignore when scanning for a SYN.\n\
+before resending the packet."),
+                           NULL,
+                           NULL, /* FIXME: i18n: */
+                           &setlist, &showlist);
+
+  add_setshow_zinteger_cmd ("syn-garbage-limit", no_class,
+                           &mips_syn_garbage,  _("\
+Set the maximum number of characters to ignore when scanning for a SYN."), _("\
+Show the maximum number of characters to ignore when scanning for a SYN."), _("\

 This is the maximum number of characters GDB will ignore when trying to\n\
 This is the maximum number of characters GDB will ignore when trying to\n\

-synchronize with the remote system.  A value of -1 means that there is no limit\n\
-(Note that these characters are printed out even though they are ignored.)",
-                               &setlist),
-                     &showlist);
-
-  add_show_from_set
-    (add_set_cmd ("monitor-prompt", class_obscure, var_string,
-                 (char *) &mips_monitor_prompt,
-                 "Set the prompt that GDB expects from the monitor.",
-                 &setlist),
-     &showlist);
-
-  add_show_from_set (
-              add_set_cmd ("monitor-warnings", class_obscure, var_zinteger,
-                           (char *) &monitor_warnings,
-                           "Set printing of monitor warnings.\n"
-               "When enabled, monitor warnings about hardware breakpoints "
-                           "will be displayed.",
-                           &setlist),
-                     &showlist);
-
-  add_com ("pmon <command>", class_obscure, pmon_command,
-          "Send a packet to PMON (must be in debug mode).");
-
-  add_show_from_set (add_set_cmd ("mask-address", no_class,
-                                 var_boolean, &mask_address_p,
-                                 "Set zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets.\n\
-Use \"on\" to enable the masking and \"off\" to disable it.\n",
-                                 &setlist),
-                    &showlist);
+synchronize with the remote system.  A value of -1 means that there is no\n\
+limit. (Note that these characters are printed out even though they are\n\
+ignored.)"),
+                           NULL,
+                           NULL, /* FIXME: i18n: */
+                           &setlist, &showlist);
+
+  add_setshow_string_cmd ("monitor-prompt", class_obscure,
+                         &mips_monitor_prompt, _("\
+Set the prompt that GDB expects from the monitor."), _("\
+Show the prompt that GDB expects from the monitor."), NULL,
+                         NULL,
+                         NULL, /* FIXME: i18n: */
+                         &setlist, &showlist);
+
+  add_setshow_zinteger_cmd ("monitor-warnings", class_obscure,
+                           &monitor_warnings, _("\
+Set printing of monitor warnings."), _("\
+Show printing of monitor warnings."), _("\
+When enabled, monitor warnings about hardware breakpoints will be displayed."),
+                           NULL,
+                           NULL, /* FIXME: i18n: */
+                           &setlist, &showlist);
+
+  add_com ("pmon", class_obscure, pmon_command,
+          _("Send a packet to PMON (must be in debug mode)."));
+
+  add_setshow_boolean_cmd ("mask-address", no_class, &mask_address_p, _("\
+Set zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
+Show zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
+Use \"on\" to enable the masking and \"off\" to disable it."),
+                          NULL,
+                          NULL, /* FIXME: i18n: */
+                          &setlist, &showlist);
+  remote_mips_ptid = ptid_build (42000, 0, 42000);

 }
 }