X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmonitor.c;h=4f9ff55dbcd1cbca78d50f44699e599a0e73f00b;hb=dbd492a37708515131c212c6ed88c13cc3a3d3b0;hp=15b11d56e4b2ed6cdacc1e3f93b85fb7c677ac78;hpb=46c6cdcf5ed83c113db573e6dcea6e9efcd9b7e6;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/monitor.c b/gdb/monitor.c
index 15b11d56e4..4f9ff55dbc 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -1,6 +1,9 @@
/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001 Free Software Foundation, Inc.
+
+ Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001, 2002, 2006, 2007, 2008, 2009, 2010
+ Free Software Foundation, Inc.
+
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
Resurrected from the ashes by Stu Grossman.
@@ -8,7 +11,7 @@
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -17,9 +20,7 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
/* This file was derived from various remote-* modules. It is a collection
of generic support functions so GDB can talk directly to a ROM based
@@ -41,6 +42,7 @@
#include "defs.h"
#include "gdbcore.h"
#include "target.h"
+#include "exceptions.h"
#include
#include
#include "gdb_string.h"
@@ -53,55 +55,19 @@
#include "gdb_regex.h"
#include "srec.h"
#include "regcache.h"
+#include "gdbthread.h"
static char *dev_name;
static struct target_ops *targ_ops;
-static void monitor_vsprintf (char *sndbuf, char *pattern, va_list args);
-
-static int readchar (int timeout);
-
-static void monitor_fetch_register (int regno);
-static void monitor_store_register (int regno);
-
-static void monitor_printable_string (char *newstr, char *oldstr, int len);
-static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
-static void monitor_detach (char *args, int from_tty);
-static void monitor_resume (int pid, int step, enum target_signal sig);
-static void monitor_interrupt (int signo);
-static void monitor_interrupt_twice (int signo);
static void monitor_interrupt_query (void);
-static void monitor_wait_cleanup (void *old_timeout);
-
-static int monitor_wait (int pid, struct target_waitstatus *status);
-static void monitor_fetch_registers (int regno);
-static void monitor_store_registers (int regno);
-static void monitor_prepare_to_store (void);
-static int monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
- int write,
- struct mem_attrib *attrib,
- struct target_ops *target);
-static void monitor_files_info (struct target_ops *ops);
-static int monitor_insert_breakpoint (CORE_ADDR addr, char *shadow);
-static int monitor_remove_breakpoint (CORE_ADDR addr, char *shadow);
-static void monitor_kill (void);
-static void monitor_load (char *file, int from_tty);
-static void monitor_mourn_inferior (void);
-static void monitor_stop (void);
-
-static int monitor_read_memory (CORE_ADDR addr, char *myaddr, int len);
-static int monitor_write_memory (CORE_ADDR addr, char *myaddr, int len);
-static int monitor_write_memory_bytes (CORE_ADDR addr, char *myaddr, int len);
-static int monitor_write_memory_block (CORE_ADDR memaddr,
- char *myaddr, int len);
-static int monitor_expect_regexp (struct re_pattern_buffer *pat,
- char *buf, int buflen);
-static void monitor_dump_regs (void);
+static void monitor_interrupt_twice (int);
+static void monitor_stop (ptid_t);
+static void monitor_dump_regs (struct regcache *regcache);
+
#if 0
static int from_hex (int a);
-static unsigned long get_hex_word (void);
#endif
-static void parse_register_dump (char *, int);
static struct monitor_ops *current_monitor;
@@ -119,7 +85,7 @@ static CORE_ADDR *breakaddr;
that monitor_open knows that we don't have a file open when the
program starts. */
-static serial_t monitor_desc = NULL;
+static struct serial *monitor_desc = NULL;
/* Pointer to regexp pattern matching data */
@@ -129,23 +95,36 @@ 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, ...) ATTR_FORMAT(printf, 1, 2);
+static void monitor_debug (const char *fmt, ...) ATTRIBUTE_PRINTF (1, 2);
static int monitor_debug_p = 0;
/* NOTE: This file alternates between monitor_debug_p and remote_debug
- when determining if debug information is printed. Perhaphs this
+ when determining if debug information is printed. Perhaps this
could be simplified. */
static void
@@ -154,6 +133,7 @@ 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);
@@ -233,12 +213,17 @@ monitor_error (char *function, char *message,
{
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 (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
+ error (_("%s (%s): %s: %s%c"),
+ function, paddress (target_gdbarch, memaddr),
+ message, safe_string, final_char);
else
- error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
+ error (_("%s (%s): %s: %s"),
+ function, paddress (target_gdbarch, memaddr),
+ message, safe_string);
}
/* Convert hex digit A to a number. */
@@ -253,7 +238,7 @@ fromhex (int a)
else if (a >= 'A' && a <= 'F')
return a - 'A' + 10;
else
- error ("Invalid hex digit %d", a);
+ error (_("Invalid hex digit %d"), a);
}
/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
@@ -273,6 +258,7 @@ fromhex (int a)
static void
monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
{
+ int addr_bit = gdbarch_addr_bit (target_gdbarch);
char format[10];
char fmt;
char *p;
@@ -301,7 +287,7 @@ monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
break;
case 'A':
arg_addr = va_arg (args, CORE_ADDR);
- strcpy (sndbuf, paddr_nz (arg_addr));
+ strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
break;
case 's':
arg_string = va_arg (args, char *);
@@ -337,11 +323,12 @@ monitor_printf_noecho (char *pattern,...)
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (monitor_debug_p)
{
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);
}
@@ -365,11 +352,12 @@ monitor_printf (char *pattern,...)
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
if (monitor_debug_p)
{
char *safe_string = (char *) alloca ((len * 4) + 1);
+
monitor_printable_string (safe_string, sndbuf, 0);
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
}
@@ -390,8 +378,8 @@ monitor_printf (char *pattern,...)
void
monitor_write (char *buf, int buflen)
{
- if (SERIAL_WRITE (monitor_desc, buf, buflen))
- fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
+ if (serial_write (monitor_desc, buf, buflen))
+ fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
safe_strerror (errno));
}
@@ -409,7 +397,7 @@ monitor_readchar (void)
do
{
looping = 0;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (c >= 0)
c &= 0xff; /* don't lose bit 7 */
@@ -420,9 +408,9 @@ monitor_readchar (void)
return c;
if (c == SERIAL_TIMEOUT)
- error ("Timeout reading from remote system.");
+ error (_("Timeout reading from remote system."));
- perror_with_name ("remote-monitor");
+ perror_with_name (_("remote-monitor"));
}
@@ -443,7 +431,7 @@ readchar (int timeout)
do
{
looping = 0;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (c >= 0)
{
@@ -453,6 +441,7 @@ readchar (int timeout)
if (monitor_debug_p || remote_debug)
{
char buf[2];
+
buf[0] = c;
buf[1] = '\0';
puts_debug ("read -->", buf, "<--");
@@ -491,13 +480,13 @@ readchar (int timeout)
if (in_monitor_wait) /* Watchdog went off */
{
target_mourn_inferior ();
- error ("GDB serial timeout has expired. Target detached.\n");
+ error (_("GDB serial timeout has expired. Target detached."));
}
else
#endif
- error ("Timeout reading from remote system.");
+ error (_("Timeout reading from remote system."));
- perror_with_name ("remote-monitor");
+ perror_with_name (_("remote-monitor"));
}
/* Scan input from the remote system, until STRING is found. If BUF is non-
@@ -513,7 +502,6 @@ monitor_expect (char *string, char *buf, int buflen)
char *p = string;
int obuflen = buflen;
int c;
- extern struct target_ops *targ_ops;
if (monitor_debug_p)
{
@@ -561,12 +549,6 @@ monitor_expect (char *string, char *buf, int buflen)
return 0;
}
}
- else if ((c == '\021' || c == '\023') &&
- (STREQ (targ_ops->to_shortname, "m32r")
- || STREQ (targ_ops->to_shortname, "mon2000")))
- { /* m32r monitor emits random DC1/DC3 chars */
- continue;
- }
else
{
/* We got a character that doesn't match the string. We need to
@@ -617,6 +599,7 @@ 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;
@@ -715,7 +698,7 @@ compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
re_set_syntax (tmp);
if (val)
- error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
+ error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern, val);
if (fastmap)
re_compile_fastmap (compiled_pattern);
@@ -729,16 +712,17 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
{
char *name;
char **p;
+ struct inferior *inf;
if (mon_ops->magic != MONITOR_OPS_MAGIC)
- error ("Magic number of monitor_ops struct wrong.");
+ error (_("Magic number of monitor_ops struct wrong."));
targ_ops = mon_ops->target;
name = targ_ops->to_shortname;
if (!args)
- error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
-`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
+ error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
+`target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
target_preopen (from_tty);
@@ -752,33 +736,41 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
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);
+ 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))
+ if (serial_setbaudrate (monitor_desc, baud_rate))
{
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
perror_with_name (dev_name);
}
}
- SERIAL_RAW (monitor_desc);
+ serial_raw (monitor_desc);
- SERIAL_FLUSH_INPUT (monitor_desc);
+ serial_flush_input (monitor_desc);
/* some systems only work with 2 stop bits */
- SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
+ serial_setstopbits (monitor_desc, mon_ops->stopbits);
current_monitor = mon_ops;
@@ -787,7 +779,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
if (current_monitor->stop)
{
- monitor_stop ();
+ monitor_stop (inferior_ptid);
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
{
monitor_debug ("EXP Open echo\n");
@@ -808,7 +800,7 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
monitor_expect_prompt (NULL, 0);
}
- SERIAL_FLUSH_INPUT (monitor_desc);
+ serial_flush_input (monitor_desc);
/* Alloc breakpoints */
if (mon_ops->set_break != NULL)
@@ -829,17 +821,24 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
}
if (from_tty)
- printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
+ printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name);
push_target (targ_ops);
- inferior_pid = 42000; /* Make run command think we are busy... */
+ /* Start afresh. */
+ init_thread_list ();
+
+ /* Make run command think we are busy... */
+ inferior_ptid = monitor_ptid;
+ inf = current_inferior ();
+ inferior_appeared (inf, ptid_get_pid (inferior_ptid));
+ add_thread_silent (inferior_ptid);
/* Give monitor_wait something to read */
monitor_printf (current_monitor->line_term);
- start_remote ();
+ start_remote (from_tty);
}
/* Close out all files and local state before this target loses
@@ -849,7 +848,7 @@ void
monitor_close (int quitting)
{
if (monitor_desc)
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
/* Free breakpoint memory */
if (breakaddr != NULL)
@@ -859,26 +858,31 @@ monitor_close (int quitting)
}
monitor_desc = NULL;
+
+ delete_thread_silent (monitor_ptid);
+ delete_inferior_silent (ptid_get_pid (monitor_ptid));
}
/* Terminate the open connection to the remote debugger. Use this
when you want to detach and do something else with your gdb. */
static void
-monitor_detach (char *args, int from_tty)
+monitor_detach (struct target_ops *ops, char *args, int from_tty)
{
pop_target (); /* calls monitor_close to do the real work */
if (from_tty)
- printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
+ printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
}
/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
char *
-monitor_supply_register (int regno, char *valstr)
+monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
{
+ struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST val;
- unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+ unsigned char regbuf[MAX_REGISTER_SIZE];
char *p;
val = 0;
@@ -907,14 +911,15 @@ monitor_supply_register (int regno, char *valstr)
monitor_debug ("Supplying Register %d %s\n", regno, valstr);
if (val == 0 && valstr == p)
- error ("monitor_supply_register (%d): bad value from monitor: %s.",
+ error (_("monitor_supply_register (%d): bad value from monitor: %s."),
regno, valstr);
/* supply register stores in target byte order, so swap here */
- store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
+ store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
+ val);
- supply_register (regno, regbuf);
+ regcache_raw_supply (regcache, regno, regbuf);
return p;
}
@@ -922,7 +927,8 @@ monitor_supply_register (int regno, char *valstr)
/* Tell the remote machine to resume. */
static void
-monitor_resume (int pid, int step, enum target_signal sig)
+monitor_resume (struct target_ops *ops,
+ ptid_t ptid, int step, enum target_signal sig)
{
/* Some monitors require a different command when starting a program */
monitor_debug ("MON resume\n");
@@ -953,13 +959,14 @@ monitor_resume (int pid, int step, enum target_signal sig)
string which are passed down to monitor specific code. */
static void
-parse_register_dump (char *buf, int len)
+parse_register_dump (struct regcache *regcache, char *buf, int len)
{
monitor_debug ("MON Parsing register dump\n");
while (1)
{
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;
@@ -975,7 +982,8 @@ parse_register_dump (char *buf, int len)
vallen = register_strings.end[2] - register_strings.start[2];
val = buf + register_strings.start[2];
- current_monitor->supply_register (regname, regnamelen, val, vallen);
+ current_monitor->supply_register (regcache, regname, regnamelen,
+ val, vallen);
buf += register_strings.end[0];
len -= register_strings.end[0];
@@ -994,7 +1002,7 @@ monitor_interrupt (int signo)
if (monitor_debug_p || remote_debug)
fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
- target_stop ();
+ target_stop (inferior_ptid);
}
/* The user typed ^C twice. */
@@ -1016,11 +1024,11 @@ monitor_interrupt_query (void)
{
target_terminal_ours ();
- if (query ("Interrupted while waiting for the program.\n\
-Give up (and stop debugging it)? "))
+ if (query (_("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? ")))
{
target_mourn_inferior ();
- return_to_top_level (RETURN_QUIT);
+ deprecated_throw_reason (RETURN_QUIT);
}
target_terminal_inferior ();
@@ -1036,14 +1044,14 @@ monitor_wait_cleanup (void *old_timeout)
-void
+static void
monitor_wait_filter (char *buf,
int bufmax,
int *ext_resp_len,
- struct target_waitstatus *status
-)
+ struct target_waitstatus *status)
{
int resp_len;
+
do
{
resp_len = monitor_expect_prompt (buf, bufmax);
@@ -1072,8 +1080,9 @@ monitor_wait_filter (char *buf,
/* Wait until the remote machine stops, then return, storing status in
status just as `wait' would. */
-static int
-monitor_wait (int pid, struct target_waitstatus *status)
+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];
@@ -1136,10 +1145,10 @@ monitor_wait (int pid, struct target_waitstatus *status)
}
if (current_monitor->register_pattern)
- parse_register_dump (buf, resp_len);
+ parse_register_dump (get_current_regcache (), buf, resp_len);
#else
monitor_debug ("Wait fetching registers after stop\n");
- monitor_dump_regs ();
+ monitor_dump_regs (get_current_regcache ());
#endif
status->kind = TARGET_WAITKIND_STOPPED;
@@ -1149,31 +1158,34 @@ monitor_wait (int pid, struct target_waitstatus *status)
in_monitor_wait = 0;
- return inferior_pid;
+ return inferior_ptid;
}
/* Fetch register REGNO, or all registers if REGNO is -1. Returns
errno value. */
static void
-monitor_fetch_register (int regno)
+monitor_fetch_register (struct regcache *regcache, int regno)
{
- char *name;
+ const char *name;
char *zerobuf;
char *regbuf;
int i;
- regbuf = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
- zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
- memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
+ regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
+ zerobuf = alloca (MAX_REGISTER_SIZE);
+ memset (zerobuf, 0, MAX_REGISTER_SIZE);
- name = current_monitor->regnames[regno];
+ if (current_monitor->regname != NULL)
+ name = current_monitor->regname (regno);
+ else
+ name = current_monitor->regnames[regno];
monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
if (!name || (*name == '\0'))
{
monitor_debug ("No register known for %d\n", regno);
- supply_register (regno, zerobuf);
+ regcache_raw_supply (regcache, regno, zerobuf);
return;
}
@@ -1202,13 +1214,14 @@ monitor_fetch_register (int regno)
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.",
+ error (_("Bad value returned from monitor while fetching register %x."),
regno);
}
@@ -1216,9 +1229,10 @@ monitor_fetch_register (int regno)
spaces, but stop reading if something else is seen. Some monitors
like to drop leading zeros. */
- for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
+ for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
{
int c;
+
c = readchar (timeout);
while (c == ' ')
c = readchar (timeout);
@@ -1252,7 +1266,7 @@ monitor_fetch_register (int regno)
current_monitor->getreg.term_cmd) /* ack expected */
monitor_expect_prompt (NULL, 0); /* get response */
- monitor_supply_register (regno, regbuf);
+ monitor_supply_register (regcache, regno, regbuf);
}
/* Sometimes, it takes several commands to dump the registers */
@@ -1260,13 +1274,14 @@ monitor_fetch_register (int regno)
case they need to compose the operation.
*/
int
-monitor_dump_reg_block (char *block_cmd)
+monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
{
char buf[TARGET_BUF_SIZE];
int resp_len;
+
monitor_printf (block_cmd);
resp_len = monitor_expect_prompt (buf, sizeof (buf));
- parse_register_dump (buf, resp_len);
+ parse_register_dump (regcache, buf, resp_len);
return 1;
}
@@ -1275,61 +1290,68 @@ monitor_dump_reg_block (char *block_cmd)
/* Call the specific function if it has been provided */
static void
-monitor_dump_regs (void)
+monitor_dump_regs (struct regcache *regcache)
{
char buf[TARGET_BUF_SIZE];
int resp_len;
+
if (current_monitor->dumpregs)
- (*(current_monitor->dumpregs)) (); /* call supplied function */
+ (*(current_monitor->dumpregs)) (regcache); /* call supplied function */
else if (current_monitor->dump_registers) /* default version */
{
monitor_printf (current_monitor->dump_registers);
resp_len = monitor_expect_prompt (buf, sizeof (buf));
- parse_register_dump (buf, resp_len);
+ parse_register_dump (regcache, buf, resp_len);
}
else
- internal_error (__FILE__, __LINE__, "failed internal consistency check"); /* Need some way to read registers */
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check")); /* Need some way to read registers */
}
static void
-monitor_fetch_registers (int regno)
+monitor_fetch_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
monitor_debug ("MON fetchregs\n");
if (current_monitor->getreg.cmd)
{
if (regno >= 0)
{
- monitor_fetch_register (regno);
+ monitor_fetch_register (regcache, regno);
return;
}
- for (regno = 0; regno < NUM_REGS; regno++)
- monitor_fetch_register (regno);
+ for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ monitor_fetch_register (regcache, regno);
}
else
{
- monitor_dump_regs ();
+ monitor_dump_regs (regcache);
}
}
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
static void
-monitor_store_register (int regno)
+monitor_store_register (struct regcache *regcache, int regno)
{
- char *name;
+ int reg_size = register_size (get_regcache_arch (regcache), regno);
+ const char *name;
ULONGEST val;
-
- name = current_monitor->regnames[regno];
+
+ if (current_monitor->regname != NULL)
+ name = current_monitor->regname (regno);
+ else
+ name = current_monitor->regnames[regno];
+
if (!name || (*name == '\0'))
{
monitor_debug ("MON Cannot store unknown register\n");
return;
}
- val = read_register (regno);
- monitor_debug ("MON storeg %d %s\n", regno,
- phex (val, REGISTER_RAW_SIZE (regno)));
+ regcache_cooked_read_unsigned (regcache, regno, &val);
+ monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
/* send the register deposit command */
@@ -1340,12 +1362,19 @@ monitor_store_register (int regno)
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", paddr_nz (val));
+ monitor_printf ("%s\r", phex_nz (val, reg_size));
monitor_expect_prompt (NULL, 0);
}
else
@@ -1361,16 +1390,18 @@ monitor_store_register (int regno)
/* Store the remote registers. */
static void
-monitor_store_registers (int regno)
+monitor_store_registers (struct target_ops *ops,
+ struct regcache *regcache, int regno)
{
if (regno >= 0)
{
- monitor_store_register (regno);
+ monitor_store_register (regcache, regno);
return;
}
- for (regno = 0; regno < NUM_REGS; regno++)
- monitor_store_register (regno);
+ for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
+ regno++)
+ monitor_store_register (regcache, regno);
}
/* Get ready to modify the registers array. On machines which store
@@ -1380,7 +1411,7 @@ monitor_store_registers (int regno)
debugged. */
static void
-monitor_prepare_to_store (void)
+monitor_prepare_to_store (struct regcache *regcache)
{
/* Do nothing, since we can store individual regs */
}
@@ -1388,20 +1419,21 @@ monitor_prepare_to_store (void)
static void
monitor_files_info (struct target_ops *ops)
{
- printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
+ printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
}
static int
monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
unsigned int val, hostval;
char *cmd;
int i;
- monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
+ monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch, memaddr));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- memaddr = ADDR_BITS_REMOVE (memaddr);
+ memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
/* Use memory fill command for leading 0 bytes. */
@@ -1450,7 +1482,7 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
cmd = current_monitor->setmem.cmdb;
}
- val = extract_unsigned_integer (myaddr, len);
+ val = extract_unsigned_integer (myaddr, len, byte_order);
if (len == 4)
{
@@ -1463,9 +1495,14 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
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");
@@ -1473,7 +1510,7 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
monitor_printf ("%x\r", val);
}
if (current_monitor->setmem.term_cmd)
- { /* Emit this to get out of the memory editing state */
+ { /* Emit this to get out of the memory editing state */
monitor_printf ("%s", current_monitor->setmem.term_cmd);
/* Drop through to expecting a prompt */
}
@@ -1487,38 +1524,12 @@ monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
}
-static int
-monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len)
-{
- unsigned int val;
- int written = 0;;
- /* Enter the sub mode */
- monitor_printf (current_monitor->setmem.cmdl, memaddr);
- monitor_expect_prompt (NULL, 0);
-
- while (len)
- {
- val = extract_unsigned_integer (myaddr, 4); /* REALLY */
- monitor_printf ("%x\r", val);
- myaddr += 4;
- memaddr += 4;
- written += 4;
- monitor_debug (" @ %s\n", paddr (memaddr));
- /* If we wanted to, here we could validate the address */
- monitor_expect_prompt (NULL, 0);
- }
- /* Now exit the sub mode */
- monitor_printf (current_monitor->getreg.term_cmd);
- monitor_expect_prompt (NULL, 0);
- return written;
-}
-
-
static int
monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
{
unsigned char val;
int written = 0;
+
if (len == 0)
return 0;
/* Enter the sub mode */
@@ -1547,6 +1558,7 @@ longlongendswap (unsigned char *a)
{
int i, j;
unsigned char x;
+
i = 0;
j = 7;
while (i < 4)
@@ -1574,10 +1586,12 @@ longlong_hexchars (unsigned long long value,
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;
}
@@ -1614,6 +1628,7 @@ monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
long long *llptr;
long long value;
int written = 0;
+
llptr = (unsigned long long *) myaddr;
if (len == 0)
return 0;
@@ -1658,6 +1673,7 @@ static int
monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
{
int written;
+
written = 0;
/* FIXME: This would be a good place to put the zero test */
#if 1
@@ -1665,17 +1681,6 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
{
return monitor_write_memory_longlongs (memaddr, myaddr, len);
}
-#endif
-#if 0
- if (len > 4)
- {
- int sublen;
- written = monitor_write_even_block (memaddr, myaddr, len);
- /* Adjust calling parameters by written amount */
- memaddr += written;
- myaddr += written;
- len -= written;
- }
#endif
written = monitor_write_memory_bytes (memaddr, myaddr, len);
return written;
@@ -1687,6 +1692,7 @@ monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
static int
monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
unsigned int val;
char membuf[sizeof (int) * 2 + 1];
char *p;
@@ -1755,6 +1761,7 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
int i;
+
for (i = 0; i < len * 2; i++)
{
int c;
@@ -1803,7 +1810,7 @@ monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
/* supply register stores in target byte order, so swap here */
- store_unsigned_integer (myaddr, len, val);
+ store_unsigned_integer (myaddr, len, byte_order, val);
return len;
}
@@ -1828,11 +1835,12 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
return 0;
}
- monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
- paddr_nz (memaddr), (long) myaddr, len);
+ 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 = ADDR_BITS_REMOVE (memaddr);
+ memaddr = gdbarch_addr_bits_remove (target_gdbarch, memaddr);
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
return monitor_read_memory_single (memaddr, myaddr, len);
@@ -1876,7 +1884,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
if (current_monitor->getmem.term_cmd)
{
- SERIAL_WRITE (monitor_desc, 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);
}
@@ -1894,6 +1902,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
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));
@@ -1916,7 +1925,8 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
p += strlen (current_monitor->getmem.resp_delim);
#endif
}
- monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
+ 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;
@@ -1945,7 +1955,7 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
c = *p;
}
if (fetched == 0)
- error ("Failed to read via monitor");
+ error (_("Failed to read via monitor"));
if (monitor_debug_p || remote_debug)
fprintf_unfiltered (gdb_stdlog, "\n");
return fetched; /* Return the number of bytes actually read */
@@ -1991,9 +2001,8 @@ monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
unused. */
static int
-monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
- struct mem_attrib *attrib ATTRIBUTE_UNUSED,
- struct target_ops *target ATTRIBUTE_UNUSED)
+monitor_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+ struct mem_attrib *attrib, struct target_ops *target)
{
int res;
@@ -2013,23 +2022,24 @@ monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
}
static void
-monitor_kill (void)
+monitor_kill (struct target_ops *ops)
{
return; /* ignore attempts to kill target system */
}
-/* All we actually do is set the PC to the start address of exec_bfd, and start
- the program at that point. */
+/* All we actually do is set the PC to the start address of exec_bfd. */
static void
-monitor_create_inferior (char *exec_file, char *args, char **env)
+monitor_create_inferior (struct target_ops *ops, char *exec_file,
+ char *args, char **env, int from_tty)
{
if (args && (*args != '\000'))
- error ("Args are not supported by the monitor.");
+ error (_("Args are not supported by the monitor."));
first_time = 1;
clear_proceed_status ();
- proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
+ regcache_write_pc (get_current_regcache (),
+ bfd_get_start_address (exec_bfd));
}
/* Clean up when a program exits.
@@ -2038,59 +2048,61 @@ monitor_create_inferior (char *exec_file, char *args, char **env)
instructions. */
static void
-monitor_mourn_inferior (void)
+monitor_mourn_inferior (struct target_ops *ops)
{
unpush_target (targ_ops);
generic_mourn_inferior (); /* Do all the proper things now */
+ delete_thread_silent (monitor_ptid);
}
/* Tell the monitor to add a breakpoint. */
static int
-monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
+monitor_insert_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
+ CORE_ADDR addr = bp_tgt->placed_address;
int i;
- unsigned char *bp;
int bplen;
- monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+ monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
if (current_monitor->set_break == NULL)
- error ("No set_break defined for this monitor");
+ error (_("No set_break defined for this monitor"));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- addr = ADDR_BITS_REMOVE (addr);
+ addr = gdbarch_addr_bits_remove (gdbarch, addr);
/* Determine appropriate breakpoint size for this address. */
- bp = memory_breakpoint_from_pc (&addr, &bplen);
+ gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
+ bp_tgt->placed_address = addr;
+ bp_tgt->placed_size = bplen;
for (i = 0; i < current_monitor->num_breakpoints; i++)
{
if (breakaddr[i] == 0)
{
breakaddr[i] = addr;
- monitor_read_memory (addr, shadow, bplen);
monitor_printf (current_monitor->set_break, addr);
monitor_expect_prompt (NULL, 0);
return 0;
}
}
- error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
+ error (_("Too many breakpoints (> %d) for monitor."), current_monitor->num_breakpoints);
}
/* Tell the monitor to remove a breakpoint. */
static int
-monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
+monitor_remove_breakpoint (struct gdbarch *gdbarch,
+ struct bp_target_info *bp_tgt)
{
+ CORE_ADDR addr = bp_tgt->placed_address;
int i;
- monitor_debug ("MON rmbkpt %s\n", paddr (addr));
+ monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
if (current_monitor->clr_break == NULL)
- error ("No clr_break defined for this monitor");
-
- if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
- addr = ADDR_BITS_REMOVE (addr);
+ error (_("No clr_break defined for this monitor"));
for (i = 0; i < current_monitor->num_breakpoints; i++)
{
@@ -2109,8 +2121,8 @@ monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
}
}
fprintf_unfiltered (gdb_stderr,
- "Can't find breakpoint associated with 0x%s\n",
- paddr_nz (addr));
+ "Can't find breakpoint associated with %s\n",
+ paddress (gdbarch, addr));
return 1;
}
@@ -2175,28 +2187,32 @@ monitor_load (char *file, int from_tty)
monitor_expect_prompt (NULL, 0);
}
-/* Finally, make the PC point at the start address */
-
+ /* Finally, make the PC point at the start address */
if (exec_bfd)
- write_pc (bfd_get_start_address (exec_bfd));
-
- inferior_pid = 0; /* No process now */
-
-/* This is necessary because many things were based on the PC at the time that
- we attached to the monitor, which is no longer valid now that we have loaded
- new code (and just changed the PC). Another way to do this might be to call
- normal_stop, except that the stack may not be valid, and things would get
- horribly confused... */
-
- clear_symtab_users ();
+ regcache_write_pc (get_current_regcache (),
+ bfd_get_start_address (exec_bfd));
+
+ /* There used to be code here which would clear inferior_ptid and
+ call clear_symtab_users. None of that should be necessary:
+ monitor targets should behave like remote protocol targets, and
+ since generic_load does none of those things, this function
+ shouldn't either.
+
+ Furthermore, clearing inferior_ptid is *incorrect*. After doing
+ a load, we still have a valid connection to the monitor, with a
+ live processor state to fiddle with. The user can type
+ `continue' or `jump *start' and make the program run. If they do
+ these things, however, GDB will be talking to a running program
+ while inferior_ptid is null_ptid; this makes things like
+ reinit_frame_cache very confused. */
}
static void
-monitor_stop (void)
+monitor_stop (ptid_t ptid)
{
monitor_debug ("MON stop\n");
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
- SERIAL_SEND_BREAK (monitor_desc);
+ serial_send_break (monitor_desc);
if (current_monitor->stop)
monitor_printf_noecho (current_monitor->stop);
}
@@ -2214,7 +2230,7 @@ monitor_rcmd (char *command,
char buf[1000];
if (monitor_desc == NULL)
- error ("monitor target not open.");
+ error (_("monitor target not open."));
p = current_monitor->prompt;
@@ -2241,7 +2257,7 @@ from_hex (int a)
if (a >= 'A' && a <= 'F')
return a - 'A' + 10;
- error ("Reply contains invalid hex digit 0x%x", a);
+ error (_("Reply contains invalid hex digit 0x%x"), a);
}
#endif
@@ -2251,73 +2267,66 @@ monitor_get_dev_name (void)
return dev_name;
}
+/* Check to see if a thread is still alive. */
+
+static int
+monitor_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+ if (ptid_equal (ptid, monitor_ptid))
+ /* The monitor's task is always alive. */
+ return 1;
+
+ return 0;
+}
+
+/* Convert a thread ID to a string. Returns the string in a static
+ buffer. */
+
+static char *
+monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+ static char buf[64];
+
+ if (ptid_equal (monitor_ptid, ptid))
+ {
+ xsnprintf (buf, sizeof buf, "Thread ");
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
+}
+
static struct target_ops monitor_ops;
static void
init_base_monitor_ops (void)
{
- monitor_ops.to_shortname = NULL;
- monitor_ops.to_longname = NULL;
- monitor_ops.to_doc = NULL;
- monitor_ops.to_open = NULL;
monitor_ops.to_close = monitor_close;
- monitor_ops.to_attach = NULL;
- monitor_ops.to_post_attach = NULL;
- monitor_ops.to_require_attach = NULL;
monitor_ops.to_detach = monitor_detach;
- monitor_ops.to_require_detach = NULL;
monitor_ops.to_resume = monitor_resume;
monitor_ops.to_wait = monitor_wait;
- monitor_ops.to_post_wait = NULL;
monitor_ops.to_fetch_registers = monitor_fetch_registers;
monitor_ops.to_store_registers = monitor_store_registers;
monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
- monitor_ops.to_xfer_memory = monitor_xfer_memory;
+ monitor_ops.deprecated_xfer_memory = monitor_xfer_memory;
monitor_ops.to_files_info = monitor_files_info;
monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
- monitor_ops.to_terminal_init = 0;
- monitor_ops.to_terminal_inferior = 0;
- monitor_ops.to_terminal_ours_for_output = 0;
- monitor_ops.to_terminal_ours = 0;
- monitor_ops.to_terminal_info = 0;
monitor_ops.to_kill = monitor_kill;
monitor_ops.to_load = monitor_load;
- monitor_ops.to_lookup_symbol = 0;
monitor_ops.to_create_inferior = monitor_create_inferior;
- monitor_ops.to_post_startup_inferior = NULL;
- monitor_ops.to_acknowledge_created_inferior = NULL;
- monitor_ops.to_clone_and_follow_inferior = NULL;
- monitor_ops.to_post_follow_inferior_by_clone = NULL;
- monitor_ops.to_insert_fork_catchpoint = NULL;
- monitor_ops.to_remove_fork_catchpoint = NULL;
- monitor_ops.to_insert_vfork_catchpoint = NULL;
- monitor_ops.to_remove_vfork_catchpoint = NULL;
- monitor_ops.to_has_forked = NULL;
- monitor_ops.to_has_vforked = NULL;
- monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
- monitor_ops.to_post_follow_vfork = NULL;
- monitor_ops.to_insert_exec_catchpoint = NULL;
- monitor_ops.to_remove_exec_catchpoint = NULL;
- monitor_ops.to_has_execd = NULL;
- monitor_ops.to_reported_exec_events_per_exec_call = NULL;
- monitor_ops.to_has_exited = NULL;
monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
- monitor_ops.to_can_run = 0;
- monitor_ops.to_notice_signals = 0;
- monitor_ops.to_thread_alive = 0;
monitor_ops.to_stop = monitor_stop;
monitor_ops.to_rcmd = monitor_rcmd;
- monitor_ops.to_pid_to_exec_file = NULL;
+ monitor_ops.to_log_command = serial_log_command;
+ monitor_ops.to_thread_alive = monitor_thread_alive;
+ monitor_ops.to_pid_to_str = monitor_pid_to_str;
monitor_ops.to_stratum = process_stratum;
- monitor_ops.DONT_USE = 0;
- monitor_ops.to_has_all_memory = 1;
- monitor_ops.to_has_memory = 1;
- monitor_ops.to_has_stack = 1;
- monitor_ops.to_has_registers = 1;
- monitor_ops.to_has_execution = 1;
- monitor_ops.to_sections = 0;
- monitor_ops.to_sections_end = 0;
+ monitor_ops.to_has_all_memory = default_child_has_all_memory;
+ monitor_ops.to_has_memory = default_child_has_memory;
+ monitor_ops.to_has_stack = default_child_has_stack;
+ monitor_ops.to_has_registers = default_child_has_registers;
+ monitor_ops.to_has_execution = default_child_has_execution;
monitor_ops.to_magic = OPS_MAGIC;
} /* init_base_monitor_ops */
@@ -2334,22 +2343,30 @@ init_monitor_ops (struct target_ops *ops)
/* Define additional commands that are usually only used by monitors. */
+extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
+
void
_initialize_remote_monitors (void)
{
init_base_monitor_ops ();
- add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
- (char *) &hashmark,
- "Set display of activity while downloading a file.\n\
-When enabled, a hashmark \'#\' is displayed.",
- &setlist),
- &showlist);
-
- add_show_from_set
- (add_set_cmd ("monitor", no_class, var_zinteger,
- (char *) &monitor_debug_p,
- "Set debugging of remote monitor communication.\n\
+ add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
+Set display of activity while downloading a file."), _("\
+Show display of activity while downloading a file."), _("\
+When enabled, a hashmark \'#\' is displayed."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setlist, &showlist);
+
+ add_setshow_zinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
+Set debugging of remote monitor communication."), _("\
+Show debugging of remote monitor communication."), _("\
When enabled, communication between GDB and the remote monitor\n\
-is displayed.", &setdebuglist),
- &showdebuglist);
+is displayed."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setdebuglist, &showdebuglist);
+
+ /* Yes, 42000 is arbitrary. The only sense out of it, is that it
+ isn't 0. */
+ monitor_ptid = ptid_build (42000, 0, 42000);
}