projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
gdb
[deliverable/binutils-gdb.git] / gdb / remote-mips.c
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index 4886852e861259bc55faad3a6913ff934c309963..56f3f22bead0f32124d5dff2a55e5016863a1431 100644 (file)
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -1,7 +1,7 @@
 /* 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 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 +10,7 @@
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -19,9 +19,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "inferior.h"
 
 #include "defs.h"
 #include "inferior.h"
@@ -31,7 +29,7 @@
 #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 "gdb_string.h"
 #include "gdb_stat.h"
 #include "regcache.h"
@@ -86,37 +84,25 @@ 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 int mips_map_regno (int regno);
-
-static void mips_fetch_registers (int regno);
-
-static void mips_prepare_to_store (void);
-
-static void mips_store_registers (int regno);
+static void mips_prepare_to_store (struct regcache *regcache);
 
 static unsigned int mips_fetch_word (CORE_ADDR addr);
 
 static int mips_store_word (CORE_ADDR addr, unsigned int value,
 
 static unsigned int mips_fetch_word (CORE_ADDR addr);
 
 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);
 
@@ -144,12 +130,13 @@ 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;
 
 /* Forward declarations.  */
 extern struct target_ops mips_ops;
@@ -498,7 +485,7 @@ mips_error (char *string,...)
   printf_unfiltered ("Ending remote MIPS debugging.\n");
   target_mourn_inferior ();
 
   printf_unfiltered ("Ending remote MIPS debugging.\n");
   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
@@ -1200,6 +1187,7 @@ 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];
   int len;
   int rpid;
   char myBuff[DATA_MAXLEN + 1];
   int len;
   int rpid;
@@ -1214,8 +1202,9 @@ 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"));
+      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;
     }
@@ -1225,7 +1214,7 @@ 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;
 
 
   mips_need_reply = 0;
 
@@ -1454,7 +1443,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
@@ -1493,8 +1482,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]);
@@ -1585,10 +1573,10 @@ device is attached to the target board (e.g., /dev/ttya).\n"
      of some sort.  That doesn't happen here (in fact, it may not be
      possible to get the monitor to send the appropriate packet).  */
 
      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);
 }
 
@@ -1596,10 +1584,10 @@ static void
 mips_open (char *name, int from_tty)
 {
   const char *monitor_prompt = NULL;
 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:
@@ -1656,7 +1644,7 @@ mips_close (int quitting)
 /* 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.");
@@ -1674,7 +1662,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;
 
@@ -1707,7 +1696,8 @@ mips_signal_from_protocol (int sig)
 /* 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;
 {
   int rstatus;
   int err;
@@ -1757,19 +1747,31 @@ mips_wait (ptid_t ptid, struct target_waitstatus *status)
                    &rpc, &rfp, &rsp, flags);
   if (nfields >= 3)
     {
                    &rpc, &rfp, &rsp, flags);
   if (nfields >= 3)
     {
+      struct regcache *regcache = get_current_regcache ();
+      struct gdbarch *gdbarch = get_regcache_arch (regcache);
+      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
       char buf[MAX_REGISTER_SIZE];
 
       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, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)),
+        byte_order, rpc);
+      regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), 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 */
+      store_unsigned_integer
+       (buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)),
+        byte_order, rfp);
+      regcache_raw_supply (regcache, 30, buf); /* This register they are avoiding and so it is unnamed */
 
 
-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (SP_REGNUM), rsp);
-      supply_register (SP_REGNUM, buf);
+      store_unsigned_integer
+       (buf, register_size (gdbarch, gdbarch_sp_regnum (gdbarch)),
+        byte_order, rsp);
+      regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
 
 
-      store_unsigned_integer (buf, DEPRECATED_REGISTER_RAW_SIZE (DEPRECATED_FP_REGNUM), 0);
-      supply_register (DEPRECATED_FP_REGNUM, buf);
+      store_unsigned_integer
+       (buf, register_size (gdbarch, gdbarch_deprecated_fp_regnum (gdbarch)),
+        byte_order, 0);
+      regcache_raw_supply (regcache,
+                          gdbarch_deprecated_fp_regnum (gdbarch), buf);
 
       if (nfields == 9)
        {
 
       if (nfields == 9)
        {
@@ -1793,7 +1795,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++)
@@ -1844,7 +1846,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
@@ -1862,30 +1864,29 @@ 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 >= mips_regnum (current_gdbarch)->fp0
-      && regno < mips_regnum (current_gdbarch)->fp0 + 32)
-    return regno - mips_regnum (current_gdbarch)->fp0 + 32;
-  else if (regno == mips_regnum (current_gdbarch)->pc)
+  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;
     return REGNO_OFFSET + 0;
-  else if (regno == mips_regnum (current_gdbarch)->cause)
+  else if (regno == mips_regnum (gdbarch)->cause)
     return REGNO_OFFSET + 1;
     return REGNO_OFFSET + 1;
-  else if (regno == mips_regnum (current_gdbarch)->hi)
+  else if (regno == mips_regnum (gdbarch)->hi)
     return REGNO_OFFSET + 2;
     return REGNO_OFFSET + 2;
-  else if (regno == mips_regnum (current_gdbarch)->lo)
+  else if (regno == mips_regnum (gdbarch)->lo)
     return REGNO_OFFSET + 3;
     return REGNO_OFFSET + 3;
-  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
+  else if (regno == mips_regnum (gdbarch)->fp_control_status)
     return REGNO_OFFSET + 4;
     return REGNO_OFFSET + 4;
-  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
+  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 REGNO_OFFSET + 5;
   else
     /* FIXME: Is there a way to get the status register?  */
@@ -1895,27 +1896,31 @@ mips_map_regno (int regno)
 /* 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)
 {
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
   unsigned LONGEST val;
   int err;
 
   if (regno == -1)
     {
   unsigned LONGEST val;
   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
@@ -1940,8 +1945,9 @@ mips_fetch_registers (int regno)
 
     /* We got the number the register holds, but gdb expects to see a
        value in the target byte ordering.  */
 
     /* 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);
+    store_unsigned_integer (buf, register_size (gdbarch, regno),
+                           byte_order, val);
+    regcache_raw_supply (regcache, regno, buf);
   }
 }
 
   }
 }
 
@@ -1949,26 +1955,29 @@ mips_fetch_registers (int regno)
    registers, so this function doesn't have to do anything.  */
 
 static void
    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 ('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));
@@ -1989,8 +1998,8 @@ mips_fetch_word (CORE_ADDR addr)
       val = mips_request ('i', addr, 0, &err,
                          mips_receive_wait, NULL);
       if (err)
       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));
+       mips_error ("Can't read address %s: %s",
+                   paddress (target_gdbarch, addr), safe_strerror (errno));
     }
   return val;
 }
     }
   return val;
 }
@@ -2001,7 +2010,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;
@@ -2017,7 +2026,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;
 }
 
@@ -2031,9 +2040,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;
@@ -2058,14 +2068,15 @@ mips_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
       if (addr != memaddr || len < 4)
        {
          /* Need part of initial word -- fetch it.  */
       if (addr != memaddr || len < 4)
        {
          /* 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,
+                                 mips_fetch_word (addr));
        }
 
       if (count > 1)
        {
          /* Need part of last word -- fetch it.  FIXME: we do this even
             if we don't need it.  */
        }
 
       if (count > 1)
        {
          /* 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,
+         store_unsigned_integer (&buffer[(count - 1) * 4], 4, byte_order,
                                  mips_fetch_word (addr + (count - 1) * 4));
        }
 
                                  mips_fetch_word (addr + (count - 1) * 4));
        }
 
@@ -2077,9 +2088,9 @@ 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)
            {
@@ -2101,7 +2112,8 @@ 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));
+         store_unsigned_integer (&buffer[i * 4], 4, byte_order,
+                                 mips_fetch_word (addr));
          QUIT;
        }
 
          QUIT;
        }
 
@@ -2125,7 +2137,7 @@ 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)
     return;
 {
   if (!mips_wait_flag)
     return;
@@ -2138,8 +2150,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
@@ -2150,7 +2162,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 ();
@@ -2178,7 +2190,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;
 
@@ -2199,13 +2212,13 @@ Can't pass arguments to remote MIPS board; arguments ignored.");
 
   /* FIXME: Should we set inferior_ptid here?  */
 
 
   /* 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.  */
 
 static void
 }
 
 /* Clean up after a process.  Actually nothing to do.  */
 
 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);
@@ -2218,32 +2231,35 @@ 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
 }
 
 static int
-mips_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)
-    return clear_breakpoint (addr, MIPS_INSTLEN, BREAK_FETCH);
+    return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
+                                 BREAK_FETCH);
   else
   else
-    return memory_remove_breakpoint (addr, contents_cache);
+    return memory_remove_breakpoint (gdbarch, bp_tgt);
 }
 
 /* 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)
@@ -2282,7 +2298,7 @@ calculate_mask (CORE_ADDR addr, int len)
 int
 mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
 {
 int
 mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
 {
-  if (set_breakpoint (addr, len, type))
+  if (mips_set_breakpoint (addr, len, type))
     return -1;
 
   return 0;
     return -1;
 
   return 0;
@@ -2291,7 +2307,7 @@ mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
 int
 mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
 {
 int
 mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
 {
-  if (clear_breakpoint (addr, len, type))
+  if (mips_clear_breakpoint (addr, len, type))
     return -1;
 
   return 0;
     return -1;
 
   return 0;
@@ -2307,18 +2323,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);
 }
 
 
 }
 
 
@@ -2327,13 +2343,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 */
+  char *saddr = paddress (target_gdbarch, addr);
 
   if (rerrflg == 0)            /* no error */
     return 0;
 
   if (rerrflg == 0)            /* no error */
     return 0;
@@ -2349,15 +2365,15 @@ check_lsi_error (CORE_ADDR addr, int rerrflg)
              if ((err->code & rerrflg) == err->code)
                {
                  found = 1;
              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);
        }
@@ -2369,15 +2385,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;
@@ -2398,14 +2414,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)
     {
@@ -2431,8 +2448,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;
            }
 
@@ -2445,9 +2463,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 */
@@ -2479,15 +2499,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);
 
@@ -2497,10 +2518,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
@@ -2542,17 +2565,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);
@@ -2564,7 +2587,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)
@@ -2574,9 +2598,9 @@ 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 1;
        }
     }
@@ -2602,7 +2626,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);
@@ -2650,16 +2675,17 @@ 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);
 
              if (deprecated_ui_load_progress_hook)
              send_srec (srec, reclen, s->vma + i);
 
              if (deprecated_ui_load_progress_hook)
@@ -3137,11 +3163,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 */
@@ -3162,11 +3188,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);
 
@@ -3174,7 +3202,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);
@@ -3242,6 +3271,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.");
@@ -3254,15 +3285,17 @@ 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));
+    regcache_write_pc (regcache, bfd_get_start_address (exec_bfd));
 
   inferior_ptid = null_ptid;   /* No process now */
 
 
   inferior_ptid = null_ptid;   /* No process now */
 
@@ -3306,7 +3339,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;
@@ -3318,12 +3351,13 @@ _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_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.  */
@@ -3368,54 +3402,60 @@ of the TFTP temporary file, if it differs from the filename seen by the board.";
   add_target (&ddb_ops);
   add_target (&lsi_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_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);
 }
 }
GDB Binutils - Deliverables
This page took 0.038725 seconds and 4 git commands to generate.