+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.
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 \
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 \
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*
;;
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
;;
;;
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
;;
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
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
;;
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
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
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
;;
+++ /dev/null
-/* 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);
-}
+++ /dev/null
-/* 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);
-}
+++ /dev/null
-/* 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;
-}
+++ /dev/null
-/* 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."));
-}
+++ /dev/null
-/* 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);
-}
+++ /dev/null
-/* 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, ®ister_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 (®ister_strings, 0, sizeof (struct re_registers));
-
- if (re_search (®ister_pattern, buf, len, 0, len,
- ®ister_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);
-}
+++ /dev/null
-/* 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
+++ /dev/null
-/* 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);
-}
+++ /dev/null
-/* 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))
projects / binutils-gdb.git / commitdiff