/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
- Free Software Foundation, Inc.
+ Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
Resurrected from the ashes by Stu Grossman.
#include "defs.h"
#include "gdbcore.h"
#include "target.h"
-#include "wait.h"
+#include "gdb_wait.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 "gdb_regex.h"
#include "dcache.h"
#include "srec.h"
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_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 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 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. */
#define TARGET_BUF_SIZE 2048
-/* Convert a string into a printable representation, Return # byte in the
- new string. */
+/* Monitor specific debugging information. Typically only useful to
+ the developer of a new monitor interface. */
-static int
-monitor_printable_string (newstr, oldstr)
- char *newstr;
- char *oldstr;
+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. Perhaphs 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;
- 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. */
if (len + 1 > sizeof sndbuf)
abort ();
-#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);
if (len + 1 > sizeof sndbuf)
abort ();
-#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);
}
c &= 0x7f;
/* 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;
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;
{
char *mybuf;
char *p;
- RDEBUG (("MON Expecting regexp\n"));
+ monitor_debug ("MON Expecting regexp\n");
if (buf)
mybuf = buf;
else
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
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);
}
}
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
char *p;
+ val = 0;
p = valstr;
while (p && *p != '\0')
{
val <<= 4;
val += fromhex (*p++);
}
- RDEBUG (("Supplying Register %d %s\n", regno, valstr));
+ monitor_debug ("Supplying Register %d %s\n", regno, valstr);
if (*p != '\0')
error ("monitor_supply_register (%d): bad value from monitor: %s.",
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;
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;
/* 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 ();
}
/* 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;
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
int regno;
{
char *name;
- static char zerobuf[MAX_REGISTER_RAW_SIZE] =
- {0};
- char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
+ 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);
+
name = current_monitor->regnames[regno];
- RDEBUG (("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"))
+ monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
- if (!name || (*name == '\0'))
+ 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);
+ supply_register (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);
}
}
}
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 */
monitor_fetch_registers (regno)
int regno;
{
- RDEBUG (("MON fetchregs\n"));
+ monitor_debug ("MON fetchregs\n");
if (current_monitor->getreg.cmd)
{
if (regno >= 0)
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 %08lx\n", regno, (ULONGEST) val))
+ monitor_debug ("MON storeg %d %s\n", regno, preg (val));
/* 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);
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 ("%A\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);
}
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);
}
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);
}
myaddr += 4;
memaddr += 4;
written += 4;
- RDEBUG ((" @ %08x\n", memaddr))
+ monitor_debug (" @ %s\n", paddr (memaddr));
/* If we wanted to, here we could validate the address */
- monitor_expect_prompt (NULL, 0);
+ monitor_expect_prompt (NULL, 0);
}
/* Now exit the sub mode */
monitor_printf (current_monitor->getreg.term_cmd);
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.",
+ monitor_error ("monitor_read_memory_single",
+ "bad response from monitor",
memaddr, i, membuf, c);
}
for (i = 0; i < len * 2; i++)
if (c == ' ')
continue;
- monitor_error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
+ monitor_error ("monitor_read_memory_single",
+ "bad response from monitor",
memaddr, i, membuf, c);
}
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 */
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)
{
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++;
}
}
if (fetched == 0)
error ("Failed to read via monitor");
- if (remote_debug)
- printf ("\n");
+ 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;
unsigned char *bp;
int bplen;
- RDEBUG (("MON inst bkpt %08x\n", addr))
- if (current_monitor->set_break == NULL)
+ 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)
{
int i;
- RDEBUG (("MON rmbkpt %08x\n", addr))
- if (current_monitor->clr_break == NULL)
+ 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)
}
}
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;
}
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 */
static void
monitor_stop ()
{
- RDEBUG (("MON stop\n"));
+ monitor_debug ("MON stop\n");
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
SERIAL_SEND_BREAK (monitor_desc);
if (current_monitor->stop)
static void
monitor_rcmd (char *command,
- struct gdb_file *outbuf)
+ struct ui_file *outbuf)
{
char *p;
int resp_len;
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\
+When enabled, communication between GDB and the remote monitor\n\
+is displayed.", &setdebuglist),
+ &showdebuglist);
}