/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
- Free Software Foundation, Inc.
+
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
+ 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
Resurrected from the ashes by Stu Grossman.
/* 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 existance, and makes for quick porting.
+ 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
#include "defs.h"
#include "gdbcore.h"
#include "target.h"
-#include "wait.h"
+#include "exceptions.h"
#include <signal.h>
#include <ctype.h>
#include "gdb_string.h"
#include "monitor.h"
#include "gdbcmd.h"
#include "inferior.h"
-#include "gnu-regex.h"
-#include "dcache.h"
+#include "gdb_regex.h"
#include "srec.h"
+#include "regcache.h"
static char *dev_name;
static struct target_ops *targ_ops;
-static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
-
-static int readchar PARAMS ((int timeout));
-
-static void monitor_fetch_register PARAMS ((int regno));
-static void monitor_store_register PARAMS ((int regno));
-
-static int monitor_printable_string PARAMS ((char *newstr, char *oldstr));
-static void monitor_error PARAMS ((char *format, CORE_ADDR memaddr, int len, char *string, int final_char));
-static void monitor_detach PARAMS ((char *args, int from_tty));
-static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
-static void monitor_interrupt PARAMS ((int signo));
-static void monitor_interrupt_twice PARAMS ((int signo));
-static void monitor_interrupt_query PARAMS ((void));
-static void monitor_wait_cleanup PARAMS ((void *old_timeout));
-
-static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
-static void monitor_fetch_registers PARAMS ((int regno));
-static void monitor_store_registers PARAMS ((int regno));
-static void monitor_prepare_to_store PARAMS ((void));
-static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
-static void monitor_files_info PARAMS ((struct target_ops * ops));
-static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
-static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
-static void monitor_kill PARAMS ((void));
-static void monitor_load PARAMS ((char *file, int from_tty));
-static void monitor_mourn_inferior PARAMS ((void));
-static void monitor_stop PARAMS ((void));
-
-static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
-static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
-static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
- char *myaddr, int len));
-static int monitor_write_memory_block PARAMS ((
- CORE_ADDR memaddr,
- char *myaddr,
- int len));
-static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
- char *buf, int buflen));
-static void monitor_dump_regs PARAMS ((void));
+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 (ptid_t ptid, 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 ptid_t monitor_wait (ptid_t ptid, 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);
#if 0
-static int from_hex PARAMS ((int a));
-static unsigned long get_hex_word PARAMS ((void));
+static int from_hex (int a);
+static unsigned long get_hex_word (void);
#endif
-static void parse_register_dump PARAMS ((char *, int));
+static void parse_register_dump (char *, int);
static struct monitor_ops *current_monitor;
static CORE_ADDR *breakaddr;
-/* Extra remote debugging for developing a new rom monitor variation */
-#if ! defined(EXTRA_RDEBUG)
-#define EXTRA_RDEBUG 0
-#endif
-#define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
-
/* 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 serial_t monitor_desc = NULL;
+static struct serial *monitor_desc = NULL;
/* Pointer to regexp pattern matching data */
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 DCACHE *remote_dcache;
static int first_time = 0; /* is this the first time we're executing after
gaving created the child proccess? */
-/* Convert a string into a printable representation, Return # byte in the
- new string. */
+#define TARGET_BUF_SIZE 2048
-static int
-monitor_printable_string (newstr, oldstr)
- char *newstr;
- char *oldstr;
+/* 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 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)
{
- char *save = newstr;
int ch;
+ int i;
- while ((ch = *oldstr++) != '\0')
+ if (len <= 0)
+ len = strlen (oldstr);
+
+ for (i = 0; i < len; i++)
{
+ ch = oldstr[i];
switch (ch)
{
default:
}
*newstr++ = '\0';
- return newstr - save;
}
/* Print monitor errors with a string, converting the string to printable
representation. */
static void
-monitor_error (format, memaddr, len, string, final_char)
- char *format;
- CORE_ADDR memaddr;
- int len;
- char *string;
- int final_char;
+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);
- char *p, *q;
- int ch;
- int safe_len = monitor_printable_string (safe_string, string);
+ monitor_printable_string (safe_string, string, real_len);
if (final_char)
- error (format, (int) memaddr, p - safe_string, safe_string, final_char);
+ error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);
else
- error (format, (int) memaddr, p - safe_string, safe_string);
+ error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);
}
/* Convert hex digit A to a number. */
static int
-fromhex (a)
- int a;
+fromhex (int a)
{
if (a >= '0' && a <= '9')
return a - '0';
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
*/
static void
-monitor_vsprintf (sndbuf, pattern, args)
- char *sndbuf;
- char *pattern;
- va_list args;
+monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
{
char format[10];
char fmt;
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- abort ();
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
-#if 0
- if (remote_debug > 0)
- puts_debug ("sent -->", sndbuf, "<--");
-#endif
- if (EXTRA_RDEBUG
- && remote_debug)
+ if (monitor_debug_p)
{
char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
- monitor_printable_string (safe_string, sndbuf);
- printf ("sent[%s]\n", safe_string);
+ monitor_printable_string (safe_string, sndbuf, 0);
+ fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
}
monitor_write (sndbuf, len);
len = strlen (sndbuf);
if (len + 1 > sizeof sndbuf)
- abort ();
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
-#if 0
- if (remote_debug > 0)
- puts_debug ("sent -->", sndbuf, "<--");
-#endif
- if (EXTRA_RDEBUG
- && remote_debug)
+ if (monitor_debug_p)
{
char *safe_string = (char *) alloca ((len * 4) + 1);
- monitor_printable_string (safe_string, sndbuf);
- printf ("sent[%s]\n", safe_string);
+ monitor_printable_string (safe_string, sndbuf, 0);
+ fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
}
monitor_write (sndbuf, len);
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. */
- RDEBUG (("ExpectEcho\n"))
- monitor_expect (sndbuf, (char *) 0, 0);
+ monitor_debug ("ExpectEcho\n");
+ monitor_expect (sndbuf, (char *) 0, 0);
}
/* Write characters to the remote system. */
void
-monitor_write (buf, buflen)
- char *buf;
- int buflen;
+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));
}
and without printing remote debug information. */
int
-monitor_readchar ()
+monitor_readchar (void)
{
int c;
int looping;
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 */
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"));
}
timeout stuff. */
static int
-readchar (timeout)
- int timeout;
+readchar (int timeout)
{
int c;
static enum
do
{
looping = 0;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ c = serial_readchar (monitor_desc, timeout);
if (c >= 0)
{
c &= 0x7f;
-#if 0
/* This seems to interfere with proper function of the
input stream */
- if (remote_debug > 0)
+ if (monitor_debug_p || remote_debug)
{
char buf[2];
buf[0] = c;
puts_debug ("read -->", buf, "<--");
}
-#endif
}
/* Canonicialize \n\r combinations into one \r */
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-
will be at the end of BUF. */
int
-monitor_expect (string, buf, buflen)
- char *string;
- char *buf;
- int buflen;
+monitor_expect (char *string, char *buf, int buflen)
{
char *p = string;
int obuflen = buflen;
int c;
- extern struct target_ops *targ_ops;
- if (EXTRA_RDEBUG
- && remote_debug)
+ if (monitor_debug_p)
{
char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
- monitor_printable_string (safe_string, string);
- printf ("MON Expecting '%s'\n", safe_string);
+ monitor_printable_string (safe_string, string, 0);
+ fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
}
- immediate_quit = 1;
+ immediate_quit++;
while (1)
{
if (buf)
if (buflen < 2)
{
*buf = '\000';
- immediate_quit = 0;
+ immediate_quit--;
return -1;
}
p++;
if (*p == '\0')
{
- immediate_quit = 0;
+ immediate_quit--;
if (buf)
{
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
/* Search for a regexp. */
static int
-monitor_expect_regexp (pat, buf, buflen)
- struct re_pattern_buffer *pat;
- char *buf;
- int buflen;
+monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
{
char *mybuf;
char *p;
- RDEBUG (("MON Expecting regexp\n"));
+ monitor_debug ("MON Expecting regexp\n");
if (buf)
mybuf = buf;
else
{
- mybuf = alloca (1024);
- buflen = 1024;
+ mybuf = alloca (TARGET_BUF_SIZE);
+ buflen = TARGET_BUF_SIZE;
}
p = mybuf;
getting into states from which we can't recover. */
int
-monitor_expect_prompt (buf, buflen)
- char *buf;
- int buflen;
+monitor_expect_prompt (char *buf, int buflen)
{
- RDEBUG (("MON Expecting prompt\n"))
- return monitor_expect (current_monitor->prompt, buf, 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
#if 0
static unsigned long
-get_hex_word ()
+get_hex_word (void)
{
unsigned long val;
int i;
#endif
static void
-compile_pattern (pattern, compiled_pattern, fastmap)
- char *pattern;
- struct re_pattern_buffer *compiled_pattern;
- char *fastmap;
+compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
+ char *fastmap)
{
int tmp;
const char *val;
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);
for communication. */
void
-monitor_open (args, mon_ops, from_tty)
- char *args;
- struct monitor_ops *mon_ops;
- int from_tty;
+monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
{
char *name;
char **p;
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);
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)
- free (dev_name);
- dev_name = strsave (args);
+ 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;
monitor_stop ();
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
{
- RDEBUG (("EXP Open echo\n"));
+ monitor_debug ("EXP Open echo\n");
monitor_expect_prompt (NULL, 0);
}
}
monitor_expect_prompt (NULL, 0);
}
- SERIAL_FLUSH_INPUT (monitor_desc);
+ serial_flush_input (monitor_desc);
/* Alloc breakpoints */
if (mon_ops->set_break != NULL)
}
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... */
+ inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */
/* Give monitor_wait something to read */
monitor_printf (current_monitor->line_term);
- if (current_monitor->flags & MO_HAS_BLOCKWRITES)
- remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
- else
- remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
start_remote ();
}
control. */
void
-monitor_close (quitting)
- int quitting;
+monitor_close (int quitting)
{
if (monitor_desc)
- SERIAL_CLOSE (monitor_desc);
+ serial_close (monitor_desc);
/* Free breakpoint memory */
if (breakaddr != NULL)
{
- free (breakaddr);
+ xfree (breakaddr);
breakaddr = NULL;
}
when you want to detach and do something else with your gdb. */
static void
-monitor_detach (args, from_tty)
- char *args;
- int from_tty;
+monitor_detach (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 (regno, valstr)
- int regno;
- char *valstr;
+monitor_supply_register (int regno, char *valstr)
{
- unsigned int val;
- unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
+ ULONGEST val;
+ unsigned char regbuf[MAX_REGISTER_SIZE];
char *p;
- val = strtoul (valstr, &p, 16);
- RDEBUG (("Supplying Register %d %s\n", regno, valstr));
+ 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.",
+ 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 (current_gdbarch, regno), val);
- supply_register (regno, regbuf);
+ regcache_raw_supply (current_regcache, regno, regbuf);
return p;
}
/* Tell the remote machine to resume. */
-void
-flush_monitor_dcache ()
-{
- dcache_flush (remote_dcache);
-}
-
static void
-monitor_resume (pid, step, sig)
- int pid, step;
- enum target_signal sig;
+monitor_resume (ptid_t ptid, int step, enum target_signal sig)
{
/* Some monitors require a different command when starting a program */
- RDEBUG (("MON resume\n"));
+ monitor_debug ("MON resume\n");
if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
{
first_time = 0;
dump_reg_flag = 1;
return;
}
- dcache_flush (remote_dcache);
if (step)
monitor_printf (current_monitor->step);
else
string which are passed down to monitor specific code. */
static void
-parse_register_dump (buf, len)
- char *buf;
- int len;
+parse_register_dump (char *buf, int len)
{
- RDEBUG (("MON Parsing register dump\n"))
- while (1)
+ monitor_debug ("MON Parsing register dump\n");
+ while (1)
{
int regnamelen, vallen;
char *regname, *val;
packet. */
static void
-monitor_interrupt (signo)
- int signo;
+monitor_interrupt (int signo)
{
/* If this doesn't work, try more severe steps. */
signal (signo, monitor_interrupt_twice);
- if (remote_debug)
- printf_unfiltered ("monitor_interrupt called\n");
+ if (monitor_debug_p || remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
target_stop ();
}
/* The user typed ^C twice. */
static void
-monitor_interrupt_twice (signo)
- int signo;
+monitor_interrupt_twice (int signo)
{
signal (signo, ofunc);
/* Ask the user what to do when an interrupt is received. */
static void
-monitor_interrupt_query ()
+monitor_interrupt_query (void)
{
target_terminal_ours ();
Give up (and stop debugging it)? "))
{
target_mourn_inferior ();
- return_to_top_level (RETURN_QUIT);
+ deprecated_throw_reason (RETURN_QUIT);
}
target_terminal_inferior ();
}
static void
-monitor_wait_cleanup (old_timeout)
- void *old_timeout;
+monitor_wait_cleanup (void *old_timeout)
{
timeout = *(int *) old_timeout;
signal (SIGINT, ofunc);
-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
/* Print any output characters that were preceded by ^O. */
/* FIXME - This would be great as a user settabgle flag */
- if (remote_debug ||
- current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+ if (monitor_debug_p || remote_debug
+ || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
{
int i;
/* Wait until the remote machine stops, then return, storing status in
status just as `wait' would. */
-static int
-monitor_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+static ptid_t
+monitor_wait (ptid_t ptid, struct target_waitstatus *status)
{
int old_timeout = timeout;
- char buf[1024];
+ char buf[TARGET_BUF_SIZE];
int resp_len;
struct cleanup *old_chain;
status->value.integer = 0;
old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
- RDEBUG (("MON wait\n"))
+ 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. */
+ timeout = -1; /* Don't time out -- user program is running. */
#endif
ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
/* Print any output characters that were preceded by ^O. */
/* FIXME - This would be great as a user settabgle flag */
- if (remote_debug ||
- current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+ if (monitor_debug_p || remote_debug
+ || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
{
int i;
if (current_monitor->register_pattern)
parse_register_dump (buf, resp_len);
#else
- RDEBUG (("Wait fetching registers after stop\n"));
+ monitor_debug ("Wait fetching registers after stop\n");
monitor_dump_regs ();
#endif
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 (regno)
- int regno;
+monitor_fetch_register (int regno)
{
- char *name;
- static char zerobuf[MAX_REGISTER_RAW_SIZE] =
- {0};
- char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
+ const char *name;
+ char *zerobuf;
+ char *regbuf;
int i;
- name = current_monitor->regnames[regno];
- RDEBUG (("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"))
+ regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
+ zerobuf = alloca (MAX_REGISTER_SIZE);
+ memset (zerobuf, 0, MAX_REGISTER_SIZE);
- if (!name || (*name == '\0'))
+ 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'))
{
- RDEBUG (("No register known for %d\n", regno))
- supply_register (regno, zerobuf);
+ monitor_debug ("No register known for %d\n", regno);
+ regcache_raw_supply (current_regcache, regno, zerobuf);
return;
}
if (current_monitor->getreg.resp_delim)
{
- RDEBUG (("EXP getreg.resp_delim\n"))
- monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
+ 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)
{
- RDEBUG (("EXP getreg.resp_delim\n"));
+ monitor_debug ("EXP getreg.resp_delim\n");
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
}
}
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);
}
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 (current_gdbarch, regno) * 2; i++)
{
int c;
c = readchar (timeout);
}
regbuf[i] = '\000'; /* terminate the number */
- RDEBUG (("REGVAL '%s'\n", regbuf));
+ 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
if (current_monitor->getreg.term)
{
- RDEBUG (("EXP getreg.term\n"))
- monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
+ monitor_debug ("EXP getreg.term\n");
+ monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
}
if (current_monitor->getreg.term_cmd)
{
- RDEBUG (("EMIT getreg.term.cmd\n"))
- monitor_printf (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 */
int
monitor_dump_reg_block (char *block_cmd)
{
- char buf[1024];
+ char buf[TARGET_BUF_SIZE];
int resp_len;
monitor_printf (block_cmd);
resp_len = monitor_expect_prompt (buf, sizeof (buf));
/* Call the specific function if it has been provided */
static void
-monitor_dump_regs ()
+monitor_dump_regs (void)
{
- char buf[1024];
+ char buf[TARGET_BUF_SIZE];
int resp_len;
if (current_monitor->dumpregs)
(*(current_monitor->dumpregs)) (); /* call supplied function */
parse_register_dump (buf, resp_len);
}
else
- abort (); /* 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 (regno)
- int regno;
+monitor_fetch_registers (int regno)
{
- RDEBUG (("MON fetchregs\n"));
+ monitor_debug ("MON fetchregs\n");
if (current_monitor->getreg.cmd)
{
if (regno >= 0)
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
static void
-monitor_store_register (regno)
- int regno;
+monitor_store_register (int regno)
{
- char *name;
- unsigned int val;
-
- name = current_monitor->regnames[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'))
{
- RDEBUG (("MON Cannot store unknown register\n"))
- return;
+ monitor_debug ("MON Cannot store unknown register\n");
+ return;
}
val = read_register (regno);
- RDEBUG (("MON storeg %d %08x\n", regno, (unsigned int) val))
+ monitor_debug ("MON storeg %d %s\n", regno,
+ phex (val, register_size (current_gdbarch, regno)));
/* send the register deposit command */
- if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
+ 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", paddr_nz (val));
+ }
if (current_monitor->setreg.term)
{
- RDEBUG (("EXP setreg.term\n"))
- monitor_expect (current_monitor->setreg.term, NULL, 0);
+ monitor_debug ("EXP setreg.term\n");
+ monitor_expect (current_monitor->setreg.term, NULL, 0);
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
- monitor_printf ("%x\r", val);
+ monitor_printf ("%s\r", paddr_nz (val));
monitor_expect_prompt (NULL, 0);
}
else
monitor_expect_prompt (NULL, 0);
if (current_monitor->setreg.term_cmd) /* Mode exit required */
{
- RDEBUG (("EXP setreg_termcmd\n"));
+ monitor_debug ("EXP setreg_termcmd\n");
monitor_printf ("%s", current_monitor->setreg.term_cmd);
monitor_expect_prompt (NULL, 0);
}
/* Store the remote registers. */
static void
-monitor_store_registers (regno)
- int regno;
+monitor_store_registers (int regno)
{
if (regno >= 0)
{
debugged. */
static void
-monitor_prepare_to_store ()
+monitor_prepare_to_store (void)
{
/* Do nothing, since we can store individual regs */
}
static void
-monitor_files_info (ops)
- struct target_ops *ops;
+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 (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
unsigned int val, hostval;
char *cmd;
int i;
- RDEBUG (("MON write %d %08x\n", len, (unsigned long) memaddr))
+ monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
- if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
+ if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
memaddr = ADDR_BITS_REMOVE (memaddr);
/* Use memory fill command for leading 0 bytes. */
if (i > 4) /* More than 4 zeros is worth doing */
{
- RDEBUG (("MON FILL %d\n", i))
- if (current_monitor->flags & MO_FILL_USES_ADDR)
+ 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);
if (len == 4)
{
hostval = *(unsigned int *) myaddr;
- RDEBUG (("Hostval(%08x) val(%08x)\n", hostval, val));
+ monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
}
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)
{
- RDEBUG (("EXP setmem.term"));
+ monitor_debug ("EXP setmem.term");
monitor_expect (current_monitor->setmem.term, NULL, 0);
monitor_printf ("%x\r", val);
}
static int
-monitor_write_even_block (memaddr, myaddr, len)
- 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;
- RDEBUG ((" @ %08x\n", 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 (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
{
unsigned char val;
int written = 0;
Which possably entails endian conversions
*/
static int
-monitor_write_memory_longlongs (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
{
static char hexstage[20]; /* At least 16 digits required, plus null */
char *endstring;
*/
static int
-monitor_write_memory_block (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
{
int written;
written = 0;
{
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;
which can only read a single byte/word/etc. at a time. */
static int
-monitor_read_memory_single (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
{
unsigned int val;
char membuf[sizeof (int) * 2 + 1];
char *p;
char *cmd;
- int i;
- RDEBUG (("MON read single\n"));
+ 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
if (current_monitor->getmem.resp_delim)
{
- RDEBUG (("EXP getmem.resp_delim\n"));
+ monitor_debug ("EXP getmem.resp_delim\n");
monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
}
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
;
else
- monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
- memaddr, i, membuf, c);
+ monitor_error ("monitor_read_memory_single",
+ "bad response from monitor",
+ memaddr, 0, NULL, 0);
}
- 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 (0x%x): bad response from monitor: %.*s%c.",
- memaddr, i, membuf, c);
- }
+ {
+ 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 */
+ 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
val = strtoul (membuf, &p, 16);
if (val == 0 && membuf == p)
- monitor_error ("monitor_read_memory_single (0x%x): bad value from monitor: %s.",
+ monitor_error ("monitor_read_memory_single",
+ "bad value from monitor",
memaddr, 0, membuf, 0);
/* supply register stores in target byte order, so swap here */
than 16 bytes at a time. */
static int
-monitor_read_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
{
unsigned int val;
char buf[512];
if (len <= 0)
{
- RDEBUG (("Zero length call to monitor_read_memory\n"));
+ monitor_debug ("Zero length call to monitor_read_memory\n");
return 0;
}
- if (remote_debug)
- printf ("MON read block ta(%08x) ha(%08x) %d\n",
- (unsigned long) memaddr, (unsigned long) myaddr, len);
+ monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
+ paddr_nz (memaddr), (long) myaddr, len);
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
memaddr = ADDR_BITS_REMOVE (memaddr);
resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
if (resp_len <= 0)
- monitor_error ("monitor_read_memory (0x%x): excessive response from monitor: %.*s.",
+ 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,
+ serial_write (monitor_desc, current_monitor->getmem.term_cmd,
strlen (current_monitor->getmem.term_cmd));
monitor_expect_prompt (NULL, 0);
}
{
int retval, tmp;
struct re_registers resp_strings;
- RDEBUG (("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim));
+ monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
memset (&resp_strings, 0, sizeof (struct re_registers));
tmp = strlen (p);
&resp_strings);
if (retval < 0)
- monitor_error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
+ 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 (0x%x): bad response from monitor: %.*s.",
+ monitor_error ("monitor_read_memory",
+ "bad response from monitor",
memaddr, resp_len, buf, 0);
p += strlen (current_monitor->getmem.resp_delim);
#endif
}
- if (remote_debug)
- printf ("MON scanning %d ,%08x '%s'\n", len, p, p);
+ monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
{
char c;
{
val = fromhex (c) * 16 + fromhex (*(p + 1));
*myaddr++ = val;
- if (remote_debug)
- printf ("[%02x]", val);
+ if (monitor_debug_p || remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
--i;
fetched++;
}
c = *p;
}
if (fetched == 0)
- error ("Failed to read via monitor");
- if (remote_debug)
- printf ("\n");
+ 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 */
}
- RDEBUG (("MON scanning bytes\n"));
+ monitor_debug ("MON scanning bytes\n");
for (i = len; i > 0; i--)
{
break;
if (*p == '\000' || *p == '\n' || *p == '\r')
- monitor_error ("monitor_read_memory (0x%x): badly terminated response from monitor: %.*s",
+ 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 (0x%x): bad value from monitor: %.*s.",
+ monitor_error ("monitor_read_memory",
+ "bad value from monitor",
memaddr, resp_len, buf, 0);
*myaddr++ = val;
return len;
}
+/* Transfer LEN bytes between target address MEMADDR and GDB address
+ MYADDR. Returns 0 for success, errno code for failure. TARGET is
+ unused. */
+
static int
-monitor_xfer_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
+monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+ struct mem_attrib *attrib, struct target_ops *target)
{
- return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
+ int res;
+
+ if (write)
+ {
+ if (current_monitor->flags & MO_HAS_BLOCKWRITES)
+ res = monitor_write_memory_block(memaddr, myaddr, len);
+ else
+ res = monitor_write_memory(memaddr, myaddr, len);
+ }
+ else
+ {
+ res = monitor_read_memory(memaddr, myaddr, len);
+ }
+
+ return res;
}
static void
-monitor_kill ()
+monitor_kill (void)
{
return; /* ignore attempts to kill target system */
}
the program at that point. */
static void
-monitor_create_inferior (exec_file, args, env)
- char *exec_file;
- char *args;
- char **env;
+monitor_create_inferior (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 ();
instructions. */
static void
-monitor_mourn_inferior ()
+monitor_mourn_inferior (void)
{
unpush_target (targ_ops);
generic_mourn_inferior (); /* Do all the proper things now */
/* Tell the monitor to add a breakpoint. */
static int
-monitor_insert_breakpoint (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
{
int i;
- unsigned char *bp;
+ const unsigned char *bp;
int bplen;
- RDEBUG (("MON inst bkpt %08x\n", addr))
- if (current_monitor->set_break == NULL)
- error ("No set_break defined for this monitor");
+ monitor_debug ("MON inst bkpt %s\n", paddr (addr));
+ if (current_monitor->set_break == NULL)
+ error (_("No set_break defined for this monitor"));
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
addr = ADDR_BITS_REMOVE (addr);
/* Determine appropriate breakpoint size for this address. */
- bp = memory_breakpoint_from_pc (&addr, &bplen);
+ bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
for (i = 0; i < current_monitor->num_breakpoints; i++)
{
}
}
- 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 (addr, shadow)
- CORE_ADDR addr;
- char *shadow;
+monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
{
int i;
- RDEBUG (("MON rmbkpt %08x\n", addr))
- if (current_monitor->clr_break == NULL)
- error ("No clr_break defined for this monitor");
+ monitor_debug ("MON rmbkpt %s\n", paddr (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);
}
}
fprintf_unfiltered (gdb_stderr,
- "Can't find breakpoint associated with 0x%x\n", addr);
+ "Can't find breakpoint associated with 0x%s\n",
+ paddr_nz (addr));
return 1;
}
an S-record. Return non-zero if the ACK is received properly. */
static int
-monitor_wait_srec_ack ()
+monitor_wait_srec_ack (void)
{
- int i, ch;
+ int ch;
if (current_monitor->flags & MO_SREC_ACK_PLUS)
{
/* monitor_load -- download a file. */
static void
-monitor_load (file, from_tty)
- char *file;
- int from_tty;
+monitor_load (char *file, int from_tty)
{
- dcache_flush (remote_dcache);
- RDEBUG (("MON load\n"))
+ monitor_debug ("MON load\n");
- if (current_monitor->load_routine)
+ if (current_monitor->load_routine)
current_monitor->load_routine (monitor_desc, file, hashmark);
else
{ /* The default is ascii S-records */
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 ();
+ /* 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 ()
+monitor_stop (void)
{
- RDEBUG (("MON stop\n"));
+ 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);
}
static void
monitor_rcmd (char *command,
- struct gdb_file *outbuf)
+ struct ui_file *outbuf)
{
char *p;
int resp_len;
char buf[1000];
if (monitor_desc == NULL)
- error ("monitor target not open.");
+ error (_("monitor target not open."));
p = current_monitor->prompt;
#if 0
static int
-from_hex (a)
- int a;
+from_hex (int a)
{
if (a >= '0' && a <= '9')
return a - '0';
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
char *
-monitor_get_dev_name ()
+monitor_get_dev_name (void)
{
return dev_name;
}
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_core_file_to_sym_file = NULL;
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_magic = OPS_MAGIC;
} /* init_base_monitor_ops */
/* Init the target_ops structure pointed at by OPS */
void
-init_monitor_ops (ops)
- struct target_ops *ops;
+init_monitor_ops (struct target_ops *ops)
{
if (monitor_ops.to_magic != OPS_MAGIC)
init_base_monitor_ops ();
/* Define additional commands that are usually only used by monitors. */
+extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
+
void
-_initialize_remote_monitors ()
+_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_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."),
+ NULL,
+ NULL, /* FIXME: i18n: */
+ &setdebuglist, &showdebuglist);
}
projects / deliverable / binutils-gdb.git / blobdiff