Delete the remaining ROM monitor targets

Ref: https://sourceware.org/ml/gdb/2015-07/msg00011.html

All of these targets use gdb/monitor.c, which has bit rotted
years ago (I'd guess around ~6), and nobody seems to
have noticed:

 | target         | source               |
 |----------------+----------------------|
 | target dbug    | gdb/dbug-rom.c       |
 | target picobug | gdb/microblaze-rom.c |
 | target dink32  | gdb/dink32-rom.c     |
 | target m32r    | gdb/m32r-rom.c       |
 | target mon2000 | gdb/m32r-rom.c       |
 | target ppcbug  | gdb/ppcbug-rom.c     |

This deletes them, along with finally removing monitor.c.

A manual update will be done separately.

gdb/ChangeLog:
2015-08-24  Pedro Alves  <palves@redhat.com>

	* NEWS: Mention removed support for the various ROM monitors.
	* Makefile.in (ALL_TARGET_OBS): Remove dbug-rom.o, dink32-rom.o,
	ppcbug-rom.o, m32r-rom.o, dsrec.o and monitor.o from gdb_target_obs.
	* configure.tgt (h8300-*-*): Remove monitor.o and m32r-rom.o from
	gdb_target_obs.
	(m68*-*-*): Remove monitor.o dbug-rom.o and dsrec.o from
	gdb_target_obs.
	(microblaze*-linux-*): Remove microblaze-rom.o, monitor.o and
	dsrec.o from gdb_target_obs.
	(microblaze*-*-*): Remove microblaze-rom.o, monitor.o and dsrec.o
	from gdb_target_obs.
	(powerpc-*-lynx*178): Remove monitor.o and dsrec.o from
	gdb_target_obs.
	(powerpc*-*-*): Remove monitor.o, dsrec.o, ppcbug-rom.o and
	dink32-rom.o from gdb_target_obs.
	(sh*-*-linux*): Remove monitor.o and dsrec.o from gdb_target_obs.
	(sh*): Remove monitor.o and dsrec.o from gdb_target_obs.
	* dbug-rom.c, dink32-rom.c, dsrec.c, m32r-rom.c, microblaze-rom.c,
	monitor.c, monitor.h, ppcbug-rom.c, srec.h: Delete files.

13 files changed, 46 insertions, 4452 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 94bb7a5..ee9783a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,25 @@
+2015-08-24  Pedro Alves  <palves@redhat.com>
+
+	* NEWS: Mention removed support for the various ROM monitors.
+	* Makefile.in (ALL_TARGET_OBS): Remove dbug-rom.o, dink32-rom.o,
+	ppcbug-rom.o, m32r-rom.o, dsrec.o and monitor.o from gdb_target_obs.
+	* configure.tgt (h8300-*-*): Remove monitor.o and m32r-rom.o from
+	gdb_target_obs.
+	(m68*-*-*): Remove monitor.o dbug-rom.o and dsrec.o from
+	gdb_target_obs.
+	(microblaze*-linux-*): Remove microblaze-rom.o, monitor.o and
+	dsrec.o from gdb_target_obs.
+	(microblaze*-*-*): Remove microblaze-rom.o, monitor.o and dsrec.o
+	from gdb_target_obs.
+	(powerpc-*-lynx*178): Remove monitor.o and dsrec.o from
+	gdb_target_obs.
+	(powerpc*-*-*): Remove monitor.o, dsrec.o, ppcbug-rom.o and
+	dink32-rom.o from gdb_target_obs.
+	(sh*-*-linux*): Remove monitor.o and dsrec.o from gdb_target_obs.
+	(sh*): Remove monitor.o and dsrec.o from gdb_target_obs.
+	* dbug-rom.c, dink32-rom.c, dsrec.c, m32r-rom.c, microblaze-rom.c,
+	monitor.c, monitor.h, ppcbug-rom.c, srec.h: Delete files.
+
 2015-08-21  Pedro Alves  <palves@redhat.com>
 
 	* frame.c (null_frame_id): Explicitly zero-initialize.
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index 13b9041..398ef6a 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -715,7 +715,6 @@ ALL_TARGET_OBS = \
 	sol2-tdep.o \
 	solib-frv.o solib-svr4.o \
 	solib-darwin.o solib-dsbt.o \
-	dbug-rom.o dink32-rom.o ppcbug-rom.o m32r-rom.o dsrec.o monitor.o \
 	remote-m32r-sdi.o remote-mips.o \
 	xcoffread.o \
 	symfile-mem.o \
@@ -945,7 +944,7 @@ complaints.h gdb_proc_service.h gdb_regex.h xtensa-tdep.h inf-loop.h \
 common/gdb_wait.h common/gdb_assert.h solib.h ppc-tdep.h cp-support.h glibc-tdep.h \
 interps.h auxv.h gdbcmd.h tramp-frame.h mipsnbsd-tdep.h	\
 amd64-linux-tdep.h linespec.h location.h i387-tdep.h mn10300-tdep.h \
-sparc64-tdep.h monitor.h ppcobsd-tdep.h srec.h \
+sparc64-tdep.h ppcobsd-tdep.h \
 coff-pe-read.h parser-defs.h gdb_ptrace.h mips-linux-tdep.h \
 m68k-tdep.h spu-tdep.h jv-lang.h environ.h amd64-tdep.h \
 doublest.h regset.h hppa-tdep.h ppc-linux-tdep.h ppc64-tdep.h \
diff --git a/gdb/NEWS b/gdb/NEWS
index 2cedccd..9edfd5e 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -35,6 +35,15 @@ show debug bfd-cache
   The "/m" option is now considered deprecated: its "source-centric"
   output hasn't proved useful in practice.
 
+* Support for various ROM monitors has been removed:
+
+  target dbug		dBUG ROM monitor for Motorola ColdFire
+  target picobug	Motorola picobug monitor
+  target dink32		DINK32 ROM monitor for PowerPC
+  target m32r		Renesas M32R/D ROM monitor
+  target mon2000	mon2000 ROM monitor
+  target ppcbug		PPCBUG ROM monitor for PowerPC
+
 *** Changes in GDB 7.10
 
 * Support for process record-replay and reverse debugging on aarch64*-linux*
diff --git a/gdb/configure.tgt b/gdb/configure.tgt
index f2c1a2d..c42b4df 100644
--- a/gdb/configure.tgt
+++ b/gdb/configure.tgt
@@ -147,8 +147,8 @@ moxie-*-elf | moxie-*-moxiebox | moxie-*-rtems*)
 	;;
 
 h8300-*-*)
-	# Target: H8300 with HMS monitor and H8 simulator
-	gdb_target_obs="h8300-tdep.o monitor.o dsrec.o"
+	# Target: H8300 processor
+	gdb_target_obs="h8300-tdep.o"
 	gdb_sim=../sim/h8300/libsim.a
 	;;
 
@@ -289,8 +289,7 @@ m32r*-*-linux*)
 	;;
 m32r*-*-*)
 	# Target: Renesas m32r processor
-	gdb_target_obs="m32r-tdep.o monitor.o m32r-rom.o dsrec.o \
-			remote-m32r-sdi.o"
+	gdb_target_obs="m32r-tdep.o remote-m32r-sdi.o"
 	gdb_sim=../sim/m32r/libsim.a
 	;;
 
@@ -302,8 +301,8 @@ m68hc11*-*-*|m6811*-*-*)
 
 m68*-*-aout* | m68*-*-coff* | m68*-*-elf* | m68*-*-rtems* | m68*-*-uclinux* | \
 fido-*-elf*)
-	# Target: Motorola m68k embedded (e.g. bug monitors)
-	gdb_target_obs="m68k-tdep.o monitor.o dbug-rom.o dsrec.o"
+	# Target: Motorola m68k embedded
+	gdb_target_obs="m68k-tdep.o"
 	;;
 m68*-*-linux*)
 	# Target: Motorola m68k with a.out and ELF
@@ -333,13 +332,13 @@ mep-*-*)
 
 microblaze*-linux-*|microblaze*-*-linux*)
 	# Target: Xilinx MicroBlaze running Linux
-	gdb_target_obs="microblaze-tdep.o microblaze-linux-tdep.o microblaze-rom.o \
-			monitor.o dsrec.o solib-svr4.o symfile-mem.o linux-tdep.o"
+	gdb_target_obs="microblaze-tdep.o microblaze-linux-tdep.o solib-svr4.o \
+			symfile-mem.o linux-tdep.o"
 	gdb_sim=../sim/microblaze/libsim.a
 	;;
 microblaze*-*-*)
 	# Target: Xilinx MicroBlaze running standalone
-	gdb_target_obs="microblaze-tdep.o microblaze-rom.o monitor.o dsrec.o"
+	gdb_target_obs="microblaze-tdep.o"
 	gdb_sim=../sim/microblaze/libsim.a
 	;;
 
@@ -442,13 +441,12 @@ powerpc*-*-linux*)
 powerpc-*-lynx*178)
 	# Target: PowerPC running Lynx178.
 	gdb_target_obs="rs6000-tdep.o rs6000-lynx178-tdep.o \
-			xcoffread.o monitor.o dsrec.o ppc-sysv-tdep.o \
+			xcoffread.o ppc-sysv-tdep.o \
 			ravenscar-thread.o ppc-ravenscar-thread.o"
 	;;
 powerpc*-*-*)
 	# Target: PowerPC running eabi
-	gdb_target_obs="rs6000-tdep.o monitor.o dsrec.o ppcbug-rom.o \
-			dink32-rom.o ppc-sysv-tdep.o solib-svr4.o \
+	gdb_target_obs="rs6000-tdep.o ppc-sysv-tdep.o solib-svr4.o \
 			ravenscar-thread.o ppc-ravenscar-thread.o"
 	if test -f ../sim/ppc/Makefile; then
 	  gdb_sim=../sim/ppc/libsim.a
@@ -484,8 +482,8 @@ score-*-*)
 
 sh*-*-linux*)
 	# Target: GNU/Linux Super-H
-	gdb_target_obs="sh-tdep.o sh64-tdep.o sh-linux-tdep.o monitor.o \
-			dsrec.o solib-svr4.o symfile-mem.o \
+	gdb_target_obs="sh-tdep.o sh64-tdep.o sh-linux-tdep.o \
+			solib-svr4.o symfile-mem.o \
 			glibc-tdep.o linux-tdep.o"
 	gdb_sim=../sim/sh/libsim.a
 	build_gdbserver=yes
@@ -505,8 +503,8 @@ sh64-*-elf*)
 	gdb_sim=../sim/sh64/libsim.a
 	;;
 sh*)
-	# Target: Embedded Renesas Super-H with ICE and simulator
-	gdb_target_obs="sh-tdep.o sh64-tdep.o monitor.o dsrec.o"
+	# Target: Embedded Renesas Super-H processor
+	gdb_target_obs="sh-tdep.o sh64-tdep.o"
 	gdb_sim=../sim/sh/libsim.a
 	;;
 
diff --git a/gdb/dbug-rom.c b/gdb/dbug-rom.c
deleted file mode 100644
index f771e1c..0000000
--- a/gdb/dbug-rom.c
+++ /dev/null
@@ -1,176 +0,0 @@
-/* Remote debugging interface to dBUG ROM monitor for GDB, the GNU debugger.
-   Copyright (C) 1996-2015 Free Software Foundation, Inc.
-
-   Written by Stan Shebs of Cygnus Support.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* dBUG is a monitor supplied on various Motorola boards, including
-   m68k, ColdFire, and PowerPC-based designs.  The code here assumes
-   the ColdFire, and (as of 9/25/96) has only been tested with a
-   ColdFire IDP board.  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "monitor.h"
-#include "serial.h"
-#include "regcache.h"
-
-#include "m68k-tdep.h"
-
-static void
-dbug_supply_register (struct regcache *regcache, char *regname,
-		      int regnamelen, char *val, int vallen)
-{
-  int regno;
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
-
-  if (regnamelen != 2)
-    return;
-
-  switch (regname[0])
-    {
-    case 'S':
-      if (regname[1] != 'R')
-	return;
-      regno = gdbarch_ps_regnum (gdbarch);
-      break;
-    case 'P':
-      if (regname[1] != 'C')
-	return;
-      regno = gdbarch_pc_regnum (gdbarch);
-      break;
-    case 'D':
-      if (regname[1] < '0' || regname[1] > '7')
-	return;
-      regno = regname[1] - '0' + M68K_D0_REGNUM;
-      break;
-    case 'A':
-      if (regname[1] < '0' || regname[1] > '7')
-	return;
-      regno = regname[1] - '0' + M68K_A0_REGNUM;
-      break;
-    default:
-      return;
-    }
-
-  monitor_supply_register (regcache, regno, val);
-}
-
-/* This array of registers needs to match the indexes used by GDB.
-   The whole reason this exists is because the various ROM monitors
-   use different names than GDB does, and don't support all the
-   registers either.  So, typing "info reg sp" becomes an "A7".  */
-
-static const char *
-dbug_regname (int index)
-{
-  static char *regnames[] =
-  {
-    "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
-    "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
-    "SR", "PC"
-    /* no float registers */
-  };
-
-  if (index >= ARRAY_SIZE (regnames) || index < 0)
-    return NULL;
-  else
-    return regnames[index];
-
-}
-
-static struct target_ops dbug_ops;
-static struct monitor_ops dbug_cmds;
-
-static char *dbug_inits[] =
-{"\r", NULL};
-
-
-static void
-init_dbug_cmds (void)
-{
-  dbug_cmds.flags = MO_CLR_BREAK_USES_ADDR
-    | MO_GETMEM_NEEDS_RANGE | MO_FILL_USES_ADDR;
-  dbug_cmds.init = dbug_inits;	/* Init strings */
-  dbug_cmds.cont = "go\r";	/* continue command */
-  dbug_cmds.step = "trace\r";	/* single step */
-  dbug_cmds.stop = NULL;	/* interrupt command */
-  dbug_cmds.set_break = "br %x\r";	/* set a breakpoint */
-  dbug_cmds.clr_break = "br -r %x\r";	/* clear a breakpoint */
-  dbug_cmds.clr_all_break = "br -r\r";	/* clear all breakpoints */
-  dbug_cmds.fill = "bf.b %x %x %x\r";	/* fill (start end val) */
-  dbug_cmds.setmem.cmdb = "mm.b %x %x\r";	/* setmem.cmdb (addr, value) */
-  dbug_cmds.setmem.cmdw = "mm.w %x %x\r";	/* setmem.cmdw (addr, value) */
-  dbug_cmds.setmem.cmdl = "mm.l %x %x\r";	/* setmem.cmdl (addr, value) */
-  dbug_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
-  dbug_cmds.setmem.resp_delim = NULL;	/* setmem.resp_delim */
-  dbug_cmds.setmem.term = NULL;	/* setmem.term */
-  dbug_cmds.setmem.term_cmd = NULL;	/* setmem.term_cmd */
-  dbug_cmds.getmem.cmdb = "md.b %x %x\r";	/* getmem.cmdb (addr, addr2) */
-  dbug_cmds.getmem.cmdw = "md.w %x %x\r";	/* getmem.cmdw (addr, addr2) */
-  dbug_cmds.getmem.cmdl = "md.l %x %x\r";	/* getmem.cmdl (addr, addr2) */
-  dbug_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, addr2) */
-  dbug_cmds.getmem.resp_delim = ":";	/* getmem.resp_delim */
-  dbug_cmds.getmem.term = NULL;	/* getmem.term */
-  dbug_cmds.getmem.term_cmd = NULL;	/* getmem.term_cmd */
-  dbug_cmds.setreg.cmd = "rm %s %x\r";	/* setreg.cmd (name, value) */
-  dbug_cmds.setreg.resp_delim = NULL;	/* setreg.resp_delim */
-  dbug_cmds.setreg.term = NULL;	/* setreg.term */
-  dbug_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
-  dbug_cmds.getreg.cmd = "rd %s\r";	/* getreg.cmd (name) */
-  dbug_cmds.getreg.resp_delim = ":";	/* getreg.resp_delim */
-  dbug_cmds.getreg.term = NULL;	/* getreg.term */
-  dbug_cmds.getreg.term_cmd = NULL;	/* getreg.term_cmd */
-  dbug_cmds.dump_registers = "rd\r";	/* dump_registers */
-					/* register_pattern */
-  dbug_cmds.register_pattern = "\\(\\w+\\) +:\\([0-9a-fA-F]+\\b\\)";
-  dbug_cmds.supply_register = dbug_supply_register;
-  dbug_cmds.load = "dl\r";	/* download command */
-  dbug_cmds.loadresp = "\n";	/* load response */
-  dbug_cmds.prompt = "dBUG>";	/* monitor command prompt */
-  dbug_cmds.line_term = "\r";	/* end-of-line terminator */
-  dbug_cmds.cmd_end = NULL;	/* optional command terminator */
-  dbug_cmds.target = &dbug_ops;	/* target operations */
-  dbug_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
-  dbug_cmds.regnames = NULL;	/* registers names */
-  dbug_cmds.regname = dbug_regname;
-  dbug_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
-}				/* init_debug_ops */
-
-static void
-dbug_open (const char *args, int from_tty)
-{
-  monitor_open (args, &dbug_cmds, from_tty);
-}
-
-extern initialize_file_ftype _initialize_dbug_rom; /* -Wmissing-prototypes */
-
-void
-_initialize_dbug_rom (void)
-{
-  init_dbug_cmds ();
-  init_monitor_ops (&dbug_ops);
-
-  dbug_ops.to_shortname = "dbug";
-  dbug_ops.to_longname = "dBUG monitor";
-  dbug_ops.to_doc = "Debug via the dBUG monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  dbug_ops.to_open = dbug_open;
-
-  add_target (&dbug_ops);
-}
diff --git a/gdb/dink32-rom.c b/gdb/dink32-rom.c
deleted file mode 100644
index 39fa956..0000000
--- a/gdb/dink32-rom.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/* Remote debugging interface for DINK32 (PowerPC) ROM monitor for
-   GDB, the GNU debugger.
-   Copyright (C) 1997-2015 Free Software Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "monitor.h"
-#include "serial.h"
-#include "symfile.h" /* For generic_load() */
-#include "inferior.h"
-#include "regcache.h"
-
-static void
-dink32_supply_register (struct regcache *regcache, char *regname,
-			int regnamelen, char *val, int vallen)
-{
-  int regno = 0;
-
-  if (regnamelen < 2 || regnamelen > 4)
-    return;
-
-  switch (regname[0])
-    {
-    case 'R':
-      if (regname[1] < '0' || regname[1] > '9')
-	return;
-      if (regnamelen == 2)
-	regno = regname[1] - '0';
-      else if (regnamelen == 3 && regname[2] >= '0' && regname[2] <= '9')
-	regno = (regname[1] - '0') * 10 + (regname[2] - '0');
-      else
-	return;
-      break;
-    case 'F':
-      if (regname[1] != 'R' || regname[2] < '0' || regname[2] > '9')
-	return;
-      if (regnamelen == 3)
-	regno = 32 + regname[2] - '0';
-      else if (regnamelen == 4 && regname[3] >= '0' && regname[3] <= '9')
-	regno = 32 + (regname[2] - '0') * 10 + (regname[3] - '0');
-      else
-	return;
-      break;
-    case 'I':
-      if (regnamelen != 2 || regname[1] != 'P')
-	return;
-      regno = 64;
-      break;
-    case 'M':
-      if (regnamelen != 3 || regname[1] != 'S' || regname[2] != 'R')
-	return;
-      regno = 65;
-      break;
-    case 'C':
-      if (regnamelen != 2 || regname[1] != 'R')
-	return;
-      regno = 66;
-      break;
-    case 'S':
-      if (regnamelen != 4 || regname[1] != 'P' || regname[2] != 'R')
-	return;
-      else if (regname[3] == '8')
-	regno = 67;
-      else if (regname[3] == '9')
-	regno = 68;
-      else if (regname[3] == '1')
-	regno = 69;
-      else if (regname[3] == '0')
-	regno = 70;
-      else
-	return;
-      break;
-    default:
-      return;
-    }
-
-  monitor_supply_register (regcache, regno, val);
-}
-
-/* This array of registers needs to match the indexes used by GDB.
-   The whole reason this exists is because the various ROM monitors
-   use different names than GDB does, and don't support all the
-   registers either.  */
-
-static char *dink32_regnames[] =
-{
-  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
-  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
-  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
-  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
-
-  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
-  "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
-  "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
-  "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
-
-  "srr0", "msr", "cr", "lr", "ctr", "xer", "xer"
-};
-
-static struct target_ops dink32_ops;
-
-static char *dink32_inits[] =
-{"\r", NULL};
-
-static struct monitor_ops dink32_cmds;
-
-static void
-dink32_open (const char *args, int from_tty)
-{
-  monitor_open (args, &dink32_cmds, from_tty);
-}
-
-extern initialize_file_ftype _initialize_dink32_rom; /* -Wmissing-prototypes */
-
-void
-_initialize_dink32_rom (void)
-{
-  dink32_cmds.flags = MO_HEX_PREFIX | MO_GETMEM_NEEDS_RANGE
-    | MO_FILL_USES_ADDR | MO_HANDLE_NL | MO_32_REGS_PAIRED
-    | MO_SETREG_INTERACTIVE | MO_SETMEM_INTERACTIVE
-    | MO_GETMEM_16_BOUNDARY | MO_CLR_BREAK_1_BASED | MO_SREC_ACK
-    | MO_SREC_ACK_ROTATE;
-  dink32_cmds.init = dink32_inits;
-  dink32_cmds.cont = "go +\r";
-  dink32_cmds.step = "tr +\r";
-  dink32_cmds.set_break = "bp 0x%x\r";
-  dink32_cmds.clr_break = "bp %d\r";
-#if 0			/* Would need to follow strict alignment rules..  */
-  dink32_cmds.fill = "mf %x %x %x\r";
-#endif
-  dink32_cmds.setmem.cmdb = "mm -b %x\r";
-  dink32_cmds.setmem.cmdw = "mm -w %x\r";
-  dink32_cmds.setmem.cmdl = "mm %x\r";
-  dink32_cmds.setmem.term = " ?  ";
-  dink32_cmds.getmem.cmdb = "md %x\r";
-  dink32_cmds.getmem.resp_delim = "        ";
-  dink32_cmds.setreg.cmd = "rm %s\r";
-  dink32_cmds.setreg.term = " ?  ";
-  dink32_cmds.getreg.cmd = "rd %s\r";
-  dink32_cmds.getreg.resp_delim = ": ";
-  dink32_cmds.dump_registers = "rd r\r";
-  dink32_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)";
-  dink32_cmds.supply_register = dink32_supply_register;
-  /* S-record download, via "keyboard port".  */
-  dink32_cmds.load = "dl -k\r";
-  dink32_cmds.loadresp = "Set Input Port : set to Keyboard Port\r";
-  dink32_cmds.prompt = "DINK32_603 >>";
-  dink32_cmds.line_term = "\r";
-  dink32_cmds.target = &dink32_ops;
-  dink32_cmds.stopbits = SERIAL_1_STOPBITS;
-  dink32_cmds.regnames = dink32_regnames;
-  dink32_cmds.magic = MONITOR_OPS_MAGIC;
-
-  init_monitor_ops (&dink32_ops);
-
-  dink32_ops.to_shortname = "dink32";
-  dink32_ops.to_longname = "DINK32 monitor";
-  dink32_ops.to_doc = "Debug using the DINK32 monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  dink32_ops.to_open = dink32_open;
-
-  add_target (&dink32_ops);
-}
diff --git a/gdb/dsrec.c b/gdb/dsrec.c
deleted file mode 100644
index 82cc968..0000000
--- a/gdb/dsrec.c
+++ /dev/null
@@ -1,316 +0,0 @@
-/* S-record download support for GDB, the GNU debugger.
-   Copyright (C) 1995-2015 Free Software Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#include "defs.h"
-#include "serial.h"
-#include "srec.h"
-#include <sys/time.h>
-#include <time.h>
-#include "gdb_bfd.h"
-
-extern int remote_debug;
-
-static int make_srec (char *srec, CORE_ADDR targ_addr, bfd * abfd,
-		      asection * sect, int sectoff, int *maxrecsize,
-		      int flags);
-
-/* Download an executable by converting it to S records.  DESC is a
-   `struct serial *' to send the data to.  FILE is the name of the
-   file to be loaded.  LOAD_OFFSET is the offset into memory to load
-   data into.  It is usually specified by the user and is useful with
-   the a.out file format.  MAXRECSIZE is the length in chars of the
-   largest S-record the host can accomodate.  This is measured from
-   the starting `S' to the last char of the checksum.  FLAGS is
-   various random flags, and HASHMARK is non-zero to cause a `#' to be
-   printed out for each record loaded.  WAITACK, if non-NULL, is a
-   function that waits for an acknowledgement after each S-record, and
-   returns non-zero if the ack is read correctly.  */
-
-void
-load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
-	   int maxrecsize,
-	   int flags, int hashmark, int (*waitack) (void))
-{
-  bfd *abfd;
-  asection *s;
-  char *srec;
-  int i;
-  int reclen;
-  struct timeval start_time, end_time;
-  unsigned long data_count = 0;
-  struct cleanup *cleanup;
-
-  srec = (char *) alloca (maxrecsize + 1);
-
-  abfd = gdb_bfd_open (file, NULL, -1);
-  if (!abfd)
-    {
-      printf_filtered (_("Unable to open file %s\n"), file);
-      return;
-    }
-
-  cleanup = make_cleanup_bfd_unref (abfd);
-  if (bfd_check_format (abfd, bfd_object) == 0)
-    {
-      printf_filtered (_("File is not an object file\n"));
-      do_cleanups (cleanup);
-      return;
-    }
-
-  gettimeofday (&start_time, NULL);
-
-  /* Write a type 0 header record. no data for a type 0, and there
-     is no data, so len is 0.  */
-
-  reclen = maxrecsize;
-  make_srec (srec, 0, NULL, (asection *) 1, 0, &reclen, flags);
-  if (remote_debug)
-    {
-      srec[reclen] = '\0';
-      puts_debug ("sent -->", srec, "<--");
-    }
-  serial_write (desc, srec, reclen);
-
-  for (s = abfd->sections; s; s = s->next)
-    if (s->flags & SEC_LOAD)
-      {
-	int numbytes;
-
-	bfd_vma addr = bfd_get_section_vma (abfd, s) + load_offset;
-	bfd_size_type size = bfd_get_section_size (s);
-	char *section_name = (char *) bfd_get_section_name (abfd, s);
-	/* Both GDB and BFD have mechanisms for printing addresses.
-           In the below, GDB's is used so that the address is
-           consistent with the rest of GDB.  BFD's printf_vma() could
-           have also been used.  cagney 1999-09-01 */
-	printf_filtered ("%s\t: %s .. %s  ",
-			 section_name,
-			 paddress (target_gdbarch (), addr),
-			 paddress (target_gdbarch (), addr + size));
-	gdb_flush (gdb_stdout);
-
-	data_count += size;
-
-	for (i = 0; i < size; i += numbytes)
-	  {
-	    reclen = maxrecsize;
-	    numbytes = make_srec (srec, (CORE_ADDR) (addr + i), abfd, s,
-				  i, &reclen, flags);
-
-	    if (remote_debug)
-	      {
-		srec[reclen] = '\0';
-		puts_debug ("sent -->", srec, "<--");
-	      }
-
-	    /* Repeatedly send the S-record until a good
-	       acknowledgement is sent back.  */
-	    do
-	      {
-		serial_write (desc, srec, reclen);
-		if (deprecated_ui_load_progress_hook)
-		  if (deprecated_ui_load_progress_hook (section_name,
-							(unsigned long) i))
-		    error (_("Canceled the download"));
-	      }
-	    while (waitack != NULL && !waitack ());
-
-	    if (hashmark)
-	      {
-		putchar_unfiltered ('#');
-		gdb_flush (gdb_stdout);
-	      }
-	  }			/* Per-packet (or S-record) loop.  */
-
-	if (deprecated_ui_load_progress_hook)
-	  if (deprecated_ui_load_progress_hook (section_name,
-						(unsigned long) i))
-	    error (_("Canceled the download"));
-	putchar_unfiltered ('\n');
-      }
-
-  if (hashmark)
-    putchar_unfiltered ('\n');
-
-  gettimeofday (&end_time, NULL);
-
-  /* Write a terminator record.  */
-
-  reclen = maxrecsize;
-  make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);
-
-  if (remote_debug)
-    {
-      srec[reclen] = '\0';
-      puts_debug ("sent -->", srec, "<--");
-    }
-
-  serial_write (desc, srec, reclen);
-
-  /* Some monitors need these to wake up properly.  (Which ones? -sts)  */
-  serial_write (desc, "\r\r", 2);
-  if (remote_debug)
-    puts_debug ("sent -->", "\r\r", "<---");
-
-  serial_flush_input (desc);
-
-  print_transfer_performance (gdb_stdout, data_count, 0,
-			      &start_time, &end_time);
-  do_cleanups (cleanup);
-}
-
-/*
- * make_srec -- make an srecord.  This writes each line, one at a
- *      time, each with it's own header and trailer line.
- *      An srecord looks like this:
- *
- * byte count-+     address
- * start ---+ |        |       data        +- checksum
- *          | |        |                   |
- *        S01000006F6B692D746573742E73726563E4
- *        S315000448600000000000000000FC00005900000000E9
- *        S31A0004000023C1400037DE00F023604000377B009020825000348D
- *        S30B0004485A0000000000004E
- *        S70500040000F6
- *
- *      S<type><length><address><data><checksum>
- *
- *      Where
- *      - length
- *        is the number of bytes following upto the checksum.  Note
- *        that this is not the number of chars following, since it
- *        takes two chars to represent a byte.
- *      - type
- *        is one of:
- *        0) header record
- *        1) two byte address data record
- *        2) three byte address data record
- *        3) four byte address data record
- *        7) four byte address termination record
- *        8) three byte address termination record
- *        9) two byte address termination record
- *       
- *      - address
- *        is the start address of the data following, or in the case of
- *        a termination record, the start address of the image
- *      - data
- *        is the data.
- *      - checksum
- *        is the sum of all the raw byte data in the record, from the length
- *        upwards, modulo 256 and subtracted from 255.
- *
- * This routine returns the length of the S-record.
- *
- */
-
-static int
-make_srec (char *srec, CORE_ADDR targ_addr, bfd *abfd, asection *sect,
-	   int sectoff, int *maxrecsize, int flags)
-{
-  unsigned char checksum;
-  int tmp;
-  static const char hextab[] = "0123456789ABCDEF";
-  static const char data_code_table[] = "123";
-  static const char term_code_table[] = "987";
-  static const char header_code_table[] = "000";
-  char const *code_table;
-  int addr_size;
-  int payload_size;
-  char *binbuf;
-  char *p;
-
-  if (sect)
-    {
-      tmp = flags;		/* Data or header record */
-      code_table = abfd ? data_code_table : header_code_table;
-      binbuf = alloca (*maxrecsize / 2);
-    }
-  else
-    {
-      tmp = flags >> SREC_TERM_SHIFT;	/* Term record */
-      code_table = term_code_table;
-      binbuf = NULL;
-    }
-
-  if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
-    addr_size = 2;
-  else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
-    addr_size = 3;
-  else if (tmp & SREC_4_BYTE_ADDR)
-    addr_size = 4;
-  else
-    internal_error (__FILE__, __LINE__,
-		    _("make_srec:  Bad address (%s), or bad flags (0x%x)."),
-		    paddress (target_gdbarch (), targ_addr), flags);
-
-  /* Now that we know the address size, we can figure out how much
-     data this record can hold.  */
-
-  if (sect && abfd)
-    {
-      payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
-      payload_size = min (payload_size, bfd_get_section_size (sect) - sectoff);
-
-      bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
-    }
-  else
-    payload_size = 0;		/* Term or header packets have no payload.  */
-
-  /* Output the header.  */
-  snprintf (srec, (*maxrecsize) + 1, "S%c%02X%0*X",
-	    code_table[addr_size - 2],
-	    addr_size + payload_size + 1,
-	    addr_size * 2, (int) targ_addr);
-
-  /* Note that the checksum is calculated on the raw data, not the
-     hexified data.  It includes the length, address and the data
-     portions of the packet.  */
-
-  checksum = 0;
-
-  checksum += (payload_size + addr_size + 1	/* Packet length */
-	       + (targ_addr & 0xff)		/* Address...  */
-	       + ((targ_addr >> 8) & 0xff)
-	       + ((targ_addr >> 16) & 0xff)
-	       + ((targ_addr >> 24) & 0xff));
-
-  /* NOTE: cagney/2003-08-10: The equation is old.  Check that the
-     recent snprintf changes match that equation.  */
-  gdb_assert (strlen (srec) == 1 + 1 + 2 + addr_size * 2);
-  p = srec + 1 + 1 + 2 + addr_size * 2;
-
-  /* Build the Srecord.  */
-  for (tmp = 0; tmp < payload_size; tmp++)
-    {
-      unsigned char k;
-
-      k = binbuf[tmp];
-      *p++ = hextab[k >> 4];
-      *p++ = hextab[k & 0xf];
-      checksum += k;
-    }
-
-  checksum = ~checksum;
-
-  *p++ = hextab[checksum >> 4];
-  *p++ = hextab[checksum & 0xf];
-  *p++ = '\r';
-
-  *maxrecsize = p - srec;
-  return payload_size;
-}
diff --git a/gdb/m32r-rom.c b/gdb/m32r-rom.c
deleted file mode 100644
index a2ac537..0000000
--- a/gdb/m32r-rom.c
+++ /dev/null
@@ -1,634 +0,0 @@
-/* Remote debugging interface to m32r and mon2000 ROM monitors for GDB, 
-   the GNU debugger.
-
-   Copyright (C) 1996-2015 Free Software Foundation, Inc.
-
-   Adapted by Michael Snyder of Cygnus Support.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* This module defines communication with the Renesas m32r monitor.  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "monitor.h"
-#include "serial.h"
-#include "symtab.h"
-#include "command.h"
-#include "gdbcmd.h"
-#include "symfile.h"		/* for generic load */
-#include <sys/time.h>
-#include <time.h>		/* for time_t */
-#include "objfiles.h"		/* for ALL_OBJFILES etc.  */
-#include "inferior.h"
-#include <ctype.h>
-#include "regcache.h"
-#include "gdb_bfd.h"
-#include "cli/cli-utils.h"
-
-/*
- * All this stuff just to get my host computer's IP address!
- */
-#ifdef __MINGW32__
-#include <winsock2.h>
-#else
-#include <sys/types.h>
-#include <netdb.h>		/* for hostent */
-#include <netinet/in.h>		/* for struct in_addr */
-#if 1
-#include <arpa/inet.h>		/* for inet_ntoa */
-#endif
-#endif
-
-static char *board_addr;	/* user-settable IP address for M32R-EVA */
-static char *server_addr;	/* user-settable IP address for gdb host */
-static char *download_path;	/* user-settable path for SREC files     */
-
-
-/* REGNUM */
-#define PSW_REGNUM      16
-#define SPI_REGNUM      18
-#define SPU_REGNUM      19
-#define ACCL_REGNUM     22
-#define ACCH_REGNUM     23
-
-
-/* 
- * Function: m32r_load_1 (helper function)
- */
-
-static void
-m32r_load_section (bfd *abfd, asection *s, void *obj)
-{
-  unsigned int *data_count = obj;
-  if (s->flags & SEC_LOAD)
-    {
-      int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
-      bfd_size_type section_size = bfd_section_size (abfd, s);
-      bfd_vma section_base = bfd_section_lma (abfd, s);
-      unsigned int buffer, i;
-
-      *data_count += section_size;
-
-      printf_filtered ("Loading section %s, size 0x%lx lma ",
-		       bfd_section_name (abfd, s),
-		       (unsigned long) section_size);
-      fputs_filtered (paddress (target_gdbarch (), section_base), gdb_stdout);
-      printf_filtered ("\n");
-      gdb_flush (gdb_stdout);
-      monitor_printf ("%s mw\r", phex_nz (section_base, addr_size));
-      for (i = 0; i < section_size; i += 4)
-	{
-	  QUIT;
-	  monitor_expect (" -> ", NULL, 0);
-	  bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
-	  monitor_printf ("%x\n", buffer);
-	}
-      monitor_expect (" -> ", NULL, 0);
-      monitor_printf ("q\n");
-      monitor_expect_prompt (NULL, 0);
-    }
-}
-
-static int
-m32r_load_1 (void *dummy)
-{
-  int data_count = 0;
-
-  bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count);
-  return data_count;
-}
-
-/* 
- * Function: m32r_load (an alternate way to load) 
- */
-
-static void
-m32r_load (char *filename, int from_tty)
-{
-  bfd *abfd;
-  unsigned int data_count = 0;
-  struct timeval start_time, end_time;
-  struct cleanup *cleanup;
-
-  if (filename == NULL || filename[0] == 0)
-    filename = get_exec_file (1);
-
-  abfd = gdb_bfd_open (filename, NULL, -1);
-  if (!abfd)
-    error (_("Unable to open file %s."), filename);
-  cleanup = make_cleanup_bfd_unref (abfd);
-  if (bfd_check_format (abfd, bfd_object) == 0)
-    error (_("File is not an object file."));
-  gettimeofday (&start_time, NULL);
-#if 0
-  for (s = abfd->sections; s; s = s->next)
-    if (s->flags & SEC_LOAD)
-      {
-	bfd_size_type section_size = bfd_section_size (abfd, s);
-	bfd_vma section_base = bfd_section_vma (abfd, s);
-	unsigned int buffer;
-
-	data_count += section_size;
-
-	printf_filtered ("Loading section %s, size 0x%lx vma ",
-			 bfd_section_name (abfd, s), section_size);
-	fputs_filtered (paddress (target_gdbarch (), section_base), gdb_stdout);
-	printf_filtered ("\n");
-	gdb_flush (gdb_stdout);
-	monitor_printf ("%x mw\r", section_base);
-	for (i = 0; i < section_size; i += 4)
-	  {
-	    monitor_expect (" -> ", NULL, 0);
-	    bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
-	    monitor_printf ("%x\n", buffer);
-	  }
-	monitor_expect (" -> ", NULL, 0);
-	monitor_printf ("q\n");
-	monitor_expect_prompt (NULL, 0);
-      }
-#else
-  if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
-    {
-      monitor_printf ("q\n");
-      do_cleanups (cleanup);
-      return;
-    }
-#endif
-  gettimeofday (&end_time, NULL);
-  printf_filtered ("Start address 0x%lx\n",
-		   (unsigned long) bfd_get_start_address (abfd));
-  print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
-			      &end_time);
-
-  /* Finally, make the PC point at the start address.  */
-  if (exec_bfd)
-    regcache_write_pc (get_current_regcache (),
-		       bfd_get_start_address (exec_bfd));
-
-  inferior_ptid = null_ptid;	/* No process now.  */
-
-  /* This is necessary because many things were based on the PC at the
-     time that we attached to the monitor, which is no longer valid
-     now that we have loaded new code (and just changed the PC).
-     Another way to do this might be to call normal_stop, except that
-     the stack may not be valid, and things would get horribly
-     confused...  */
-
-  clear_symtab_users (0);
-  do_cleanups (cleanup);
-}
-
-static void
-m32r_load_gen (struct target_ops *self, const char *filename, int from_tty)
-{
-  generic_load (filename, from_tty);
-}
-
-/* This array of registers needs to match the indexes used by GDB.  The
-   whole reason this exists is because the various ROM monitors use
-   different names than GDB does, and don't support all the registers
-   either.  So, typing "info reg sp" becomes an "A7".  */
-
-static char *m32r_regnames[] =
-  { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
-  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
-  "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
-};
-
-static void
-m32r_supply_register (struct regcache *regcache, char *regname,
-		      int regnamelen, char *val, int vallen)
-{
-  int regno;
-  int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
-
-  for (regno = 0; regno < num_regs; regno++)
-    if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
-      break;
-
-  if (regno >= num_regs)
-    return;			/* no match */
-
-  if (regno == ACCL_REGNUM)
-    {				/* Special handling for 64-bit acc reg.  */
-      monitor_supply_register (regcache, ACCH_REGNUM, val);
-      val = strchr (val, ':');	/* Skip past ':' to get 2nd word.  */
-      if (val != NULL)
-	monitor_supply_register (regcache, ACCL_REGNUM, val + 1);
-    }
-  else
-    {
-      monitor_supply_register (regcache, regno, val);
-      if (regno == PSW_REGNUM)
-	{
-#if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
-     || defined BIE_REGNUM || defined COND_REGNUM  || defined CBR_REGNUM \
-     || defined BPC_REGNUM || defined BCARRY_REGNUM)
-	  unsigned long psw = strtoul (val, NULL, 16);
-	  char *zero = "00000000", *one = "00000001";
-#endif
-
-#ifdef SM_REGNUM
-	  /* Stack mode bit */
-	  monitor_supply_register (regcache, SM_REGNUM,
-				   (psw & 0x80) ? one : zero);
-#endif
-#ifdef BSM_REGNUM
-	  /* Backup stack mode bit */
-	  monitor_supply_register (regcache, BSM_REGNUM,
-				   (psw & 0x8000) ? one : zero);
-#endif
-#ifdef IE_REGNUM
-	  /* Interrupt enable bit */
-	  monitor_supply_register (regcache, IE_REGNUM,
-				   (psw & 0x40) ? one : zero);
-#endif
-#ifdef BIE_REGNUM
-	  /* Backup interrupt enable bit */
-	  monitor_supply_register (regcache, BIE_REGNUM,
-				   (psw & 0x4000) ? one : zero);
-#endif
-#ifdef COND_REGNUM
-	  /* Condition bit (carry etc.) */
-	  monitor_supply_register (regcache, COND_REGNUM,
-				   (psw & 0x1) ? one : zero);
-#endif
-#ifdef CBR_REGNUM
-	  monitor_supply_register (regcache, CBR_REGNUM,
-				   (psw & 0x1) ? one : zero);
-#endif
-#ifdef BPC_REGNUM
-	  monitor_supply_register (regcache, BPC_REGNUM,
-				   zero);	/* KLUDGE:   (???????) */
-#endif
-#ifdef BCARRY_REGNUM
-	  monitor_supply_register (regcache, BCARRY_REGNUM,
-				   zero);	/* KLUDGE: (??????) */
-#endif
-	}
-
-      if (regno == SPI_REGNUM || regno == SPU_REGNUM)
-	{	/* special handling for stack pointer (spu or spi).  */
-	  ULONGEST stackmode, psw;
-	  regcache_cooked_read_unsigned (regcache, PSW_REGNUM, &psw);
-	  stackmode = psw & 0x80;
-
-	  if (regno == SPI_REGNUM && !stackmode)	/* SP == SPI */
-	    monitor_supply_register (regcache,
-				     gdbarch_sp_regnum (gdbarch), val);
-	  else if (regno == SPU_REGNUM && stackmode)	/* SP == SPU */
-	    monitor_supply_register (regcache,
-				     gdbarch_sp_regnum (gdbarch), val);
-	}
-    }
-}
-
-/* m32r RevC board monitor */
-
-static struct target_ops m32r_ops;
-
-static char *m32r_inits[] = { "\r", NULL };
-
-static struct monitor_ops m32r_cmds;
-
-static void
-init_m32r_cmds (void)
-{
-  m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
-  m32r_cmds.init = m32r_inits;	/* Init strings */
-  m32r_cmds.cont = "go\r";	/* continue command */
-  m32r_cmds.step = "step\r";	/* single step */
-  m32r_cmds.stop = NULL;	/* interrupt command */
-  m32r_cmds.set_break = "%x +bp\r";	/* set a breakpoint */
-  m32r_cmds.clr_break = "%x -bp\r";	/* clear a breakpoint */
-  m32r_cmds.clr_all_break = "bpoff\r";	/* clear all breakpoints */
-  m32r_cmds.fill = "%x %x %x fill\r";	/* fill (start length val) */
-  m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";	/* setmem.cmdb (addr, value) */
-  m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";	/* setmem.cmdw (addr, value) */
-  m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";	/* setmem.cmdl (addr, value) */
-  m32r_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
-  m32r_cmds.setmem.resp_delim = NULL;	/* setmem.resp_delim */
-  m32r_cmds.setmem.term = NULL;	/* setmem.term */
-  m32r_cmds.setmem.term_cmd = NULL;	/* setmem.term_cmd */
-  m32r_cmds.getmem.cmdb = "%x %x dump\r";	/* getmem.cmdb (addr, len) */
-  m32r_cmds.getmem.cmdw = NULL;	/* getmem.cmdw (addr, len) */
-  m32r_cmds.getmem.cmdl = NULL;	/* getmem.cmdl (addr, len) */
-  m32r_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, len) */
-  m32r_cmds.getmem.resp_delim = ": ";	/* getmem.resp_delim */
-  m32r_cmds.getmem.term = NULL;	/* getmem.term */
-  m32r_cmds.getmem.term_cmd = NULL;	/* getmem.term_cmd */
-  m32r_cmds.setreg.cmd = "%x to %%%s\r";	/* setreg.cmd (name, value) */
-  m32r_cmds.setreg.resp_delim = NULL;	/* setreg.resp_delim */
-  m32r_cmds.setreg.term = NULL;	/* setreg.term */
-  m32r_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
-  m32r_cmds.getreg.cmd = NULL;	/* getreg.cmd (name) */
-  m32r_cmds.getreg.resp_delim = NULL;	/* getreg.resp_delim */
-  m32r_cmds.getreg.term = NULL;	/* getreg.term */
-  m32r_cmds.getreg.term_cmd = NULL;	/* getreg.term_cmd */
-  m32r_cmds.dump_registers = ".reg\r";	/* dump_registers */
-  					/* register_pattern */
-  m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
-  m32r_cmds.supply_register = m32r_supply_register;
-  m32r_cmds.load = NULL;	/* download command */
-  m32r_cmds.loadresp = NULL;	/* load response */
-  m32r_cmds.prompt = "ok ";	/* monitor command prompt */
-  m32r_cmds.line_term = "\r";	/* end-of-line terminator */
-  m32r_cmds.cmd_end = NULL;	/* optional command terminator */
-  m32r_cmds.target = &m32r_ops;	/* target operations */
-  m32r_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
-  m32r_cmds.regnames = m32r_regnames;	/* registers names */
-  m32r_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
-}				/* init_m32r_cmds */
-
-static void
-m32r_open (const char *args, int from_tty)
-{
-  monitor_open (args, &m32r_cmds, from_tty);
-}
-
-/* Mon2000 monitor (MSA2000 board) */
-
-static struct target_ops mon2000_ops;
-static struct monitor_ops mon2000_cmds;
-
-static void
-init_mon2000_cmds (void)
-{
-  mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
-  mon2000_cmds.init = m32r_inits;	/* Init strings */
-  mon2000_cmds.cont = "go\r";	/* continue command */
-  mon2000_cmds.step = "step\r";	/* single step */
-  mon2000_cmds.stop = NULL;	/* interrupt command */
-  mon2000_cmds.set_break = "%x +bp\r";	/* set a breakpoint */
-  mon2000_cmds.clr_break = "%x -bp\r";	/* clear a breakpoint */
-  mon2000_cmds.clr_all_break = "bpoff\r";	/* clear all breakpoints */
-  mon2000_cmds.fill = "%x %x %x fill\r";	/* fill (start length val) */
-  mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r";	/* setmem.cmdb (addr, value) */
-  mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r";	/* setmem.cmdw (addr, value) */
-  mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r";	/* setmem.cmdl (addr, value) */
-  mon2000_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
-  mon2000_cmds.setmem.resp_delim = NULL;	/* setmem.resp_delim */
-  mon2000_cmds.setmem.term = NULL;	/* setmem.term */
-  mon2000_cmds.setmem.term_cmd = NULL;	/* setmem.term_cmd */
-  mon2000_cmds.getmem.cmdb = "%x %x dump\r";	/* getmem.cmdb (addr, len) */
-  mon2000_cmds.getmem.cmdw = NULL;	/* getmem.cmdw (addr, len) */
-  mon2000_cmds.getmem.cmdl = NULL;	/* getmem.cmdl (addr, len) */
-  mon2000_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, len) */
-  mon2000_cmds.getmem.resp_delim = ": ";	/* getmem.resp_delim */
-  mon2000_cmds.getmem.term = NULL;	/* getmem.term */
-  mon2000_cmds.getmem.term_cmd = NULL;	/* getmem.term_cmd */
-  mon2000_cmds.setreg.cmd = "%x to %%%s\r";	/* setreg.cmd (name, value) */
-  mon2000_cmds.setreg.resp_delim = NULL;	/* setreg.resp_delim */
-  mon2000_cmds.setreg.term = NULL;	/* setreg.term */
-  mon2000_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
-  mon2000_cmds.getreg.cmd = NULL;	/* getreg.cmd (name) */
-  mon2000_cmds.getreg.resp_delim = NULL;	/* getreg.resp_delim */
-  mon2000_cmds.getreg.term = NULL;	/* getreg.term */
-  mon2000_cmds.getreg.term_cmd = NULL;	/* getreg.term_cmd */
-  mon2000_cmds.dump_registers = ".reg\r";	/* dump_registers */
-						/* register_pattern */
-  mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
-  mon2000_cmds.supply_register = m32r_supply_register;
-  mon2000_cmds.load = NULL;	/* download command */
-  mon2000_cmds.loadresp = NULL;	/* load response */
-  mon2000_cmds.prompt = "Mon2000>";	/* monitor command prompt */
-  mon2000_cmds.line_term = "\r";	/* end-of-line terminator */
-  mon2000_cmds.cmd_end = NULL;	/* optional command terminator */
-  mon2000_cmds.target = &mon2000_ops;	/* target operations */
-  mon2000_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
-  mon2000_cmds.regnames = m32r_regnames;	/* registers names */
-  mon2000_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
-}				/* init_mon2000_cmds */
-
-static void
-mon2000_open (const char *args, int from_tty)
-{
-  monitor_open (args, &mon2000_cmds, from_tty);
-}
-
-static void
-m32r_upload_command (char *args, int from_tty)
-{
-  bfd *abfd;
-  asection *s;
-  struct timeval start_time, end_time;
-  int resp_len, data_count = 0;
-  char buf[1024];
-  struct hostent *hostent;
-  struct in_addr inet_addr;
-  struct cleanup *cleanup;
-
-  /* First check to see if there's an ethernet port!  */
-  monitor_printf ("ust\r");
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));
-  if (!strchr (buf, ':'))
-    error (_("No ethernet connection!"));
-
-  if (board_addr == 0)
-    {
-      /* Scan second colon in the output from the "ust" command.  */
-      char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;
-
-      myIPaddress = skip_spaces (myIPaddress);
-
-      if (startswith (myIPaddress, "0.0."))	/* empty */
-	error (_("Please use 'set board-address' to "
-		 "set the M32R-EVA board's IP address."));
-      if (strchr (myIPaddress, '('))
-	*(strchr (myIPaddress, '(')) = '\0';	/* delete trailing junk */
-      board_addr = xstrdup (myIPaddress);
-    }
-  if (server_addr == 0)
-    {
-#ifdef __MINGW32__
-      WSADATA wd;
-      /* Winsock initialization.  */
-      if (WSAStartup (MAKEWORD (1, 1), &wd))
-	error (_("Couldn't initialize WINSOCK."));
-#endif
-
-      buf[0] = 0;
-      gethostname (buf, sizeof (buf));
-      if (buf[0] != 0)
-	{
-	  hostent = gethostbyname (buf);
-	  if (hostent != 0)
-	    {
-#if 1
-	      memcpy (&inet_addr.s_addr, hostent->h_addr,
-		      sizeof (inet_addr.s_addr));
-	      server_addr = (char *) inet_ntoa (inet_addr);
-#else
-	      server_addr = (char *) inet_ntoa (hostent->h_addr);
-#endif
-	    }
-	}
-      if (server_addr == 0)	/* failed?  */
-	error (_("Need to know gdb host computer's "
-		 "IP address (use 'set server-address')"));
-    }
-
-  if (args == 0 || args[0] == 0)	/* No args: upload the current
-					   file.  */
-    args = get_exec_file (1);
-
-  if (args[0] != '/' && download_path == 0)
-    {
-      if (current_directory)
-	download_path = xstrdup (current_directory);
-      else
-	error (_("Need to know default download "
-		 "path (use 'set download-path')"));
-    }
-
-  gettimeofday (&start_time, NULL);
-  monitor_printf ("uhip %s\r", server_addr);
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));	/* parse result?  */
-  monitor_printf ("ulip %s\r", board_addr);
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));	/* parse result?  */
-  if (args[0] != '/')
-    monitor_printf ("up %s\r", download_path);	/* use default path */
-  else
-    monitor_printf ("up\r");	/* rooted filename/path */
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));	/* parse result?  */
-
-  if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec"))
-    monitor_printf ("ul %s\r", args);
-  else				/* add ".srec" suffix */
-    monitor_printf ("ul %s.srec\r", args);
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));	/* parse result?  */
-
-  if (buf[0] == 0 || strstr (buf, "complete") == 0)
-    error (_("Upload file not found: %s.srec\n"
-	     "Check IP addresses and download path."),
-	   args);
-  else
-    printf_filtered (" -- Ethernet load complete.\n");
-
-  gettimeofday (&end_time, NULL);
-  abfd = gdb_bfd_open (args, NULL, -1);
-  cleanup = make_cleanup_bfd_unref (abfd);
-  if (abfd != NULL)
-    {		/* Download is done -- print section statistics.  */
-      if (bfd_check_format (abfd, bfd_object) == 0)
-	{
-	  printf_filtered ("File is not an object file\n");
-	}
-      for (s = abfd->sections; s; s = s->next)
-	if (s->flags & SEC_LOAD)
-	  {
-	    bfd_size_type section_size = bfd_section_size (abfd, s);
-	    bfd_vma section_base = bfd_section_lma (abfd, s);
-
-	    data_count += section_size;
-
-	    printf_filtered ("Loading section %s, size 0x%lx lma ",
-			     bfd_section_name (abfd, s),
-			     (unsigned long) section_size);
-	    fputs_filtered (paddress (target_gdbarch (), section_base),
-			    gdb_stdout);
-	    printf_filtered ("\n");
-	    gdb_flush (gdb_stdout);
-	  }
-      /* Finally, make the PC point at the start address.  */
-      regcache_write_pc (get_current_regcache (),
-			 bfd_get_start_address (abfd));
-      printf_filtered ("Start address 0x%lx\n", 
-		       (unsigned long) bfd_get_start_address (abfd));
-      print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
-				  &end_time);
-    }
-  inferior_ptid = null_ptid;	/* No process now.  */
-
-  /* This is necessary because many things were based on the PC at the
-     time that we attached to the monitor, which is no longer valid
-     now that we have loaded new code (and just changed the PC).
-     Another way to do this might be to call normal_stop, except that
-     the stack may not be valid, and things would get horribly
-     confused...  */
-
-  clear_symtab_users (0);
-  do_cleanups (cleanup);
-}
-
-/* Provide a prototype to silence -Wmissing-prototypes.  */
-extern initialize_file_ftype _initialize_m32r_rom;
-
-void
-_initialize_m32r_rom (void)
-{
-  /* Initialize m32r RevC monitor target.  */
-  init_m32r_cmds ();
-  init_monitor_ops (&m32r_ops);
-
-  m32r_ops.to_shortname = "m32r";
-  m32r_ops.to_longname = "m32r monitor";
-  m32r_ops.to_load = m32r_load_gen;	/* Monitor lacks a download
-					   command.  */
-  m32r_ops.to_doc = "Debug via the m32r monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  m32r_ops.to_open = m32r_open;
-  add_target (&m32r_ops);
-
-  /* Initialize mon2000 monitor target */
-  init_mon2000_cmds ();
-  init_monitor_ops (&mon2000_ops);
-
-  mon2000_ops.to_shortname = "mon2000";
-  mon2000_ops.to_longname = "Mon2000 monitor";
-  mon2000_ops.to_load = m32r_load_gen;	/* Monitor lacks a download
-					   command.  */
-  mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  mon2000_ops.to_open = mon2000_open;
-  add_target (&mon2000_ops);
-
-  add_setshow_string_cmd ("download-path", class_obscure, &download_path, _("\
-Set the default path for downloadable SREC files."), _("\
-Show the default path for downloadable SREC files."), _("\
-Determines the default path for downloadable SREC files."),
-			  NULL,
-			  NULL, /* FIXME: i18n: The default path for
-				   downloadable SREC files is %s.  */
-			  &setlist, &showlist);
-
-  add_setshow_string_cmd ("board-address", class_obscure, &board_addr, _("\
-Set IP address for M32R-EVA target board."), _("\
-Show IP address for M32R-EVA target board."), _("\
-Determine the IP address for M32R-EVA target board."),
-			  NULL,
-			  NULL, /* FIXME: i18n: IP address for
-				   M32R-EVA target board is %s.  */
-			  &setlist, &showlist);
-
-  add_setshow_string_cmd ("server-address", class_obscure, &server_addr, _("\
-Set IP address for download server (GDB's host computer)."), _("\
-Show IP address for download server (GDB's host computer)."), _("\
-Determine the IP address for download server (GDB's host computer)."),
-			  NULL,
-			  NULL, /* FIXME: i18n: IP address for
-				   download server (GDB's host
-				   computer) is %s.  */
-			  &setlist, &showlist);
-
-  add_com ("upload", class_obscure, m32r_upload_command, _("\
-Upload the srec file via the monitor's Ethernet upload capability."));
-
-  add_com ("tload", class_obscure, m32r_load, _("test upload command."));
-}
diff --git a/gdb/microblaze-rom.c b/gdb/microblaze-rom.c
deleted file mode 100644
index beffadf..0000000
--- a/gdb/microblaze-rom.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/* Remote debugging interface to Xilinx MicroBlaze.
-
-   Copyright (C) 2009-2015 Free Software Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "monitor.h"
-#include "serial.h"
-#include "regcache.h"
-
-void _initialize_picobug_rom (void);
-
-static char *picobug_inits[] =
-{"\r", NULL};
-
-static struct target_ops picobug_ops;
-static struct monitor_ops picobug_cmds;
-
-/* Picobug only supports a subset of registers from MCore.  In reality,
-   it doesn't support ss1, either.  */
-static char *picobug_regnames[] = {
-  "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
-  "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
-  0,      0,      0,      0,      0,      0,      0,      0,
-  0,      0,      0,      0,      0,      0,      0,      0,
-  "psr",  "vbr",  "epsr", "fpsr", "epc",  "fpc",  0,      "ss1",
-  "ss2",  "ss3",  "ss4",  0,      0,      0,      0,      0,
-  0,      0,      0,      0,      0,      0,      0,      0,
-  0,      0,      0,      0,      0,      0,      0,      0,
-  "pc" };
-
-
-
-static void
-picobug_open (const char *args, int from_tty)
-{
-  monitor_open (args, &picobug_cmds, from_tty);
-}
-/* We choose to write our own dumpregs routine, since the output of
-   the register dumping is rather difficult to encapsulate in a
-   regexp:
-
-picobug> rd
-     pc 2f00031e      epc 2f00031e      fpc 00000000
-    psr 80000101     epsr 80000101     fpsr 00000000
-ss0-ss4 bad0beef 00000000 00000000 00000000 00000000      vbr 30005c00
-  r0-r7 2f0fff4c 00000090 00000001 00000002 00000003 00000004 00000005 00000006
- r8-r15 2f0fff64 00000000 00000000 00000000 00000000 00000000 00000000 2f00031e
-*/
-
-static int
-picobug_dumpregs (struct regcache *regcache)
-{
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
-  char buf[1024];
-  int resp_len;
-  char *p;
-
-  /* Send the dump register command to the monitor and
-     get the reply.  */
-  monitor_printf (picobug_cmds.dump_registers);
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));
-
-  p = strtok (buf, " \t\r\n");
-  while (p)
-    {
-      if (strchr (p, '-'))
-	{
-	  /* Got a range.  Either r0-r7, r8-r15 or ss0-ss4.  */
-	  if (startswith (p, "r0") || startswith (p, "r8"))
-	    {
-	      int rn = (p[1] == '0' ? 0 : 8);
-	      int i = 0;
-
-	      /* Get the next 8 values and record them.  */
-	      while (i < 8)
-		{
-		  p = strtok (NULL, " \t\r\n");
-		  if (p)
-		    monitor_supply_register (regcache, rn + i, p);
-		  i++;
-		}
-	    }
-	  else if (startswith (p, "ss"))
-	    {
-	      /* Get the next five values, ignoring the first.  */
-	      int rn;
-	      p = strtok (NULL, " \t\r\n");
-	      for (rn = 39; rn < 43; rn++)
-		{
-		  p = strtok (NULL, " \t\r\n");
-		  if (p)
-		    monitor_supply_register (regcache, rn, p);
-		}
-	    }
-	  else
-	    {
-	      break;
-	    }
-	}
-      else
-	{
-	  /* Simple register type, paired.  */
-	  char *name = p;
-	  int i;
-
-	  /* Get and record value.  */
-	  p = strtok (NULL, " \t\r\n");
-	  if (p)
-	    {
-	      for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
-		{
-		  if (picobug_regnames[i]
-		      && strcmp (picobug_regnames[i], name) == 0)
-		    break;
-		}
-
-	      if (i <= gdbarch_num_regs (gdbarch))
-		monitor_supply_register (regcache, i, p);
-	    }
-	}
-      p = strtok (NULL, " \t\r\n");
-    }
-
-  return 0;
-}
-
-static void
-init_picobug_cmds (void)
-{
-  picobug_cmds.flags = MO_GETMEM_NEEDS_RANGE | MO_CLR_BREAK_USES_ADDR
-		       | MO_PRINT_PROGRAM_OUTPUT;
-
-  picobug_cmds.init = picobug_inits;		/* Init strings		*/
-  picobug_cmds.cont = "g\n";			/* continue command	*/
-  picobug_cmds.step = "s\n";			/* single step		*/
-  picobug_cmds.set_break = "br %x\n";		/* set a breakpoint	*/
-  picobug_cmds.clr_break = "nobr %x\n";		/* clear a breakpoint	*/
-  picobug_cmds.clr_all_break = "nobr\n";	/* clear all breakpoints */
-  picobug_cmds.setmem.cmdb = "mm %x %x ;b\n";	/* setmem.cmdb (addr, value) */
-  picobug_cmds.setmem.cmdw = "mm %x %x ;h\n";	/* setmem.cmdw (addr, value) */
-  picobug_cmds.setmem.cmdl = "mm %x %x ;w\n";	/* setmem.cmdl (addr, value) */
-  picobug_cmds.getmem.cmdb = "md %x %x\n";	/* getmem.cmdb (start addr,
-						   end addr) 		*/
-  picobug_cmds.getmem.resp_delim = ":";		/* getmem.resp_delim	*/
-  picobug_cmds.setreg.cmd = "rm %s %x\n";	/* setreg.cmd (name, value) */
-  picobug_cmds.getreg.cmd = "rd %s\n";		/* getreg.cmd (name)	*/
-  picobug_cmds.getreg.resp_delim = ":";		/* getreg.resp_delim	*/
-  picobug_cmds.dump_registers = "rd\n";		/* dump_registers	*/
-  picobug_cmds.dumpregs = picobug_dumpregs;	/* dump registers parser */
-  picobug_cmds.load = "lo\n";			/* download command	*/
-  picobug_cmds.prompt = "picobug> ";		/* monitor command prompt */
-  picobug_cmds.line_term = "\n";		/* end-of-line terminator */
-  picobug_cmds.target = &picobug_ops;		/* target operations	*/
-  picobug_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits	*/
-  picobug_cmds.regnames = picobug_regnames;	/* registers names	*/
-  picobug_cmds.num_breakpoints = 20;		/* number of breakpoints */
-  picobug_cmds.magic = MONITOR_OPS_MAGIC;	/* magic		*/
-}
-
-void
-_initialize_picobug_rom (void)
-{
-  int i;
-
-  /* Initialize m32r RevC monitor target.  */
-  init_picobug_cmds ();
-  init_monitor_ops (&picobug_ops);
-  picobug_ops.to_shortname = "picobug";
-  picobug_ops.to_longname = "picobug monitor";
-  picobug_ops.to_doc = "Debug via the picobug monitor.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  picobug_ops.to_open = picobug_open;
-
-  add_target (&picobug_ops);
-}
diff --git a/gdb/monitor.c b/gdb/monitor.c
deleted file mode 100644
index 4657d73..0000000
--- a/gdb/monitor.c
+++ /dev/null
@@ -1,2417 +0,0 @@
-/* Remote debugging interface for boot monitors, for GDB.
-
-   Copyright (C) 1990-2015 Free Software Foundation, Inc.
-
-   Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
-   Resurrected from the ashes by Stu Grossman.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* This file was derived from various remote-* modules.  It is a collection
-   of generic support functions so GDB can talk directly to a ROM based
-   monitor.  This saves use from having to hack an exception based handler
-   into existence, and makes for quick porting.
-
-   This module talks to a debug monitor called 'MONITOR', which
-   We communicate with MONITOR via either a direct serial line, or a TCP
-   (or possibly TELNET) stream to a terminal multiplexor,
-   which in turn talks to the target board.  */
-
-/* FIXME 32x64: This code assumes that registers and addresses are at
-   most 32 bits long.  If they can be larger, you will need to declare
-   values as LONGEST and use %llx or some such to print values when
-   building commands to send to the monitor.  Since we don't know of
-   any actual 64-bit targets with ROM monitors that use this code,
-   it's not an issue right now.  -sts 4/18/96  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include <signal.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include "command.h"
-#include "serial.h"
-#include "monitor.h"
-#include "gdbcmd.h"
-#include "inferior.h"
-#include "infrun.h"
-#include "gdb_regex.h"
-#include "srec.h"
-#include "regcache.h"
-#include "gdbthread.h"
-#include "readline/readline.h"
-#include "rsp-low.h"
-
-static char *dev_name;
-static struct target_ops *targ_ops;
-
-static void monitor_interrupt_query (void);
-static void monitor_interrupt_twice (int);
-static void monitor_stop (struct target_ops *self, ptid_t);
-static void monitor_dump_regs (struct regcache *regcache);
-
-#if 0
-static int from_hex (int a);
-#endif
-
-static struct monitor_ops *current_monitor;
-
-static int hashmark;		/* flag set by "set hash".  */
-
-static int timeout = 30;
-
-static int in_monitor_wait = 0;	/* Non-zero means we are in monitor_wait().  */
-
-static void (*ofunc) ();	/* Old SIGINT signal handler.  */
-
-static CORE_ADDR *breakaddr;
-
-/* Descriptor for I/O to remote machine.  Initialize it to NULL so
-   that monitor_open knows that we don't have a file open when the
-   program starts.  */
-
-static struct serial *monitor_desc = NULL;
-
-/* Pointer to regexp pattern matching data.  */
-
-static struct re_pattern_buffer register_pattern;
-static char register_fastmap[256];
-
-static struct re_pattern_buffer getmem_resp_delim_pattern;
-static char getmem_resp_delim_fastmap[256];
-
-static struct re_pattern_buffer setmem_resp_delim_pattern;
-static char setmem_resp_delim_fastmap[256];
-
-static struct re_pattern_buffer setreg_resp_delim_pattern;
-static char setreg_resp_delim_fastmap[256];
-
-static int dump_reg_flag;	/* Non-zero means do a dump_registers cmd when
-				   monitor_wait wakes up.  */
-
-static int first_time = 0;	/* Is this the first time we're
-				   executing after gaving created the
-				   child proccess?  */
-
-
-/* This is the ptid we use while we're connected to a monitor.  Its
-   value is arbitrary, as monitor targets don't have a notion of
-   processes or threads, but we need something non-null to place in
-   inferior_ptid.  */
-static ptid_t monitor_ptid;
-
-#define TARGET_BUF_SIZE 2048
-
-/* Monitor specific debugging information.  Typically only useful to
-   the developer of a new monitor interface.  */
-
-static void monitor_debug (const char *fmt, ...) ATTRIBUTE_PRINTF (1, 2);
-
-static unsigned int monitor_debug_p = 0;
-
-/* NOTE: This file alternates between monitor_debug_p and remote_debug
-   when determining if debug information is printed.  Perhaps this
-   could be simplified.  */
-
-static void
-monitor_debug (const char *fmt, ...)
-{
-  if (monitor_debug_p)
-    {
-      va_list args;
-
-      va_start (args, fmt);
-      vfprintf_filtered (gdb_stdlog, fmt, args);
-      va_end (args);
-    }
-}
-
-
-/* Convert a string into a printable representation, Return # byte in
-   the new string.  When LEN is >0 it specifies the size of the
-   string.  Otherwize strlen(oldstr) is used.  */
-
-static void
-monitor_printable_string (char *newstr, char *oldstr, int len)
-{
-  int ch;
-  int i;
-
-  if (len <= 0)
-    len = strlen (oldstr);
-
-  for (i = 0; i < len; i++)
-    {
-      ch = oldstr[i];
-      switch (ch)
-	{
-	default:
-	  if (isprint (ch))
-	    *newstr++ = ch;
-
-	  else
-	    {
-	      sprintf (newstr, "\\x%02x", ch & 0xff);
-	      newstr += 4;
-	    }
-	  break;
-
-	case '\\':
-	  *newstr++ = '\\';
-	  *newstr++ = '\\';
-	  break;
-	case '\b':
-	  *newstr++ = '\\';
-	  *newstr++ = 'b';
-	  break;
-	case '\f':
-	  *newstr++ = '\\';
-	  *newstr++ = 't';
-	  break;
-	case '\n':
-	  *newstr++ = '\\';
-	  *newstr++ = 'n';
-	  break;
-	case '\r':
-	  *newstr++ = '\\';
-	  *newstr++ = 'r';
-	  break;
-	case '\t':
-	  *newstr++ = '\\';
-	  *newstr++ = 't';
-	  break;
-	case '\v':
-	  *newstr++ = '\\';
-	  *newstr++ = 'v';
-	  break;
-	}
-    }
-
-  *newstr++ = '\0';
-}
-
-/* Print monitor errors with a string, converting the string to printable
-   representation.  */
-
-static void
-monitor_error (char *function, char *message,
-	       CORE_ADDR memaddr, int len, char *string, int final_char)
-{
-  int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
-  char *safe_string = alloca ((real_len * 4) + 1);
-
-  monitor_printable_string (safe_string, string, real_len);
-
-  if (final_char)
-    error (_("%s (%s): %s: %s%c"),
-	   function, paddress (target_gdbarch (), memaddr),
-	   message, safe_string, final_char);
-  else
-    error (_("%s (%s): %s: %s"),
-	   function, paddress (target_gdbarch (), memaddr),
-	   message, safe_string);
-}
-
-/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
-
-   This function exists to get around the problem that many host platforms
-   don't have a printf that can print 64-bit addresses.  The %A format
-   specification is recognized as a special case, and causes the argument
-   to be printed as a 64-bit hexadecimal address.
-
-   Only format specifiers of the form "[0-9]*[a-z]" are recognized.
-   If it is a '%s' format, the argument is a string; otherwise the
-   argument is assumed to be a long integer.
-
-   %% is also turned into a single %.  */
-
-static void
-monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
-{
-  int addr_bit = gdbarch_addr_bit (target_gdbarch ());
-  char format[10];
-  char fmt;
-  char *p;
-  int i;
-  long arg_int;
-  CORE_ADDR arg_addr;
-  char *arg_string;
-
-  for (p = pattern; *p; p++)
-    {
-      if (*p == '%')
-	{
-	  /* Copy the format specifier to a separate buffer.  */
-	  format[0] = *p++;
-	  for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
-	       i++, p++)
-	    format[i] = *p;
-	  format[i] = fmt = *p;
-	  format[i + 1] = '\0';
-
-	  /* Fetch the next argument and print it.  */
-	  switch (fmt)
-	    {
-	    case '%':
-	      strcpy (sndbuf, "%");
-	      break;
-	    case 'A':
-	      arg_addr = va_arg (args, CORE_ADDR);
-	      strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
-	      break;
-	    case 's':
-	      arg_string = va_arg (args, char *);
-	      sprintf (sndbuf, format, arg_string);
-	      break;
-	    default:
-	      arg_int = va_arg (args, long);
-	      sprintf (sndbuf, format, arg_int);
-	      break;
-	    }
-	  sndbuf += strlen (sndbuf);
-	}
-      else
-	*sndbuf++ = *p;
-    }
-  *sndbuf = '\0';
-}
-
-
-/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
-   Works just like printf.  */
-
-void
-monitor_printf_noecho (char *pattern,...)
-{
-  va_list args;
-  char sndbuf[2000];
-  int len;
-
-  va_start (args, pattern);
-
-  monitor_vsprintf (sndbuf, pattern, args);
-
-  len = strlen (sndbuf);
-  if (len + 1 > sizeof sndbuf)
-    internal_error (__FILE__, __LINE__,
-		    _("failed internal consistency check"));
-
-  if (monitor_debug_p)
-    {
-      char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
-
-      monitor_printable_string (safe_string, sndbuf, 0);
-      fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
-    }
-
-  monitor_write (sndbuf, len);
-}
-
-/* monitor_printf -- Send data to monitor and check the echo.  Works just like
-   printf.  */
-
-void
-monitor_printf (char *pattern,...)
-{
-  va_list args;
-  char sndbuf[2000];
-  int len;
-
-  va_start (args, pattern);
-
-  monitor_vsprintf (sndbuf, pattern, args);
-
-  len = strlen (sndbuf);
-  if (len + 1 > sizeof sndbuf)
-    internal_error (__FILE__, __LINE__,
-		    _("failed internal consistency check"));
-
-  if (monitor_debug_p)
-    {
-      char *safe_string = (char *) alloca ((len * 4) + 1);
-
-      monitor_printable_string (safe_string, sndbuf, 0);
-      fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
-    }
-
-  monitor_write (sndbuf, len);
-
-  /* We used to expect that the next immediate output was the
-     characters we just output, but sometimes some extra junk appeared
-     before the characters we expected, like an extra prompt, or a
-     portmaster sending telnet negotiations.  So, just start searching
-     for what we sent, and skip anything unknown.  */
-  monitor_debug ("ExpectEcho\n");
-  monitor_expect (sndbuf, (char *) 0, 0);
-}
-
-
-/* Write characters to the remote system.  */
-
-void
-monitor_write (char *buf, int buflen)
-{
-  if (serial_write (monitor_desc, buf, buflen))
-    fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
-			safe_strerror (errno));
-}
-
-
-/* Read a binary character from the remote system, doing all the fancy
-   timeout stuff, but without interpreting the character in any way,
-   and without printing remote debug information.  */
-
-int
-monitor_readchar (void)
-{
-  int c;
-  int looping;
-
-  do
-    {
-      looping = 0;
-      c = serial_readchar (monitor_desc, timeout);
-
-      if (c >= 0)
-	c &= 0xff;		/* don't lose bit 7 */
-    }
-  while (looping);
-
-  if (c >= 0)
-    return c;
-
-  if (c == SERIAL_TIMEOUT)
-    error (_("Timeout reading from remote system."));
-
-  perror_with_name (_("remote-monitor"));
-}
-
-
-/* Read a character from the remote system, doing all the fancy
-   timeout stuff.  */
-
-static int
-readchar (int timeout)
-{
-  int c;
-  static enum
-    {
-      last_random, last_nl, last_cr, last_crnl
-    }
-  state = last_random;
-  int looping;
-
-  do
-    {
-      looping = 0;
-      c = serial_readchar (monitor_desc, timeout);
-
-      if (c >= 0)
-	{
-	  c &= 0x7f;
-	  /* This seems to interfere with proper function of the
-	     input stream.  */
-	  if (monitor_debug_p || remote_debug)
-	    {
-	      char buf[2];
-
-	      buf[0] = c;
-	      buf[1] = '\0';
-	      puts_debug ("read -->", buf, "<--");
-	    }
-
-	}
-
-      /* Canonicialize \n\r combinations into one \r.  */
-      if ((current_monitor->flags & MO_HANDLE_NL) != 0)
-	{
-	  if ((c == '\r' && state == last_nl)
-	      || (c == '\n' && state == last_cr))
-	    {
-	      state = last_crnl;
-	      looping = 1;
-	    }
-	  else if (c == '\r')
-	    state = last_cr;
-	  else if (c != '\n')
-	    state = last_random;
-	  else
-	    {
-	      state = last_nl;
-	      c = '\r';
-	    }
-	}
-    }
-  while (looping);
-
-  if (c >= 0)
-    return c;
-
-  if (c == SERIAL_TIMEOUT)
-#if 0
-    /* I fail to see how detaching here can be useful.  */
-    if (in_monitor_wait)	/* Watchdog went off.  */
-      {
-	target_mourn_inferior ();
-	error (_("GDB serial timeout has expired.  Target detached."));
-      }
-    else
-#endif
-      error (_("Timeout reading from remote system."));
-
-  perror_with_name (_("remote-monitor"));
-}
-
-/* Scan input from the remote system, until STRING is found.  If BUF is non-
-   zero, then collect input until we have collected either STRING or BUFLEN-1
-   chars.  In either case we terminate BUF with a 0.  If input overflows BUF
-   because STRING can't be found, return -1, else return number of chars in BUF
-   (minus the terminating NUL).  Note that in the non-overflow case, STRING
-   will be at the end of BUF.  */
-
-int
-monitor_expect (char *string, char *buf, int buflen)
-{
-  char *p = string;
-  int obuflen = buflen;
-  int c;
-
-  if (monitor_debug_p)
-    {
-      char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
-      monitor_printable_string (safe_string, string, 0);
-      fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
-    }
-
-  immediate_quit++;
-  QUIT;
-  while (1)
-    {
-      if (buf)
-	{
-	  if (buflen < 2)
-	    {
-	      *buf = '\000';
-	      immediate_quit--;
-	      return -1;
-	    }
-
-	  c = readchar (timeout);
-	  if (c == '\000')
-	    continue;
-	  *buf++ = c;
-	  buflen--;
-	}
-      else
-	c = readchar (timeout);
-
-      /* Don't expect any ^C sent to be echoed.  */
-
-      if (*p == '\003' || c == *p)
-	{
-	  p++;
-	  if (*p == '\0')
-	    {
-	      immediate_quit--;
-
-	      if (buf)
-		{
-		  *buf++ = '\000';
-		  return obuflen - buflen;
-		}
-	      else
-		return 0;
-	    }
-	}
-      else
-	{
-	  /* We got a character that doesn't match the string.  We need to
-	     back up p, but how far?  If we're looking for "..howdy" and the
-	     monitor sends "...howdy"?  There's certainly a match in there,
-	     but when we receive the third ".", we won't find it if we just
-	     restart the matching at the beginning of the string.
-
-	     This is a Boyer-Moore kind of situation.  We want to reset P to
-	     the end of the longest prefix of STRING that is a suffix of
-	     what we've read so far.  In the example above, that would be
-	     ".." --- the longest prefix of "..howdy" that is a suffix of
-	     "...".  This longest prefix could be the empty string, if C
-	     is nowhere to be found in STRING.
-
-	     If this longest prefix is not the empty string, it must contain
-	     C, so let's search from the end of STRING for instances of C,
-	     and see if the portion of STRING before that is a suffix of
-	     what we read before C.  Actually, we can search backwards from
-	     p, since we know no prefix can be longer than that.
-
-	     Note that we can use STRING itself, along with C, as a record
-	     of what we've received so far.  :)  */
-	  int i;
-
-	  for (i = (p - string) - 1; i >= 0; i--)
-	    if (string[i] == c)
-	      {
-		/* Is this prefix a suffix of what we've read so far?
-		   In other words, does
-                     string[0 .. i-1] == string[p - i, p - 1]?  */
-		if (! memcmp (string, p - i, i))
-		  {
-		    p = string + i + 1;
-		    break;
-		  }
-	      }
-	  if (i < 0)
-	    p = string;
-	}
-    }
-}
-
-/* Search for a regexp.  */
-
-static int
-monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
-{
-  char *mybuf;
-  char *p;
-
-  monitor_debug ("MON Expecting regexp\n");
-  if (buf)
-    mybuf = buf;
-  else
-    {
-      mybuf = alloca (TARGET_BUF_SIZE);
-      buflen = TARGET_BUF_SIZE;
-    }
-
-  p = mybuf;
-  while (1)
-    {
-      int retval;
-
-      if (p - mybuf >= buflen)
-	{			/* Buffer about to overflow.  */
-
-/* On overflow, we copy the upper half of the buffer to the lower half.  Not
-   great, but it usually works...  */
-
-	  memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
-	  p = mybuf + buflen / 2;
-	}
-
-      *p++ = readchar (timeout);
-
-      retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
-      if (retval >= 0)
-	return 1;
-    }
-}
-
-/* Keep discarding input until we see the MONITOR prompt.
-
-   The convention for dealing with the prompt is that you
-   o give your command
-   o *then* wait for the prompt.
-
-   Thus the last thing that a procedure does with the serial line will
-   be an monitor_expect_prompt().  Exception: monitor_resume does not
-   wait for the prompt, because the terminal is being handed over to
-   the inferior.  However, the next thing which happens after that is
-   a monitor_wait which does wait for the prompt.  Note that this
-   includes abnormal exit, e.g. error().  This is necessary to prevent
-   getting into states from which we can't recover.  */
-
-int
-monitor_expect_prompt (char *buf, int buflen)
-{
-  monitor_debug ("MON Expecting prompt\n");
-  return monitor_expect (current_monitor->prompt, buf, buflen);
-}
-
-/* Get N 32-bit words from remote, each preceded by a space, and put
-   them in registers starting at REGNO.  */
-
-#if 0
-static unsigned long
-get_hex_word (void)
-{
-  unsigned long val;
-  int i;
-  int ch;
-
-  do
-    ch = readchar (timeout);
-  while (isspace (ch));
-
-  val = from_hex (ch);
-
-  for (i = 7; i >= 1; i--)
-    {
-      ch = readchar (timeout);
-      if (!isxdigit (ch))
-	break;
-      val = (val << 4) | from_hex (ch);
-    }
-
-  return val;
-}
-#endif
-
-static void
-compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
-		 char *fastmap)
-{
-  int tmp;
-  const char *val;
-
-  compiled_pattern->fastmap = fastmap;
-
-  tmp = re_set_syntax (RE_SYNTAX_EMACS);
-  val = re_compile_pattern (pattern,
-			    strlen (pattern),
-			    compiled_pattern);
-  re_set_syntax (tmp);
-
-  if (val)
-    error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
-	   pattern, val);
-
-  if (fastmap)
-    re_compile_fastmap (compiled_pattern);
-}
-
-/* Open a connection to a remote debugger.  NAME is the filename used
-   for communication.  */
-
-void
-monitor_open (const char *args, struct monitor_ops *mon_ops, int from_tty)
-{
-  const char *name;
-  char **p;
-  struct inferior *inf;
-
-  if (mon_ops->magic != MONITOR_OPS_MAGIC)
-    error (_("Magic number of monitor_ops struct wrong."));
-
-  targ_ops = mon_ops->target;
-  name = targ_ops->to_shortname;
-
-  if (!args)
-    error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
-`target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
-
-  target_preopen (from_tty);
-
-  /* Setup pattern for register dump.  */
-
-  if (mon_ops->register_pattern)
-    compile_pattern (mon_ops->register_pattern, &register_pattern,
-		     register_fastmap);
-
-  if (mon_ops->getmem.resp_delim)
-    compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
-		     getmem_resp_delim_fastmap);
-
-  if (mon_ops->setmem.resp_delim)
-    compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
-                     setmem_resp_delim_fastmap);
-
-  if (mon_ops->setreg.resp_delim)
-    compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
-                     setreg_resp_delim_fastmap);
-  
-  unpush_target (targ_ops);
-
-  if (dev_name)
-    xfree (dev_name);
-  dev_name = xstrdup (args);
-
-  monitor_desc = serial_open (dev_name);
-
-  if (!monitor_desc)
-    perror_with_name (dev_name);
-
-  if (baud_rate != -1)
-    {
-      if (serial_setbaudrate (monitor_desc, baud_rate))
-	{
-	  serial_close (monitor_desc);
-	  perror_with_name (dev_name);
-	}
-    }
-
-  serial_setparity (monitor_desc, serial_parity);
-  serial_raw (monitor_desc);
-
-  serial_flush_input (monitor_desc);
-
-  /* some systems only work with 2 stop bits.  */
-
-  serial_setstopbits (monitor_desc, mon_ops->stopbits);
-
-  current_monitor = mon_ops;
-
-  /* See if we can wake up the monitor.  First, try sending a stop sequence,
-     then send the init strings.  Last, remove all breakpoints.  */
-
-  if (current_monitor->stop)
-    {
-      monitor_stop (targ_ops, inferior_ptid);
-      if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
-	{
-	  monitor_debug ("EXP Open echo\n");
-	  monitor_expect_prompt (NULL, 0);
-	}
-    }
-
-  /* wake up the monitor and see if it's alive.  */
-  for (p = mon_ops->init; *p != NULL; p++)
-    {
-      /* Some of the characters we send may not be echoed,
-         but we hope to get a prompt at the end of it all.  */
-
-      if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
-	monitor_printf (*p);
-      else
-	monitor_printf_noecho (*p);
-      monitor_expect_prompt (NULL, 0);
-    }
-
-  serial_flush_input (monitor_desc);
-
-  /* Alloc breakpoints */
-  if (mon_ops->set_break != NULL)
-    {
-      if (mon_ops->num_breakpoints == 0)
-	mon_ops->num_breakpoints = 8;
-
-      breakaddr = (CORE_ADDR *)
-	xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
-      memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
-    }
-
-  /* Remove all breakpoints.  */
-
-  if (mon_ops->clr_all_break)
-    {
-      monitor_printf (mon_ops->clr_all_break);
-      monitor_expect_prompt (NULL, 0);
-    }
-
-  if (from_tty)
-    printf_unfiltered (_("Remote target %s connected to %s\n"),
-		       name, dev_name);
-
-  push_target (targ_ops);
-
-  /* Start afresh.  */
-  init_thread_list ();
-
-  /* Make run command think we are busy...  */
-  inferior_ptid = monitor_ptid;
-  inf = current_inferior ();
-  inferior_appeared (inf, ptid_get_pid (inferior_ptid));
-  add_thread_silent (inferior_ptid);
-
-  /* Give monitor_wait something to read.  */
-
-  monitor_printf (current_monitor->line_term);
-
-  init_wait_for_inferior ();
-
-  start_remote (from_tty);
-}
-
-/* Close out all files and local state before this target loses
-   control.  */
-
-void
-monitor_close (struct target_ops *self)
-{
-  if (monitor_desc)
-    serial_close (monitor_desc);
-
-  /* Free breakpoint memory.  */
-  if (breakaddr != NULL)
-    {
-      xfree (breakaddr);
-      breakaddr = NULL;
-    }
-
-  monitor_desc = NULL;
-
-  discard_all_inferiors ();
-}
-
-/* Terminate the open connection to the remote debugger.  Use this
-   when you want to detach and do something else with your gdb.  */
-
-static void
-monitor_detach (struct target_ops *ops, const char *args, int from_tty)
-{
-  unpush_target (ops);		/* calls monitor_close to do the real work.  */
-  if (from_tty)
-    printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
-}
-
-/* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
-
-char *
-monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
-{
-  struct gdbarch *gdbarch = get_regcache_arch (regcache);
-  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
-  ULONGEST val;
-  unsigned char regbuf[MAX_REGISTER_SIZE];
-  char *p;
-
-  val = 0;
-  p = valstr;
-  while (p && *p != '\0')
-    {
-      if (*p == '\r' || *p == '\n')
-        {
-          while (*p != '\0') 
-              p++;
-          break;
-        }
-      if (isspace (*p))
-        {
-          p++;
-          continue;
-        }
-      if (!isxdigit (*p) && *p != 'x')
-        {
-          break;
-        }
-
-      val <<= 4;
-      val += fromhex (*p++);
-    }
-  monitor_debug ("Supplying Register %d %s\n", regno, valstr);
-
-  if (val == 0 && valstr == p)
-    error (_("monitor_supply_register (%d):  bad value from monitor: %s."),
-	   regno, valstr);
-
-  /* supply register stores in target byte order, so swap here.  */
-
-  store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
-			  val);
-
-  regcache_raw_supply (regcache, regno, regbuf);
-
-  return p;
-}
-
-/* Tell the remote machine to resume.  */
-
-static void
-monitor_resume (struct target_ops *ops,
-		ptid_t ptid, int step, enum gdb_signal sig)
-{
-  /* Some monitors require a different command when starting a program.  */
-  monitor_debug ("MON resume\n");
-  if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
-    {
-      first_time = 0;
-      monitor_printf ("run\r");
-      if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
-	dump_reg_flag = 1;
-      return;
-    }
-  if (step)
-    monitor_printf (current_monitor->step);
-  else
-    {
-      if (current_monitor->continue_hook)
-	(*current_monitor->continue_hook) ();
-      else
-	monitor_printf (current_monitor->cont);
-      if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
-	dump_reg_flag = 1;
-    }
-}
-
-/* Parse the output of a register dump command.  A monitor specific
-   regexp is used to extract individual register descriptions of the
-   form REG=VAL.  Each description is split up into a name and a value
-   string which are passed down to monitor specific code.  */
-
-static void
-parse_register_dump (struct regcache *regcache, char *buf, int len)
-{
-  monitor_debug ("MON Parsing  register dump\n");
-  while (1)
-    {
-      int regnamelen, vallen;
-      char *regname, *val;
-
-      /* Element 0 points to start of register name, and element 1
-         points to the start of the register value.  */
-      struct re_registers register_strings;
-
-      memset (&register_strings, 0, sizeof (struct re_registers));
-
-      if (re_search (&register_pattern, buf, len, 0, len,
-		     &register_strings) == -1)
-	break;
-
-      regnamelen = register_strings.end[1] - register_strings.start[1];
-      regname = buf + register_strings.start[1];
-      vallen = register_strings.end[2] - register_strings.start[2];
-      val = buf + register_strings.start[2];
-
-      current_monitor->supply_register (regcache, regname, regnamelen,
-					val, vallen);
-
-      buf += register_strings.end[0];
-      len -= register_strings.end[0];
-    }
-}
-
-/* Send ^C to target to halt it.  Target will respond, and send us a
-   packet.  */
-
-static void
-monitor_interrupt (int signo)
-{
-  /* If this doesn't work, try more severe steps.  */
-  signal (signo, monitor_interrupt_twice);
-
-  if (monitor_debug_p || remote_debug)
-    fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
-
-  target_stop (inferior_ptid);
-}
-
-/* The user typed ^C twice.  */
-
-static void
-monitor_interrupt_twice (int signo)
-{
-  signal (signo, ofunc);
-
-  monitor_interrupt_query ();
-
-  signal (signo, monitor_interrupt);
-}
-
-/* Ask the user what to do when an interrupt is received.  */
-
-static void
-monitor_interrupt_query (void)
-{
-  target_terminal_ours ();
-
-  if (query (_("Interrupted while waiting for the program.\n\
-Give up (and stop debugging it)? ")))
-    {
-      target_mourn_inferior ();
-      quit ();
-    }
-
-  target_terminal_inferior ();
-}
-
-static void
-monitor_wait_cleanup (void *old_timeout)
-{
-  timeout = *(int *) old_timeout;
-  signal (SIGINT, ofunc);
-  in_monitor_wait = 0;
-}
-
-
-
-static void
-monitor_wait_filter (char *buf,
-		     int bufmax,
-		     int *ext_resp_len,
-		     struct target_waitstatus *status)
-{
-  int resp_len;
-
-  do
-    {
-      resp_len = monitor_expect_prompt (buf, bufmax);
-      *ext_resp_len = resp_len;
-
-      if (resp_len <= 0)
-	fprintf_unfiltered (gdb_stderr,
-			    "monitor_wait:  excessive "
-			    "response from monitor: %s.", buf);
-    }
-  while (resp_len < 0);
-
-  /* Print any output characters that were preceded by ^O.  */
-  /* FIXME - This would be great as a user settabgle flag.  */
-  if (monitor_debug_p || remote_debug
-      || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
-    {
-      int i;
-
-      for (i = 0; i < resp_len - 1; i++)
-	if (buf[i] == 0x0f)
-	  putchar_unfiltered (buf[++i]);
-    }
-}
-
-
-
-/* Wait until the remote machine stops, then return, storing status in
-   status just as `wait' would.  */
-
-static ptid_t
-monitor_wait (struct target_ops *ops,
-	      ptid_t ptid, struct target_waitstatus *status, int options)
-{
-  int old_timeout = timeout;
-  char buf[TARGET_BUF_SIZE];
-  int resp_len;
-  struct cleanup *old_chain;
-
-  status->kind = TARGET_WAITKIND_EXITED;
-  status->value.integer = 0;
-
-  old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
-  monitor_debug ("MON wait\n");
-
-#if 0
-  /* This is somthing other than a maintenance command.  */
-    in_monitor_wait = 1;
-  timeout = watchdog > 0 ? watchdog : -1;
-#else
-  timeout = -1;		/* Don't time out -- user program is running.  */
-#endif
-
-  ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
-
-  if (current_monitor->wait_filter)
-    (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
-  else
-    monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
-
-#if 0				/* Transferred to monitor wait filter.  */
-  do
-    {
-      resp_len = monitor_expect_prompt (buf, sizeof (buf));
-
-      if (resp_len <= 0)
-	fprintf_unfiltered (gdb_stderr,
-			    "monitor_wait:  excessive "
-			    "response from monitor: %s.", buf);
-    }
-  while (resp_len < 0);
-
-  /* Print any output characters that were preceded by ^O.  */
-  /* FIXME - This would be great as a user settabgle flag.  */
-  if (monitor_debug_p || remote_debug
-      || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
-    {
-      int i;
-
-      for (i = 0; i < resp_len - 1; i++)
-	if (buf[i] == 0x0f)
-	  putchar_unfiltered (buf[++i]);
-    }
-#endif
-
-  signal (SIGINT, ofunc);
-
-  timeout = old_timeout;
-#if 0
-  if (dump_reg_flag && current_monitor->dump_registers)
-    {
-      dump_reg_flag = 0;
-      monitor_printf (current_monitor->dump_registers);
-      resp_len = monitor_expect_prompt (buf, sizeof (buf));
-    }
-
-  if (current_monitor->register_pattern)
-    parse_register_dump (get_current_regcache (), buf, resp_len);
-#else
-  monitor_debug ("Wait fetching registers after stop\n");
-  monitor_dump_regs (get_current_regcache ());
-#endif
-
-  status->kind = TARGET_WAITKIND_STOPPED;
-  status->value.sig = GDB_SIGNAL_TRAP;
-
-  discard_cleanups (old_chain);
-
-  in_monitor_wait = 0;
-
-  return inferior_ptid;
-}
-
-/* Fetch register REGNO, or all registers if REGNO is -1.  Returns
-   errno value.  */
-
-static void
-monitor_fetch_register (struct regcache *regcache, int regno)
-{
-  const char *name;
-  char *zerobuf;
-  char *regbuf;
-  int i;
-
-  regbuf  = alloca (MAX_REGISTER_SIZE * 2 + 1);
-  zerobuf = alloca (MAX_REGISTER_SIZE);
-  memset (zerobuf, 0, MAX_REGISTER_SIZE);
-
-  if (current_monitor->regname != NULL)
-    name = current_monitor->regname (regno);
-  else
-    name = current_monitor->regnames[regno];
-  monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
-
-  if (!name || (*name == '\0'))
-    {
-      monitor_debug ("No register known for %d\n", regno);
-      regcache_raw_supply (regcache, regno, zerobuf);
-      return;
-    }
-
-  /* Send the register examine command.  */
-
-  monitor_printf (current_monitor->getreg.cmd, name);
-
-  /* If RESP_DELIM is specified, we search for that as a leading
-     delimiter for the register value.  Otherwise, we just start
-     searching from the start of the buf.  */
-
-  if (current_monitor->getreg.resp_delim)
-    {
-      monitor_debug ("EXP getreg.resp_delim\n");
-      monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
-      /* Handle case of first 32 registers listed in pairs.  */
-      if (current_monitor->flags & MO_32_REGS_PAIRED
-	  && (regno & 1) != 0 && regno < 32)
-	{
-	  monitor_debug ("EXP getreg.resp_delim\n");
-	  monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
-	}
-    }
-
-  /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set.  */
-  if (current_monitor->flags & MO_HEX_PREFIX)
-    {
-      int c;
-
-      c = readchar (timeout);
-      while (c == ' ')
-	c = readchar (timeout);
-      if ((c == '0') && ((c = readchar (timeout)) == 'x'))
-	;
-      else
-	error (_("Bad value returned from monitor "
-		 "while fetching register %x."),
-	       regno);
-    }
-
-  /* Read upto the maximum number of hex digits for this register, skipping
-     spaces, but stop reading if something else is seen.  Some monitors
-     like to drop leading zeros.  */
-
-  for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
-    {
-      int c;
-
-      c = readchar (timeout);
-      while (c == ' ')
-	c = readchar (timeout);
-
-      if (!isxdigit (c))
-	break;
-
-      regbuf[i] = c;
-    }
-
-  regbuf[i] = '\000';		/* Terminate the number.  */
-  monitor_debug ("REGVAL '%s'\n", regbuf);
-
-  /* If TERM is present, we wait for that to show up.  Also, (if TERM
-     is present), we will send TERM_CMD if that is present.  In any
-     case, we collect all of the output into buf, and then wait for
-     the normal prompt.  */
-
-  if (current_monitor->getreg.term)
-    {
-      monitor_debug ("EXP getreg.term\n");
-      monitor_expect (current_monitor->getreg.term, NULL, 0); /* Get
-								 response.  */
-    }
-
-  if (current_monitor->getreg.term_cmd)
-    {
-      monitor_debug ("EMIT getreg.term.cmd\n");
-      monitor_printf (current_monitor->getreg.term_cmd);
-    }
-  if (!current_monitor->getreg.term ||	/* Already expected or */
-      current_monitor->getreg.term_cmd)		/* ack expected.  */
-    monitor_expect_prompt (NULL, 0);	/* Get response.  */
-
-  monitor_supply_register (regcache, regno, regbuf);
-}
-
-/* Sometimes, it takes several commands to dump the registers.  */
-/* This is a primitive for use by variations of monitor interfaces in
-   case they need to compose the operation.  */
-
-int
-monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
-{
-  char buf[TARGET_BUF_SIZE];
-  int resp_len;
-
-  monitor_printf (block_cmd);
-  resp_len = monitor_expect_prompt (buf, sizeof (buf));
-  parse_register_dump (regcache, buf, resp_len);
-  return 1;
-}
-
-
-/* Read the remote registers into the block regs.  */
-/* Call the specific function if it has been provided.  */
-
-static void
-monitor_dump_regs (struct regcache *regcache)
-{
-  char buf[TARGET_BUF_SIZE];
-  int resp_len;
-
-  if (current_monitor->dumpregs)
-    (*(current_monitor->dumpregs)) (regcache);	/* Call supplied function.  */
-  else if (current_monitor->dump_registers)	/* Default version.  */
-    {
-      monitor_printf (current_monitor->dump_registers);
-      resp_len = monitor_expect_prompt (buf, sizeof (buf));
-      parse_register_dump (regcache, buf, resp_len);
-    }
-  else
-    /* Need some way to read registers.  */
-    internal_error (__FILE__, __LINE__,
-		    _("failed internal consistency check"));
-}
-
-static void
-monitor_fetch_registers (struct target_ops *ops,
-			 struct regcache *regcache, int regno)
-{
-  monitor_debug ("MON fetchregs\n");
-  if (current_monitor->getreg.cmd)
-    {
-      if (regno >= 0)
-	{
-	  monitor_fetch_register (regcache, regno);
-	  return;
-	}
-
-      for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
-	   regno++)
-	monitor_fetch_register (regcache, regno);
-    }
-  else
-    {
-      monitor_dump_regs (regcache);
-    }
-}
-
-/* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
-
-static void
-monitor_store_register (struct regcache *regcache, int regno)
-{
-  int reg_size = register_size (get_regcache_arch (regcache), regno);
-  const char *name;
-  ULONGEST val;
-  
-  if (current_monitor->regname != NULL)
-    name = current_monitor->regname (regno);
-  else
-    name = current_monitor->regnames[regno];
-  
-  if (!name || (*name == '\0'))
-    {
-      monitor_debug ("MON Cannot store unknown register\n");
-      return;
-    }
-
-  regcache_cooked_read_unsigned (regcache, regno, &val);
-  monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
-
-  /* Send the register deposit command.  */
-
-  if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
-    monitor_printf (current_monitor->setreg.cmd, val, name);
-  else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-    monitor_printf (current_monitor->setreg.cmd, name);
-  else
-    monitor_printf (current_monitor->setreg.cmd, name, val);
-
-  if (current_monitor->setreg.resp_delim)
-    {
-      monitor_debug ("EXP setreg.resp_delim\n");
-      monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
-      if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-	monitor_printf ("%s\r", phex_nz (val, reg_size));
-    }
-  if (current_monitor->setreg.term)
-    {
-      monitor_debug ("EXP setreg.term\n");
-      monitor_expect (current_monitor->setreg.term, NULL, 0);
-      if (current_monitor->flags & MO_SETREG_INTERACTIVE)
-	monitor_printf ("%s\r", phex_nz (val, reg_size));
-      monitor_expect_prompt (NULL, 0);
-    }
-  else
-    monitor_expect_prompt (NULL, 0);
-  if (current_monitor->setreg.term_cmd)		/* Mode exit required.  */
-    {
-      monitor_debug ("EXP setreg_termcmd\n");
-      monitor_printf ("%s", current_monitor->setreg.term_cmd);
-      monitor_expect_prompt (NULL, 0);
-    }
-}				/* monitor_store_register */
-
-/* Store the remote registers.  */
-
-static void
-monitor_store_registers (struct target_ops *ops,
-			 struct regcache *regcache, int regno)
-{
-  if (regno >= 0)
-    {
-      monitor_store_register (regcache, regno);
-      return;
-    }
-
-  for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
-       regno++)
-    monitor_store_register (regcache, regno);
-}
-
-/* Get ready to modify the registers array.  On machines which store
-   individual registers, this doesn't need to do anything.  On machines
-   which store all the registers in one fell swoop, this makes sure
-   that registers contains all the registers from the program being
-   debugged.  */
-
-static void
-monitor_prepare_to_store (struct target_ops *self, struct regcache *regcache)
-{
-  /* Do nothing, since we can store individual regs.  */
-}
-
-static void
-monitor_files_info (struct target_ops *ops)
-{
-  printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
-}
-
-static int
-monitor_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
-{
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
-  unsigned int val, hostval;
-  char *cmd;
-  int i;
-
-  monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch (), memaddr));
-
-  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
-
-  /* Use memory fill command for leading 0 bytes.  */
-
-  if (current_monitor->fill)
-    {
-      for (i = 0; i < len; i++)
-	if (myaddr[i] != 0)
-	  break;
-
-      if (i > 4)		/* More than 4 zeros is worth doing.  */
-	{
-	  monitor_debug ("MON FILL %d\n", i);
-	  if (current_monitor->flags & MO_FILL_USES_ADDR)
-	    monitor_printf (current_monitor->fill, memaddr,
-			    (memaddr + i) - 1, 0);
-	  else
-	    monitor_printf (current_monitor->fill, memaddr, i, 0);
-
-	  monitor_expect_prompt (NULL, 0);
-
-	  return i;
-	}
-    }
-
-#if 0
-  /* Can't actually use long longs if VAL is an int (nice idea, though).  */
-  if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
-    {
-      len = 8;
-      cmd = current_monitor->setmem.cmdll;
-    }
-  else
-#endif
-  if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
-    {
-      len = 4;
-      cmd = current_monitor->setmem.cmdl;
-    }
-  else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
-    {
-      len = 2;
-      cmd = current_monitor->setmem.cmdw;
-    }
-  else
-    {
-      len = 1;
-      cmd = current_monitor->setmem.cmdb;
-    }
-
-  val = extract_unsigned_integer (myaddr, len, byte_order);
-
-  if (len == 4)
-    {
-      hostval = *(unsigned int *) myaddr;
-      monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
-    }
-
-
-  if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
-    monitor_printf_noecho (cmd, memaddr, val);
-  else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
-    {
-      monitor_printf_noecho (cmd, memaddr);
-
-      if (current_monitor->setmem.resp_delim)
-        {
-          monitor_debug ("EXP setmem.resp_delim");
-          monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0); 
-	  monitor_printf ("%x\r", val);
-       }
-      if (current_monitor->setmem.term)
-	{
-	  monitor_debug ("EXP setmem.term");
-	  monitor_expect (current_monitor->setmem.term, NULL, 0);
-	  monitor_printf ("%x\r", val);
-	}
-      if (current_monitor->setmem.term_cmd)
-	{	/* Emit this to get out of the memory editing state.  */
-	  monitor_printf ("%s", current_monitor->setmem.term_cmd);
-	  /* Drop through to expecting a prompt.  */
-	}
-    }
-  else
-    monitor_printf (cmd, memaddr, val);
-
-  monitor_expect_prompt (NULL, 0);
-
-  return len;
-}
-
-
-static int
-monitor_write_memory_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
-{
-  unsigned char val;
-  int written = 0;
-
-  if (len == 0)
-    return 0;
-  /* Enter the sub mode.  */
-  monitor_printf (current_monitor->setmem.cmdb, memaddr);
-  monitor_expect_prompt (NULL, 0);
-  while (len)
-    {
-      val = *myaddr;
-      monitor_printf ("%x\r", val);
-      myaddr++;
-      memaddr++;
-      written++;
-      /* If we wanted to, here we could validate the address.  */
-      monitor_expect_prompt (NULL, 0);
-      len--;
-    }
-  /* Now exit the sub mode.  */
-  monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt (NULL, 0);
-  return written;
-}
-
-
-static void
-longlongendswap (unsigned char *a)
-{
-  int i, j;
-  unsigned char x;
-
-  i = 0;
-  j = 7;
-  while (i < 4)
-    {
-      x = *(a + i);
-      *(a + i) = *(a + j);
-      *(a + j) = x;
-      i++, j--;
-    }
-}
-/* Format 32 chars of long long value, advance the pointer.  */
-static char *hexlate = "0123456789abcdef";
-static char *
-longlong_hexchars (unsigned long long value,
-		   char *outbuff)
-{
-  if (value == 0)
-    {
-      *outbuff++ = '0';
-      return outbuff;
-    }
-  else
-    {
-      static unsigned char disbuf[8];	/* disassembly buffer */
-      unsigned char *scan, *limit;	/* loop controls */
-      unsigned char c, nib;
-      int leadzero = 1;
-
-      scan = disbuf;
-      limit = scan + 8;
-      {
-	unsigned long long *dp;
-
-	dp = (unsigned long long *) scan;
-	*dp = value;
-      }
-      longlongendswap (disbuf);	/* FIXME: ONly on big endian hosts.  */
-      while (scan < limit)
-	{
-	  c = *scan++;		/* A byte of our long long value.  */
-	  if (leadzero)
-	    {
-	      if (c == 0)
-		continue;
-	      else
-		leadzero = 0;	/* Henceforth we print even zeroes.  */
-	    }
-	  nib = c >> 4;		/* high nibble bits */
-	  *outbuff++ = hexlate[nib];
-	  nib = c & 0x0f;	/* low nibble bits */
-	  *outbuff++ = hexlate[nib];
-	}
-      return outbuff;
-    }
-}				/* longlong_hexchars */
-
-
-
-/* I am only going to call this when writing virtual byte streams.
-   Which possably entails endian conversions.  */
-
-static int
-monitor_write_memory_longlongs (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
-{
-  static char hexstage[20];	/* At least 16 digits required, plus null.  */
-  char *endstring;
-  long long *llptr;
-  long long value;
-  int written = 0;
-
-  llptr = (long long *) myaddr;
-  if (len == 0)
-    return 0;
-  monitor_printf (current_monitor->setmem.cmdll, memaddr);
-  monitor_expect_prompt (NULL, 0);
-  while (len >= 8)
-    {
-      value = *llptr;
-      endstring = longlong_hexchars (*llptr, hexstage);
-      *endstring = '\0';	/* NUll terminate for printf.  */
-      monitor_printf ("%s\r", hexstage);
-      llptr++;
-      memaddr += 8;
-      written += 8;
-      /* If we wanted to, here we could validate the address.  */
-      monitor_expect_prompt (NULL, 0);
-      len -= 8;
-    }
-  /* Now exit the sub mode.  */
-  monitor_printf (current_monitor->getreg.term_cmd);
-  monitor_expect_prompt (NULL, 0);
-  return written;
-}				/* */
-
-
-
-/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
-/* This is for the large blocks of memory which may occur in downloading.
-   And for monitors which use interactive entry,
-   And for monitors which do not have other downloading methods.
-   Without this, we will end up calling monitor_write_memory many times
-   and do the entry and exit of the sub mode many times
-   This currently assumes...
-   MO_SETMEM_INTERACTIVE
-   ! MO_NO_ECHO_ON_SETMEM
-   To use this, the you have to patch the monitor_cmds block with
-   this function.  Otherwise, its not tuned up for use by all
-   monitor variations.  */
-
-static int
-monitor_write_memory_block (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
-{
-  int written;
-
-  written = 0;
-  /* FIXME: This would be a good place to put the zero test.  */
-#if 1
-  if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
-    {
-      return monitor_write_memory_longlongs (memaddr, myaddr, len);
-    }
-#endif
-  written = monitor_write_memory_bytes (memaddr, myaddr, len);
-  return written;
-}
-
-/* This is an alternate form of monitor_read_memory which is used for monitors
-   which can only read a single byte/word/etc. at a time.  */
-
-static int
-monitor_read_memory_single (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
-{
-  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
-  unsigned int val;
-  char membuf[sizeof (int) * 2 + 1];
-  char *p;
-  char *cmd;
-
-  monitor_debug ("MON read single\n");
-#if 0
-  /* Can't actually use long longs (nice idea, though).  In fact, the
-     call to strtoul below will fail if it tries to convert a value
-     that's too big to fit in a long.  */
-  if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
-    {
-      len = 8;
-      cmd = current_monitor->getmem.cmdll;
-    }
-  else
-#endif
-  if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
-    {
-      len = 4;
-      cmd = current_monitor->getmem.cmdl;
-    }
-  else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
-    {
-      len = 2;
-      cmd = current_monitor->getmem.cmdw;
-    }
-  else
-    {
-      len = 1;
-      cmd = current_monitor->getmem.cmdb;
-    }
-
-  /* Send the examine command.  */
-
-  monitor_printf (cmd, memaddr);
-
-  /* If RESP_DELIM is specified, we search for that as a leading
-     delimiter for the memory value.  Otherwise, we just start
-     searching from the start of the buf.  */
-
-  if (current_monitor->getmem.resp_delim)
-    {
-      monitor_debug ("EXP getmem.resp_delim\n");
-      monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
-    }
-
-  /* Now, read the appropriate number of hex digits for this loc,
-     skipping spaces.  */
-
-  /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set.  */
-  if (current_monitor->flags & MO_HEX_PREFIX)
-    {
-      int c;
-
-      c = readchar (timeout);
-      while (c == ' ')
-	c = readchar (timeout);
-      if ((c == '0') && ((c = readchar (timeout)) == 'x'))
-	;
-      else
-	monitor_error ("monitor_read_memory_single", 
-		       "bad response from monitor",
-		       memaddr, 0, NULL, 0);
-    }
-
-  {
-    int i;
-
-    for (i = 0; i < len * 2; i++)
-      {
-	int c;
-
-	while (1)
-	  {
-	    c = readchar (timeout);
-	    if (isxdigit (c))
-	      break;
-	    if (c == ' ')
-	      continue;
-	    
-	    monitor_error ("monitor_read_memory_single",
-			   "bad response from monitor",
-			   memaddr, i, membuf, 0);
-	  }
-      membuf[i] = c;
-    }
-    membuf[i] = '\000';		/* Terminate the number.  */
-  }
-
-/* If TERM is present, we wait for that to show up.  Also, (if TERM is
-   present), we will send TERM_CMD if that is present.  In any case, we collect
-   all of the output into buf, and then wait for the normal prompt.  */
-
-  if (current_monitor->getmem.term)
-    {
-      monitor_expect (current_monitor->getmem.term, NULL, 0); /* Get
-								 response.  */
-
-      if (current_monitor->getmem.term_cmd)
-	{
-	  monitor_printf (current_monitor->getmem.term_cmd);
-	  monitor_expect_prompt (NULL, 0);
-	}
-    }
-  else
-    monitor_expect_prompt (NULL, 0);	/* Get response.  */
-
-  p = membuf;
-  val = strtoul (membuf, &p, 16);
-
-  if (val == 0 && membuf == p)
-    monitor_error ("monitor_read_memory_single",
-		   "bad value from monitor",
-		   memaddr, 0, membuf, 0);
-
-  /* supply register stores in target byte order, so swap here.  */
-
-  store_unsigned_integer (myaddr, len, byte_order, val);
-
-  return len;
-}
-
-/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
-   memory at MEMADDR.  Returns length moved.  Currently, we do no more
-   than 16 bytes at a time.  */
-
-static int
-monitor_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
-{
-  unsigned int val;
-  char buf[512];
-  char *p, *p1;
-  int resp_len;
-  int i;
-  CORE_ADDR dumpaddr;
-
-  if (len <= 0)
-    {
-      monitor_debug ("Zero length call to monitor_read_memory\n");
-      return 0;
-    }
-
-  monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
-		 paddress (target_gdbarch (), memaddr),
-		 host_address_to_string (myaddr), len);
-
-  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
-
-  if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
-    return monitor_read_memory_single (memaddr, myaddr, len);
-
-  len = min (len, 16);
-
-  /* Some dumpers align the first data with the preceding 16
-     byte boundary.  Some print blanks and start at the
-     requested boundary.  EXACT_DUMPADDR  */
-
-  dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
-    ? memaddr : memaddr & ~0x0f;
-
-  /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
-  if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
-    len = ((memaddr + len) & ~0xf) - memaddr;
-
-  /* Send the memory examine command.  */
-
-  if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
-    monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
-  else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
-    monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
-  else
-    monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
-
-  /* If TERM is present, we wait for that to show up.  Also, (if TERM
-     is present), we will send TERM_CMD if that is present.  In any
-     case, we collect all of the output into buf, and then wait for
-     the normal prompt.  */
-
-  if (current_monitor->getmem.term)
-    {
-      resp_len = monitor_expect (current_monitor->getmem.term,
-				 buf, sizeof buf);	/* Get response.  */
-
-      if (resp_len <= 0)
-	monitor_error ("monitor_read_memory",
-		       "excessive response from monitor",
-		       memaddr, resp_len, buf, 0);
-
-      if (current_monitor->getmem.term_cmd)
-	{
-	  serial_write (monitor_desc, current_monitor->getmem.term_cmd,
-			strlen (current_monitor->getmem.term_cmd));
-	  monitor_expect_prompt (NULL, 0);
-	}
-    }
-  else
-    resp_len = monitor_expect_prompt (buf, sizeof buf);	 /* Get response.  */
-
-  p = buf;
-
-  /* If RESP_DELIM is specified, we search for that as a leading
-     delimiter for the values.  Otherwise, we just start searching
-     from the start of the buf.  */
-
-  if (current_monitor->getmem.resp_delim)
-    {
-      int retval, tmp;
-      struct re_registers resp_strings;
-
-      monitor_debug ("MON getmem.resp_delim %s\n",
-		     current_monitor->getmem.resp_delim);
-
-      memset (&resp_strings, 0, sizeof (struct re_registers));
-      tmp = strlen (p);
-      retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
-			  &resp_strings);
-
-      if (retval < 0)
-	monitor_error ("monitor_read_memory",
-		       "bad response from monitor",
-		       memaddr, resp_len, buf, 0);
-
-      p += resp_strings.end[0];
-#if 0
-      p = strstr (p, current_monitor->getmem.resp_delim);
-      if (!p)
-	monitor_error ("monitor_read_memory",
-		       "bad response from monitor",
-		       memaddr, resp_len, buf, 0);
-      p += strlen (current_monitor->getmem.resp_delim);
-#endif
-    }
-  monitor_debug ("MON scanning  %d ,%s '%s'\n", len,
-		 host_address_to_string (p), p);
-  if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
-    {
-      char c;
-      int fetched = 0;
-      i = len;
-      c = *p;
-
-
-      while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
-	{
-	  if (isxdigit (c))
-	    {
-	      if ((dumpaddr >= memaddr) && (i > 0))
-		{
-		  val = fromhex (c) * 16 + fromhex (*(p + 1));
-		  *myaddr++ = val;
-		  if (monitor_debug_p || remote_debug)
-		    fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
-		  --i;
-		  fetched++;
-		}
-	      ++dumpaddr;
-	      ++p;
-	    }
-	  ++p;			/* Skip a blank or other non hex char.  */
-	  c = *p;
-	}
-      if (fetched == 0)
-	error (_("Failed to read via monitor"));
-      if (monitor_debug_p || remote_debug)
-	fprintf_unfiltered (gdb_stdlog, "\n");
-      return fetched;		/* Return the number of bytes actually
-				   read.  */
-    }
-  monitor_debug ("MON scanning bytes\n");
-
-  for (i = len; i > 0; i--)
-    {
-      /* Skip non-hex chars, but bomb on end of string and newlines.  */
-
-      while (1)
-	{
-	  if (isxdigit (*p))
-	    break;
-
-	  if (*p == '\000' || *p == '\n' || *p == '\r')
-	    monitor_error ("monitor_read_memory",
-			   "badly terminated response from monitor",
-			   memaddr, resp_len, buf, 0);
-	  p++;
-	}
-
-      val = strtoul (p, &p1, 16);
-
-      if (val == 0 && p == p1)
-	monitor_error ("monitor_read_memory",
-		       "bad value from monitor",
-		       memaddr, resp_len, buf, 0);
-
-      *myaddr++ = val;
-
-      if (i == 1)
-	break;
-
-      p = p1;
-    }
-
-  return len;
-}
-
-/* Helper for monitor_xfer_partial that handles memory transfers.
-   Arguments are like target_xfer_partial.  */
-
-static enum target_xfer_status
-monitor_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
-		     ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
-{
-  int res;
-
-  if (writebuf != NULL)
-    {
-      if (current_monitor->flags & MO_HAS_BLOCKWRITES)
-	res = monitor_write_memory_block (memaddr, writebuf, len);
-      else
-	res = monitor_write_memory (memaddr, writebuf, len);
-    }
-  else
-    {
-      res = monitor_read_memory (memaddr, readbuf, len);
-    }
-
-  if (res <= 0)
-    return TARGET_XFER_E_IO;
-  else
-    {
-      *xfered_len = (ULONGEST) res;
-      return TARGET_XFER_OK;
-    }
-}
-
-/* Target to_xfer_partial implementation.  */
-
-static enum target_xfer_status
-monitor_xfer_partial (struct target_ops *ops, enum target_object object,
-		      const char *annex, gdb_byte *readbuf,
-		      const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
-		      ULONGEST *xfered_len)
-{
-  switch (object)
-    {
-    case TARGET_OBJECT_MEMORY:
-      return monitor_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
-
-    default:
-      return TARGET_XFER_E_IO;
-    }
-}
-
-static void
-monitor_kill (struct target_ops *ops)
-{
-  return;			/* Ignore attempts to kill target system.  */
-}
-
-/* All we actually do is set the PC to the start address of exec_bfd.  */
-
-static void
-monitor_create_inferior (struct target_ops *ops, char *exec_file,
-			 char *args, char **env, int from_tty)
-{
-  if (args && (*args != '\000'))
-    error (_("Args are not supported by the monitor."));
-
-  first_time = 1;
-  clear_proceed_status (0);
-  regcache_write_pc (get_current_regcache (),
-		     bfd_get_start_address (exec_bfd));
-}
-
-/* Clean up when a program exits.
-   The program actually lives on in the remote processor's RAM, and may be
-   run again without a download.  Don't leave it full of breakpoint
-   instructions.  */
-
-static void
-monitor_mourn_inferior (struct target_ops *ops)
-{
-  unpush_target (targ_ops);
-  generic_mourn_inferior ();	/* Do all the proper things now.  */
-  delete_thread_silent (monitor_ptid);
-}
-
-/* Tell the monitor to add a breakpoint.  */
-
-static int
-monitor_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
-			   struct bp_target_info *bp_tgt)
-{
-  CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
-  int i;
-  int bplen;
-
-  monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
-  if (current_monitor->set_break == NULL)
-    error (_("No set_break defined for this monitor"));
-
-  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
-    addr = gdbarch_addr_bits_remove (gdbarch, addr);
-
-  /* Determine appropriate breakpoint size for this address.  */
-  gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
-  bp_tgt->placed_address = addr;
-  bp_tgt->placed_size = bplen;
-
-  for (i = 0; i < current_monitor->num_breakpoints; i++)
-    {
-      if (breakaddr[i] == 0)
-	{
-	  breakaddr[i] = addr;
-	  monitor_printf (current_monitor->set_break, addr);
-	  monitor_expect_prompt (NULL, 0);
-	  return 0;
-	}
-    }
-
-  error (_("Too many breakpoints (> %d) for monitor."),
-	 current_monitor->num_breakpoints);
-}
-
-/* Tell the monitor to remove a breakpoint.  */
-
-static int
-monitor_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
-			   struct bp_target_info *bp_tgt)
-{
-  CORE_ADDR addr = bp_tgt->placed_address;
-  int i;
-
-  monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
-  if (current_monitor->clr_break == NULL)
-    error (_("No clr_break defined for this monitor"));
-
-  for (i = 0; i < current_monitor->num_breakpoints; i++)
-    {
-      if (breakaddr[i] == addr)
-	{
-	  breakaddr[i] = 0;
-	  /* Some monitors remove breakpoints based on the address.  */
-	  if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
-	    monitor_printf (current_monitor->clr_break, addr);
-	  else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
-	    monitor_printf (current_monitor->clr_break, i + 1);
-	  else
-	    monitor_printf (current_monitor->clr_break, i);
-	  monitor_expect_prompt (NULL, 0);
-	  return 0;
-	}
-    }
-  fprintf_unfiltered (gdb_stderr,
-		      "Can't find breakpoint associated with %s\n",
-		      paddress (gdbarch, addr));
-  return 1;
-}
-
-/* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
-   an S-record.  Return non-zero if the ACK is received properly.  */
-
-static int
-monitor_wait_srec_ack (void)
-{
-  int ch;
-
-  if (current_monitor->flags & MO_SREC_ACK_PLUS)
-    {
-      return (readchar (timeout) == '+');
-    }
-  else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
-    {
-      /* Eat two backspaces, a "rotating" char (|/-\), and a space.  */
-      if ((ch = readchar (1)) < 0)
-	return 0;
-      if ((ch = readchar (1)) < 0)
-	return 0;
-      if ((ch = readchar (1)) < 0)
-	return 0;
-      if ((ch = readchar (1)) < 0)
-	return 0;
-    }
-  return 1;
-}
-
-/* monitor_load -- download a file.  */
-
-static void
-monitor_load (struct target_ops *self, const char *args, int from_tty)
-{
-  CORE_ADDR load_offset = 0;
-  char **argv;
-  struct cleanup *old_cleanups;
-  char *filename;
-
-  monitor_debug ("MON load\n");
-
-  if (args == NULL)
-    error_no_arg (_("file to load"));
-
-  argv = gdb_buildargv (args);
-  old_cleanups = make_cleanup_freeargv (argv);
-
-  filename = tilde_expand (argv[0]);
-  make_cleanup (xfree, filename);
-
-  /* Enable user to specify address for downloading as 2nd arg to load.  */
-  if (argv[1] != NULL)
-    {
-      const char *endptr;
-
-      load_offset = strtoulst (argv[1], &endptr, 0);
-
-      /* If the last word was not a valid number then
-	 treat it as a file name with spaces in.  */
-      if (argv[1] == endptr)
-	error (_("Invalid download offset:%s."), argv[1]);
-
-      if (argv[2] != NULL)
-	error (_("Too many parameters."));
-    }
-
-  monitor_printf (current_monitor->load);
-  if (current_monitor->loadresp)
-    monitor_expect (current_monitor->loadresp, NULL, 0);
-
-  load_srec (monitor_desc, filename, load_offset,
-	     32, SREC_ALL, hashmark,
-	     current_monitor->flags & MO_SREC_ACK ?
-	     monitor_wait_srec_ack : NULL);
-
-  monitor_expect_prompt (NULL, 0);
-
-  do_cleanups (old_cleanups);
-
-  /* Finally, make the PC point at the start address.  */
-  if (exec_bfd)
-    regcache_write_pc (get_current_regcache (),
-		       bfd_get_start_address (exec_bfd));
-
-  /* There used to be code here which would clear inferior_ptid and
-     call clear_symtab_users.  None of that should be necessary:
-     monitor targets should behave like remote protocol targets, and
-     since generic_load does none of those things, this function
-     shouldn't either.
-
-     Furthermore, clearing inferior_ptid is *incorrect*.  After doing
-     a load, we still have a valid connection to the monitor, with a
-     live processor state to fiddle with.  The user can type
-     `continue' or `jump *start' and make the program run.  If they do
-     these things, however, GDB will be talking to a running program
-     while inferior_ptid is null_ptid; this makes things like
-     reinit_frame_cache very confused.  */
-}
-
-static void
-monitor_stop (struct target_ops *self, ptid_t ptid)
-{
-  monitor_debug ("MON stop\n");
-  if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
-    serial_send_break (monitor_desc);
-  if (current_monitor->stop)
-    monitor_printf_noecho (current_monitor->stop);
-}
-
-/* Put a COMMAND string out to MONITOR.  Output from MONITOR is placed
-   in OUTPUT until the prompt is seen.  FIXME: We read the characters
-   ourseleves here cause of a nasty echo.  */
-
-static void
-monitor_rcmd (struct target_ops *self, const char *command,
-	      struct ui_file *outbuf)
-{
-  char *p;
-  int resp_len;
-  char buf[1000];
-
-  if (monitor_desc == NULL)
-    error (_("monitor target not open."));
-
-  p = current_monitor->prompt;
-
-  /* Send the command.  Note that if no args were supplied, then we're
-     just sending the monitor a newline, which is sometimes useful.  */
-
-  monitor_printf ("%s\r", (command ? command : ""));
-
-  resp_len = monitor_expect_prompt (buf, sizeof buf);
-
-  fputs_unfiltered (buf, outbuf);	/* Output the response.  */
-}
-
-/* Convert hex digit A to a number.  */
-
-#if 0
-static int
-from_hex (int a)
-{
-  if (a >= '0' && a <= '9')
-    return a - '0';
-  if (a >= 'a' && a <= 'f')
-    return a - 'a' + 10;
-  if (a >= 'A' && a <= 'F')
-    return a - 'A' + 10;
-
-  error (_("Reply contains invalid hex digit 0x%x"), a);
-}
-#endif
-
-char *
-monitor_get_dev_name (void)
-{
-  return dev_name;
-}
-
-/* Check to see if a thread is still alive.  */
-
-static int
-monitor_thread_alive (struct target_ops *ops, ptid_t ptid)
-{
-  if (ptid_equal (ptid, monitor_ptid))
-    /* The monitor's task is always alive.  */
-    return 1;
-
-  return 0;
-}
-
-/* Convert a thread ID to a string.  Returns the string in a static
-   buffer.  */
-
-static char *
-monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
-{
-  static char buf[64];
-
-  if (ptid_equal (monitor_ptid, ptid))
-    {
-      xsnprintf (buf, sizeof buf, "Thread <main>");
-      return buf;
-    }
-
-  return normal_pid_to_str (ptid);
-}
-
-static struct target_ops monitor_ops;
-
-static void
-init_base_monitor_ops (void)
-{
-  monitor_ops.to_close = monitor_close;
-  monitor_ops.to_detach = monitor_detach;
-  monitor_ops.to_resume = monitor_resume;
-  monitor_ops.to_wait = monitor_wait;
-  monitor_ops.to_fetch_registers = monitor_fetch_registers;
-  monitor_ops.to_store_registers = monitor_store_registers;
-  monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
-  monitor_ops.to_xfer_partial = monitor_xfer_partial;
-  monitor_ops.to_files_info = monitor_files_info;
-  monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
-  monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
-  monitor_ops.to_kill = monitor_kill;
-  monitor_ops.to_load = monitor_load;
-  monitor_ops.to_create_inferior = monitor_create_inferior;
-  monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
-  monitor_ops.to_stop = monitor_stop;
-  monitor_ops.to_rcmd = monitor_rcmd;
-  monitor_ops.to_log_command = serial_log_command;
-  monitor_ops.to_thread_alive = monitor_thread_alive;
-  monitor_ops.to_pid_to_str = monitor_pid_to_str;
-  monitor_ops.to_stratum = process_stratum;
-  monitor_ops.to_has_all_memory = default_child_has_all_memory;
-  monitor_ops.to_has_memory = default_child_has_memory;
-  monitor_ops.to_has_stack = default_child_has_stack;
-  monitor_ops.to_has_registers = default_child_has_registers;
-  monitor_ops.to_has_execution = default_child_has_execution;
-  monitor_ops.to_magic = OPS_MAGIC;
-}				/* init_base_monitor_ops */
-
-/* Init the target_ops structure pointed at by OPS.  */
-
-void
-init_monitor_ops (struct target_ops *ops)
-{
-  if (monitor_ops.to_magic != OPS_MAGIC)
-    init_base_monitor_ops ();
-
-  memcpy (ops, &monitor_ops, sizeof monitor_ops);
-}
-
-/* Define additional commands that are usually only used by monitors.  */
-
-/* -Wmissing-prototypes */
-extern initialize_file_ftype _initialize_remote_monitors;
-
-void
-_initialize_remote_monitors (void)
-{
-  init_base_monitor_ops ();
-  add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
-Set display of activity while downloading a file."), _("\
-Show display of activity while downloading a file."), _("\
-When enabled, a hashmark \'#\' is displayed."),
-			   NULL,
-			   NULL, /* FIXME: i18n: */
-			   &setlist, &showlist);
-
-  add_setshow_zuinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
-Set debugging of remote monitor communication."), _("\
-Show debugging of remote monitor communication."), _("\
-When enabled, communication between GDB and the remote monitor\n\
-is displayed."),
-			     NULL,
-			     NULL, /* FIXME: i18n: */
-			     &setdebuglist, &showdebuglist);
-
-  /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
-     isn't 0.  */
-  monitor_ptid = ptid_build (42000, 0, 42000);
-}
diff --git a/gdb/monitor.h b/gdb/monitor.h
deleted file mode 100644
index cf72093..0000000
--- a/gdb/monitor.h
+++ /dev/null
@@ -1,261 +0,0 @@
-/* Definitions for remote debugging interface for ROM monitors.
-   Copyright (C) 1990-2015 Free Software Foundation, Inc.
-   Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#ifndef MONITOR_H
-#define MONITOR_H
-
-struct target_waitstatus;
-struct serial;
-
-/* This structure describes the strings necessary to give small command
-   sequences to the monitor, and parse the response.
-
-   CMD is the actual command typed at the monitor.  Usually this has
-   embedded sequences ala printf, which are substituted with the
-   arguments appropriate to that type of command.  Ie: to examine a
-   register, we substitute the register name for the first arg.  To
-   modify memory, we substitute the memory location and the new
-   contents for the first and second args, etc...
-
-   RESP_DELIM used to home in on the response string, and is used to
-   disambiguate the answer within the pile of text returned by the
-   monitor.  This should be a unique string that immediately precedes
-   the answer.  Ie: if your monitor prints out `PC: 00000001= ' in
-   response to asking for the PC, you should use `: ' as the
-   RESP_DELIM.  RESP_DELIM may be NULL if the res- ponse is going to
-   be ignored, or has no particular leading text.
-
-   TERM is the string that the monitor outputs to indicate that it is
-   idle, and waiting for input.  This is usually a prompt of some
-   sort.  In the previous example, it would be `= '.  It is important
-   that TERM really means that the monitor is idle, otherwise GDB may
-   try to type at it when it isn't ready for input.  This is a problem
-   because many monitors cannot deal with type-ahead.  TERM may be
-   NULL if the normal prompt is output.
-
-   TERM_CMD is used to quit out of the subcommand mode and get back to
-   the main prompt.  TERM_CMD may be NULL if it isn't necessary.  It
-   will also be ignored if TERM is NULL.  */
-
-struct memrw_cmd
-  {
-    char *cmdb;			/* Command to send for byte read/write */
-    char *cmdw;			/* Command for word (16 bit) read/write */
-    char *cmdl;			/* Command for long (32 bit) read/write */
-    char *cmdll;		/* Command for long long (64 bit) read/write */
-    char *resp_delim;		/* String just prior to the desired value */
-    char *term;			/* Terminating string to search for */
-    char *term_cmd;		/* String to get out of sub-mode (if
-				   necessary) */
-  };
-
-struct regrw_cmd
-  {
-    char *cmd;			/* Command to send for reg read/write */
-    char *resp_delim;		/* String (actually a regexp if getmem) just
-				   prior to the desired value */
-    char *term;			/* Terminating string to search for */
-    char *term_cmd;		/* String to get out of sub-mode (if
-				   necessary) */
-  };
-
-struct monitor_ops
-  {
-    int flags;			/* See below */
-    char **init;		/* List of init commands.  NULL terminated.  */
-    char *cont;			/* continue command */
-    char *step;			/* single step */
-    char *stop;			/* Interrupt program string */
-    char *set_break;		/* set a breakpoint.  If NULL, monitor
-				   implementation sets its own
-				   to_insert_breakpoint method.  */
-    char *clr_break;		/* clear a breakpoint */
-    char *clr_all_break;	/* Clear all breakpoints */
-    char *fill;			/* Memory fill cmd (addr len val) */
-    struct memrw_cmd setmem;	/* set memory to a value */
-    struct memrw_cmd getmem;	/* display memory */
-    struct regrw_cmd setreg;	/* set a register */
-    struct regrw_cmd getreg;	/* get a register */
-    /* Some commands can dump a bunch of registers
-       at once.  This comes as a set of REG=VAL
-       pairs.  This should be called for each pair
-       of registers that we can parse to supply
-       GDB with the value of a register.  */
-    char *dump_registers;	/* Command to dump all regs at once */
-    char *register_pattern;	/* Pattern that picks out register
-				   from reg dump */
-    void (*supply_register) (struct regcache *regcache, char *name,
-			     int namelen, char *val, int vallen);
-    int (*dumpregs) (struct regcache *);	/* Dump all registers */
-    int (*continue_hook) (void);	/* Emit the continue command */
-    int (*wait_filter) (char *buf,	/* Maybe contains registers */
-			int bufmax,
-			int *response_length,
-			struct target_waitstatus * status);
-    char *load;			/* load command */
-    char *loadresp;		/* Response to load command */
-    char *prompt;		/* monitor command prompt */
-    char *line_term;		/* end-of-command delimitor */
-    char *cmd_end;		/* optional command terminator */
-    struct target_ops *target;	/* target operations */
-    int stopbits;		/* number of stop bits */
-    char **regnames;		/* array of register names in ascii */
-                                /* deprecated: use regname instead */
-    const char *(*regname) (int index); 
-                                /* function for dynamic regname array */
-    int num_breakpoints;	/* If set_break != NULL, number of supported
-				   breakpoints */
-    int magic;			/* Check value */
-  };
-
-/* The monitor ops magic number, used to detect if an ops structure doesn't
-   have the right number of entries filled in.  */
-
-#define MONITOR_OPS_MAGIC 600925
-
-/* Flag definitions.  */
-
-/* If set, then clear breakpoint command uses address, otherwise it
-   uses an index returned by the monitor.  */
-
-#define MO_CLR_BREAK_USES_ADDR 0x1
-
-/* If set, then memory fill command uses STARTADDR, ENDADDR+1, VALUE
-   as args, else it uses STARTADDR, LENGTH, VALUE as args.  */
-
-#define MO_FILL_USES_ADDR 0x2
-
-/* If set, then monitor doesn't automatically supply register dump
-   when coming back after a continue.  */
-
-#define MO_NEED_REGDUMP_AFTER_CONT 0x4
-
-/* getmem needs start addr and end addr.  */
-
-#define MO_GETMEM_NEEDS_RANGE 0x8
-
-/* getmem can only read one loc at a time.  */
-
-#define MO_GETMEM_READ_SINGLE 0x10
-
-/* handle \r\n combinations.  */
-
-#define MO_HANDLE_NL 0x20
-
-/* don't expect echos in monitor_open.  */
-
-#define MO_NO_ECHO_ON_OPEN 0x40
-
-/* If set, send break to stop monitor.  */
-
-#define MO_SEND_BREAK_ON_STOP 0x80
-
-/* If set, target sends an ACK after each S-record.  */
-
-#define MO_SREC_ACK 0x100
-
-/* Allow 0x prefix on addresses retured from monitor.  */
-
-#define MO_HEX_PREFIX 0x200
-
-/* Some monitors require a different command when starting a program.  */
-
-#define MO_RUN_FIRST_TIME 0x400
-
-/* Don't expect echos when getting memory */
-
-#define MO_NO_ECHO_ON_SETMEM 0x800
-
-/* If set, then register store command expects value BEFORE regname.  */
-
-#define MO_REGISTER_VALUE_FIRST 0x1000
-
-/* If set, then the monitor displays registers as pairs.  */
-
-#define MO_32_REGS_PAIRED 0x2000
-
-/* If set, then register setting happens interactively.  */
-
-#define MO_SETREG_INTERACTIVE 0x4000
-
-/* If set, then memory setting happens interactively.  */
-
-#define MO_SETMEM_INTERACTIVE 0x8000
-
-/* If set, then memory dumps are always on 16-byte boundaries, even
-   when less is desired.  */
-
-#define MO_GETMEM_16_BOUNDARY 0x10000
-
-/* If set, then the monitor numbers its breakpoints starting from 1.  */
-
-#define MO_CLR_BREAK_1_BASED 0x20000
-
-/* If set, then the monitor acks srecords with a plus sign.  */
-
-#define MO_SREC_ACK_PLUS 0x40000
-
-/* If set, then the monitor "acks" srecords with rotating lines.  */
-
-#define MO_SREC_ACK_ROTATE 0x80000
-
-/* If set, then remove useless address bits from memory addresses.  */
-
-#define MO_ADDR_BITS_REMOVE 0x100000
-
-/* If set, then display target program output if prefixed by ^O.  */
-
-#define MO_PRINT_PROGRAM_OUTPUT 0x200000
-
-/* Some dump bytes commands align the first data with the preceding
-   16 byte boundary.  Some print blanks and start at the exactly the
-   requested boundary.  */
-
-#define MO_EXACT_DUMPADDR 0x400000
-
-/* Rather entering and exiting the write memory dialog for each word byte,
-   we can save time by transferring the whole block without exiting
-   the memory editing mode.  You only need to worry about this
-   if you are doing memory downloading.
-   This engages a new write function registered with dcache.  */
-
-#define MO_HAS_BLOCKWRITES 0x800000
-
-#define SREC_SIZE 160
-
-extern void monitor_open (const char *args, struct monitor_ops *ops,
-			  int from_tty);
-extern void monitor_close (struct target_ops *self);
-extern char *monitor_supply_register (struct regcache *regcache,
-				      int regno, char *valstr);
-extern int monitor_expect (char *prompt, char *buf, int buflen);
-extern int monitor_expect_prompt (char *buf, int buflen);
-/* Note: The variable argument functions monitor_printf and
-   monitor_printf_noecho vararg do not take take standard format style
-   arguments.  Instead they take custom formats interpretered directly
-   by monitor_vsprintf.  */
-extern void monitor_printf (char *, ...);
-extern void monitor_printf_noecho (char *, ...);
-extern void monitor_write (char *buf, int buflen);
-extern int monitor_readchar (void);
-extern char *monitor_get_dev_name (void);
-extern void init_monitor_ops (struct target_ops *);
-extern int monitor_dump_reg_block (struct regcache *regcache, char *dump_cmd);
-
-#endif
diff --git a/gdb/ppcbug-rom.c b/gdb/ppcbug-rom.c
deleted file mode 100644
index b1e22cc..0000000
--- a/gdb/ppcbug-rom.c
+++ /dev/null
@@ -1,224 +0,0 @@
-/* Remote debugging interface for PPCbug (PowerPC) Rom monitor
-   for GDB, the GNU debugger.
-   Copyright (C) 1995-2015 Free Software Foundation, Inc.
-
-   Written by Stu Grossman of Cygnus Support
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#include "defs.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "monitor.h"
-#include "serial.h"
-#include "regcache.h"
-
-static void
-ppcbug_supply_register (struct regcache *regcache, char *regname,
-			int regnamelen, char *val, int vallen)
-{
-  int regno = 0;
-
-  if (regnamelen < 2 || regnamelen > 4)
-    return;
-
-  switch (regname[0])
-    {
-    case 'R':
-      if (regname[1] < '0' || regname[1] > '9')
-	return;
-      if (regnamelen == 2)
-	regno = regname[1] - '0';
-      else if (regnamelen == 3 && regname[2] >= '0' && regname[2] <= '9')
-	regno = (regname[1] - '0') * 10 + (regname[2] - '0');
-      else
-	return;
-      break;
-    case 'F':
-      if (regname[1] != 'R' || regname[2] < '0' || regname[2] > '9')
-	return;
-      if (regnamelen == 3)
-	regno = 32 + regname[2] - '0';
-      else if (regnamelen == 4 && regname[3] >= '0' && regname[3] <= '9')
-	regno = 32 + (regname[2] - '0') * 10 + (regname[3] - '0');
-      else
-	return;
-      break;
-    case 'I':
-      if (regnamelen != 2 || regname[1] != 'P')
-	return;
-      regno = 64;
-      break;
-    case 'M':
-      if (regnamelen != 3 || regname[1] != 'S' || regname[2] != 'R')
-	return;
-      regno = 65;
-      break;
-    case 'C':
-      if (regnamelen != 2 || regname[1] != 'R')
-	return;
-      regno = 66;
-      break;
-    case 'S':
-      if (regnamelen != 4 || regname[1] != 'P' || regname[2] != 'R')
-	return;
-      else if (regname[3] == '8')
-	regno = 67;
-      else if (regname[3] == '9')
-	regno = 68;
-      else if (regname[3] == '1')
-	regno = 69;
-      else if (regname[3] == '0')
-	regno = 70;
-      else
-	return;
-      break;
-    default:
-      return;
-    }
-
-  monitor_supply_register (regcache, regno, val);
-}
-
-/*
- * This array of registers needs to match the indexes used by GDB.  The
- * whole reason this exists is because the various ROM monitors use
- * different names than GDB does, and don't support all the
- * registers either.  So, typing "info reg sp" becomes an "A7".
- */
-
-static char *ppcbug_regnames[] =
-{
-  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
-  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
-  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
-  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
-
-  "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
-  "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
-  "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
-  "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",
-
-/* pc      ps      cnd     lr      cnt     xer     mq */
-  "ip", "msr", "cr", "spr8", "spr9", "spr1", "spr0"
-};
-
-/*
- * Define the monitor command strings.  Since these are passed directly
- * through to a printf style function, we need can include formatting
- * strings.  We also need a CR or LF on the end.
- */
-
-static struct target_ops ppcbug_ops0;
-static struct target_ops ppcbug_ops1;
-
-static char *ppcbug_inits[] =
-{"\r", NULL};
-
-static void
-init_ppc_cmds (char *LOAD_CMD,
-	       struct monitor_ops *OPS,
-	       struct target_ops *targops)
-{
-  OPS->flags = MO_CLR_BREAK_USES_ADDR | MO_HANDLE_NL;
-  OPS->init = ppcbug_inits;	/* Init strings */
-  OPS->cont = "g\r";		/* continue command */
-  OPS->step = "t\r";		/* single step */
-  OPS->stop = NULL;		/* interrupt command */
-  OPS->set_break = "br %x\r";	/* set a breakpoint */
-  OPS->clr_break = "nobr %x\r";	/* clear a breakpoint */
-  OPS->clr_all_break = "nobr\r";	/* clear all breakpoints */
-  OPS->fill = "bf %x:%x %x;b\r";	/* fill (start count val) */
-  OPS->setmem.cmdb = "ms %x %02x\r";	/* setmem.cmdb (addr, value) */
-  OPS->setmem.cmdw = "ms %x %04x\r";	/* setmem.cmdw (addr, value) */
-  OPS->setmem.cmdl = "ms %x %08x\r";	/* setmem.cmdl (addr, value) */
-  OPS->setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
-  OPS->setmem.resp_delim = NULL;	/* setreg.resp_delim */
-  OPS->setmem.term = NULL;	/* setreg.term */
-  OPS->setmem.term_cmd = NULL;	/* setreg.term_cmd */
-  OPS->getmem.cmdb = "md %x:%x;b\r";	/* getmem.cmdb (addr, len) */
-  OPS->getmem.cmdw = "md %x:%x;b\r";	/* getmem.cmdw (addr, len) */
-  OPS->getmem.cmdl = "md %x:%x;b\r";	/* getmem.cmdl (addr, len) */
-  OPS->getmem.cmdll = NULL;	/* getmem.cmdll (addr, len) */
-  OPS->getmem.resp_delim = " ";	/* getmem.resp_delim */
-  OPS->getmem.term = NULL;	/* getmem.term */
-  OPS->getmem.term_cmd = NULL;	/* getmem.term_cmd */
-  OPS->setreg.cmd = "rs %s %x\r";	/* setreg.cmd (name, value) */
-  OPS->setreg.resp_delim = NULL;	/* setreg.resp_delim */
-  OPS->setreg.term = NULL;	/* setreg.term */
-  OPS->setreg.term_cmd = NULL;	/* setreg.term_cmd */
-  OPS->getreg.cmd = "rs %s\r";	/* getreg.cmd (name) */
-  OPS->getreg.resp_delim = "=";	/* getreg.resp_delim */
-  OPS->getreg.term = NULL;	/* getreg.term */
-  OPS->getreg.term_cmd = NULL;	/* getreg.term_cmd */
-				/* register_pattern */
-  OPS->register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)";
-  OPS->supply_register = ppcbug_supply_register;
-  OPS->dump_registers = "rd\r";	/* dump all registers */
-  OPS->load = LOAD_CMD;		/* download command */
-  OPS->loadresp = NULL;		/* load response */
-  OPS->prompt = "PPC1-Bug>";	/* monitor command prompt */
-  OPS->line_term = "\r";	/* end-of-line terminator */
-  OPS->cmd_end = NULL;		/* optional command terminator */
-  OPS->target = targops;	/* target operations */
-  OPS->stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
-  OPS->regnames = ppcbug_regnames;	/* registers names */
-  OPS->magic = MONITOR_OPS_MAGIC;	/* magic */
-}
-
-
-static struct monitor_ops ppcbug_cmds0;
-static struct monitor_ops ppcbug_cmds1;
-
-static void
-ppcbug_open0 (const char *args, int from_tty)
-{
-  monitor_open (args, &ppcbug_cmds0, from_tty);
-}
-
-static void
-ppcbug_open1 (const char *args, int from_tty)
-{
-  monitor_open (args, &ppcbug_cmds1, from_tty);
-}
-
-extern initialize_file_ftype _initialize_ppcbug_rom; /* -Wmissing-prototypes */
-
-void
-_initialize_ppcbug_rom (void)
-{
-  init_ppc_cmds ("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0);
-  init_ppc_cmds ("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
-  init_monitor_ops (&ppcbug_ops0);
-
-  ppcbug_ops0.to_shortname = "ppcbug";
-  ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
-  ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  ppcbug_ops0.to_open = ppcbug_open0;
-
-  add_target (&ppcbug_ops0);
-
-  init_monitor_ops (&ppcbug_ops1);
-
-  ppcbug_ops1.to_shortname = "ppcbug1";
-  ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
-  ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
-Specify the serial device it is connected to (e.g. /dev/ttya).";
-  ppcbug_ops1.to_open = ppcbug_open1;
-
-  add_target (&ppcbug_ops1);
-}
diff --git a/gdb/srec.h b/gdb/srec.h
deleted file mode 100644
index bef607f..0000000
--- a/gdb/srec.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/* S-record download support for GDB, the GNU debugger.
-   Copyright (C) 1995-2015 Free Software Foundation, Inc.
-
-   This file is part of GDB.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-struct serial;
-
-void load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
-		int maxrecsize, int flags, int hashmark,
-		int (*waitack) (void));
-
-/* S-record capability flags */
-
-/* Which record types are supported */
-#define SREC_2_BYTE_ADDR 0x00000001
-#define SREC_3_BYTE_ADDR 0x00000002
-#define SREC_4_BYTE_ADDR 0x00000004
-#define SREC_TERM_SHIFT 3
-
-#define SREC_ALL (SREC_2_BYTE_ADDR | SREC_3_BYTE_ADDR | SREC_4_BYTE_ADDR \
-		  | ((SREC_2_BYTE_ADDR | SREC_3_BYTE_ADDR | SREC_4_BYTE_ADDR) \
-		     << SREC_TERM_SHIFT))