/* Remote debugging for the ARM RDP interface.
- Copyright 1994, 1995 Free Software Foundation, Inc.
+
+ Copyright 1994, 1995, 1998, 1999, 2000, 2001, 2002 Free Software
+ Foundation, Inc.
This file is part of GDB.
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.
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
*/
#include "defs.h"
#include "inferior.h"
-#include "wait.h"
#include "value.h"
-#include "callback.h"
+#include "gdb/callback.h"
#include "command.h"
-#ifdef ANSI_PROTOTYPES
-#include <stdarg.h>
-#else
-#include <varargs.h>
-#endif
-
+#include <ctype.h>
#include <fcntl.h>
#include "symfile.h"
#include "remote-utils.h"
+#include "gdb_string.h"
+#include "gdbcore.h"
+#include "regcache.h"
+#include "serial.h"
+
+#include "arm-tdep.h"
+
+#ifdef HAVE_TIME_H
+#include <time.h>
+#endif
extern struct target_ops remote_rdp_ops;
-static serial_t io;
+static struct serial *io;
static host_callback *callback = &default_callback;
struct
-{
- int step_info;
- int break_info;
- int model_info;
- int target_info;
- int can_step;
- char command_line[10];
- int rdi_level;
- int rdi_stopped_status;
-} ds;
+ {
+ int step_info;
+ int break_info;
+ int model_info;
+ int target_info;
+ int can_step;
+ char command_line[10];
+ int rdi_level;
+ int rdi_stopped_status;
+ }
+ds;
#define RDP_OPEN 0
#define RDP_OPEN_TYPE_COLD 0
#define RDP_OPEN_TYPE_WARM 1
+#define RDP_OPEN_TYPE_BAUDRATE 2
+
+#define RDP_OPEN_BAUDRATE_9600 1
+#define RDP_OPEN_BAUDRATE_19200 2
+#define RDP_OPEN_BAUDRATE_38400 3
+
#define RDP_OPEN_TYPE_RETURN_SEX (1<<3)
#define RDP_CLOSE 1
#define RDP_FPU_READWRITE_MASK_FPS (1<<8)
#define RDP_SET_BREAK 0xa
-#define RDP_SET_BREAK_TYPE_PC_EQUAL 0
-#define RDP_SET_BREAK_TYPE_GET_HANDLE (0x10)
+#define RDP_SET_BREAK_TYPE_PC_EQUAL 0
+#define RDP_SET_BREAK_TYPE_GET_HANDLE (0x10)
#define RDP_CLEAR_BREAK 0xb
#define RDP_INFO_ABOUT_BREAK_THREAD_BREAK (1<<9)
#define RDP_INFO_ABOUT_BREAK_THREAD_WATCH (1<<10)
#define RDP_INFO_ABOUT_BREAK_COND (1<<11)
+#define RDP_INFO_VECTOR_CATCH (0x180)
+#define RDP_INFO_ICEBREAKER (7)
+#define RDP_INFO_SET_CMDLINE (0x300)
+
+#define RDP_SELECT_CONFIG (0x16)
+#define RDI_ConfigCPU 0
+#define RDI_ConfigSystem 1
+#define RDI_MatchAny 0
+#define RDI_MatchExactly 1
+#define RDI_MatchNoEarlier 2
#define RDP_RESET 0x7f
#define RDP_RES_VALUE_BIG_ENDIAN 241
#define RDP_RES_RESET 0x7f
#define RDP_RES_AT_BREAKPOINT 143
-
+#define RDP_RES_IDUNNO 0xe6
#define RDP_OSOpReply 0x13
#define RDP_OSOpWord 2
#define RDP_OSOpNothing 0
static int timeout = 2;
+static char *commandline = NULL;
+
static int
-remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
- char *myaddr,
- int len,
- int write,
- struct target_ops * target));
+remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int write,
+ struct mem_attrib *attrib,
+ struct target_ops *target);
/* Stuff for talking to the serial layer. */
static unsigned char
-get_byte ()
+get_byte (void)
{
- int c = SERIAL_READCHAR (io, timeout);
+ int c = serial_readchar (io, timeout);
+
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
if (c == SERIAL_TIMEOUT)
{
error ("Timeout reading from remote_system");
}
- if (remote_debug)
- printf ("[%02x]", c);
return c;
}
/* Note that the target always speaks little-endian to us,
even if it's a big endian machine. */
static unsigned int
-get_word ()
+get_word (void)
{
unsigned int val = 0;
unsigned int c;
}
static void
-put_byte (val)
- char val;
+put_byte (char val)
{
- SERIAL_WRITE (io, &val, 1);
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
+ serial_write (io, &val, 1);
}
static void
-put_word (val)
- long val;
+put_word (int val)
{
/* We always send in little endian */
unsigned char b[4];
b[2] = val >> 16;
b[3] = val >> 24;
- SERIAL_WRITE (io, b, 4);
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
+
+ serial_write (io, b, 4);
}
/* Stuff for talking to the RDP layer. */
+/* This is a bit more fancy that need be so that it syncs even in nasty cases.
-/* This is a bit more fancy that need be so that it syncs even in nasty cases. */
+ I'be been unable to make it reliably sync up with the change
+ baudrate open command. It likes to sit and say it's been reset,
+ with no more action. So I took all that code out. I'd rather sync
+ reliably at 9600 than wait forever for a possible 19200 connection.
+ */
static void
-rdp_init ()
+rdp_init (int cold, int tty)
{
- int oloop;
+ int sync = 0;
+ int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
+ int baudtry = 9600;
- for (oloop = 0; oloop < 2; oloop++)
- {
- int longtry;
- SERIAL_FLUSH_INPUT (io);
- for (longtry = 0; longtry < 2; longtry++)
- {
- int try;
- int flush_and_retry = 0;
+ time_t now = time (0);
+ time_t stop_time = now + 10; /* Try and sync for 10 seconds, then give up */
- for (try = 0; try < 10 && !flush_and_retry; try++)
- {
- int restype;
- put_byte (RDP_OPEN);
- put_byte (RDP_OPEN_TYPE_COLD | RDP_OPEN_TYPE_RETURN_SEX);
- put_word (0);
+ while (time (0) < stop_time && !sync)
+ {
+ int restype;
+ QUIT;
- restype = SERIAL_READCHAR (io, 1);
+ serial_flush_input (io);
+ serial_flush_output (io);
+ if (tty)
+ printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
+
+ /*
+ ** It seems necessary to reset an EmbeddedICE to get it going.
+ ** This has the side benefit of displaying the startup banner.
+ */
+ if (cold)
+ {
+ put_byte (RDP_RESET);
+ while ((restype = serial_readchar (io, 1)) > 0)
+ {
switch (restype)
{
case SERIAL_TIMEOUT:
- flush_and_retry = 1;
break;
case RDP_RESET:
- return;
+ /* Sent at start of reset process: ignore */
+ break;
default:
- printf_unfiltered ("Got res return %d\n", restype);
+ printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
break;
- case RDP_RES_VALUE:
+ }
+ }
+
+ if (restype == 0)
+ {
+ /* Got end-of-banner mark */
+ printf_filtered ("\n");
+ }
+ }
+
+ put_byte (RDP_OPEN);
+
+ put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
+ put_word (0);
+
+ while (!sync && (restype = serial_readchar (io, 1)) > 0)
+ {
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
+
+ switch (restype)
+ {
+ case SERIAL_TIMEOUT:
+ break;
+
+ case RDP_RESET:
+ while ((restype = serial_readchar (io, 1)) == RDP_RESET)
+ ;
+ do
+ {
+ printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
+ }
+ while ((restype = serial_readchar (io, 1)) > 0);
+
+ if (tty)
+ {
+ printf_unfiltered ("\nThe board has sent notification that it was reset.\n");
+ printf_unfiltered ("Waiting for it to settle down...\n");
+ }
+ sleep (3);
+ if (tty)
+ printf_unfiltered ("\nTrying again.\n");
+ cold = 0;
+ break;
+
+ default:
+ break;
+
+ case RDP_RES_VALUE:
+ {
+ int resval = serial_readchar (io, 1);
+
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
+
+ switch (resval)
{
- int resval = SERIAL_READCHAR (io, 1);
-
- switch (resval)
- {
- case SERIAL_TIMEOUT:
- break;
- case RDP_RES_VALUE_LITTLE_ENDIAN:
- target_byte_order = LITTLE_ENDIAN;
- return;
- case RDP_RES_VALUE_BIG_ENDIAN:
- target_byte_order = BIG_ENDIAN;
- return;
- default:
- printf_unfiltered ("Trying to sync, got resval %d\n", resval);
- }
+ case SERIAL_TIMEOUT:
+ break;
+ case RDP_RES_VALUE_LITTLE_ENDIAN:
+ target_byte_order = BFD_ENDIAN_LITTLE;
+ sync = 1;
+ break;
+ case RDP_RES_VALUE_BIG_ENDIAN:
+ target_byte_order = BFD_ENDIAN_BIG;
+ sync = 1;
+ break;
+ default:
+ break;
}
- }
+ }
}
}
}
- error ("Couldn't reset the board, try pressing the reset button");
+
+ if (!sync)
+ {
+ error ("Couldn't reset the board, try pressing the reset button");
+ }
}
-#ifdef ANSI_PROTOTYPES
void
send_rdp (char *template,...)
-#else
-void
-send_rdp (char *template, va_alist)
- va_dcl
-#endif
{
char buf[200];
char *dst = buf;
va_list alist;
-#ifdef ANSI_PROTOTYPES
va_start (alist, template);
-#else
- va_start (alist);
-#endif
while (*template)
{
}
break;
case 'Z':
- /* Check the result code, error if not zero */
- if (get_byte ())
- error ("Command garbled");
+ /* Check the result code */
+ switch (get_byte ())
+ {
+ case 0:
+ /* Success */
+ break;
+ case 253:
+ /* Target can't do it; never mind */
+ printf_unfiltered ("RDP: Insufficient privilege\n");
+ return;
+ case 254:
+ /* Target can't do it; never mind */
+ printf_unfiltered ("RDP: Unimplemented message\n");
+ return;
+ case 255:
+ error ("Command garbled");
+ break;
+ default:
+ error ("Corrupt reply from target");
+ break;
+ }
break;
case 'W':
/* Read a word from the target */
pc = va_arg (alist, char *);
val = va_arg (alist, int);
dst = buf;
- SERIAL_WRITE (io, pc, val);
+ serial_write (io, pc, val);
break;
case '-':
/* Send whats in the queue */
if (dst != buf)
{
- SERIAL_WRITE (io, buf, dst - buf);
+ serial_write (io, buf, dst - buf);
dst = buf;
}
break;
*pi = get_byte ();
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
}
- va_end (args);
+ va_end (alist);
if (dst != buf)
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
static int
-rdp_write (memaddr, buf, len)
- CORE_ADDR memaddr;
- char *buf;
- int len;
+rdp_write (CORE_ADDR memaddr, char *buf, int len)
{
int res;
int val;
static int
-rdp_read (memaddr, buf, len)
- CORE_ADDR memaddr;
- char *buf;
- int len;
+rdp_read (CORE_ADDR memaddr, char *buf, int len)
{
int res;
int val;
}
static void
-rdp_fetch_one_register (mask, buf)
- int mask;
- char *buf;
+rdp_fetch_one_register (int mask, char *buf)
{
int val;
send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
}
static void
-rdp_fetch_one_fpu_register (mask, buf)
- int mask;
- char *buf;
+rdp_fetch_one_fpu_register (int mask, char *buf)
{
#if 0
/* !!! Since the PIE board doesn't work as documented,
{
/* There are 12 bytes long
!! fixme about endianness
- */
+ */
int dummy; /* I've seen these come back as four words !! */
send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
}
static void
-rdp_store_one_register (mask, buf)
- int mask;
- char *buf;
+rdp_store_one_register (int mask, char *buf)
{
int val = extract_unsigned_integer (buf, 4);
static void
-rdp_store_one_fpu_register (mask, buf)
- int mask;
- char *buf;
+rdp_store_one_fpu_register (int mask, char *buf)
{
#if 0
/* See comment in fetch_one_fpu_register */
}
#endif
}
-
\f
+
/* Convert between GDB requests and the RDP layer. */
static void
-remote_rdp_fetch_register (regno)
- int regno;
+remote_rdp_fetch_register (int regno)
{
if (regno == -1)
{
}
else
{
- char buf[MAX_REGISTER_RAW_SIZE];
+ char buf[ARM_MAX_REGISTER_RAW_SIZE];
if (regno < 15)
rdp_fetch_one_register (1 << regno, buf);
- else if (regno == PC_REGNUM)
+ else if (regno == ARM_PC_REGNUM)
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
- else if (regno == PS_REGNUM)
+ else if (regno == ARM_PS_REGNUM)
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
- else if (regno == FPS_REGNUM)
+ else if (regno == ARM_FPS_REGNUM)
rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
- else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
- rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
+ else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+ rdp_fetch_one_fpu_register (1 << (regno - ARM_F0_REGNUM), buf);
else
{
printf ("Help me with fetch reg %d\n", regno);
static void
-remote_rdp_store_register (regno)
- int regno;
+remote_rdp_store_register (int regno)
{
if (regno == -1)
{
}
else
{
- char tmp[MAX_REGISTER_RAW_SIZE];
- read_register_gen (regno, tmp);
+ char tmp[ARM_MAX_REGISTER_RAW_SIZE];
+ deprecated_read_register_gen (regno, tmp);
if (regno < 15)
rdp_store_one_register (1 << regno, tmp);
- else if (regno == PC_REGNUM)
+ else if (regno == ARM_PC_REGNUM)
rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
- else if (regno == PS_REGNUM)
+ else if (regno == ARM_PS_REGNUM)
rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
- else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
- rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
+ else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
+ rdp_store_one_fpu_register (1 << (regno - ARM_F0_REGNUM), tmp);
else
{
printf ("Help me with reg %d\n", regno);
}
static void
-remote_rdp_kill ()
+remote_rdp_kill (void)
{
callback->shutdown (callback);
}
static void
-rdp_info ()
+rdp_info (void)
{
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
&ds.step_info);
static void
-rdp_execute_start ()
+rdp_execute_start (void)
{
/* Start it off, but don't wait for it */
send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
}
+static void
+rdp_set_command_line (char *command, char *args)
+{
+ /*
+ ** We could use RDP_INFO_SET_CMDLINE to send this, but EmbeddedICE systems
+ ** don't implement that, and get all confused at the unexpected text.
+ ** Instead, just keep a copy, and send it when the target does a SWI_GetEnv
+ */
+
+ if (commandline != NULL)
+ xfree (commandline);
+
+ xasprintf (&commandline, "%s %s", command, args);
+}
+
+static void
+rdp_catch_vectors (void)
+{
+ /*
+ ** We want the target monitor to intercept the abort vectors
+ ** i.e. stop the program if any of these are used.
+ */
+ send_rdp ("bww-SZ", RDP_INFO, RDP_INFO_VECTOR_CATCH,
+ /*
+ ** Specify a bitmask including
+ ** the reset vector
+ ** the undefined instruction vector
+ ** the prefetch abort vector
+ ** the data abort vector
+ ** the address exception vector
+ */
+ (1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5)
+ );
+}
+
+
#define a_byte 1
#define a_word 2
#define SWI_GenerateError 0x71
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+static int translate_open_mode[] =
+{
+ O_RDONLY, /* "r" */
+ O_RDONLY + O_BINARY, /* "rb" */
+ O_RDWR, /* "r+" */
+ O_RDWR + O_BINARY, /* "r+b" */
+ O_WRONLY + O_CREAT + O_TRUNC, /* "w" */
+ O_WRONLY + O_BINARY + O_CREAT + O_TRUNC, /* "wb" */
+ O_RDWR + O_CREAT + O_TRUNC, /* "w+" */
+ O_RDWR + O_BINARY + O_CREAT + O_TRUNC, /* "w+b" */
+ O_WRONLY + O_APPEND + O_CREAT, /* "a" */
+ O_WRONLY + O_BINARY + O_APPEND + O_CREAT, /* "ab" */
+ O_RDWR + O_APPEND + O_CREAT, /* "a+" */
+ O_RDWR + O_BINARY + O_APPEND + O_CREAT /* "a+b" */
+};
+
static int
-exec_swi (swi, args)
- int swi;
- argsin *args;
+exec_swi (int swi, argsin *args)
{
int i;
char c;
case SWI_Time:
args->n = callback->time (callback, NULL);
return 1;
+
+ case SWI_Clock:
+ /* return number of centi-seconds... */
+ args->n =
+#ifdef CLOCKS_PER_SEC
+ (CLOCKS_PER_SEC >= 100)
+ ? (clock () / (CLOCKS_PER_SEC / 100))
+ : ((clock () * 100) / CLOCKS_PER_SEC);
+#else
+ /* presume unix... clock() returns microseconds */
+ clock () / 10000;
+#endif
+ return 1;
+
case SWI_Remove:
args->n = callback->unlink (callback, args->s);
return 1;
case SWI_Rename:
args->n = callback->rename (callback, args[0].s, args[1].s);
return 1;
- case SWI_Open:
- i = 0;
-#ifdef O_BINARY
- if (args[1].n & 1)
- i |= O_BINARY;
-#endif
- if (args[1].n & 2)
- i |= O_RDWR;
+ case SWI_Open:
+ /* Now we need to decode the Demon open mode */
+ i = translate_open_mode[args[1].n];
- if (args[1].n & 4)
+ /* Filename ":tt" is special: it denotes stdin/out */
+ if (strcmp (args->s, ":tt") == 0)
{
- i |= O_CREAT;
+ if (i == O_RDONLY) /* opening tty "r" */
+ args->n = 0 /* stdin */ ;
+ else
+ args->n = 1 /* stdout */ ;
}
-
- if (args[1].n & 8)
- i |= O_APPEND;
-
- args->n = callback->open (callback, args->s, i);
+ else
+ args->n = callback->open (callback, args->s, i);
return 1;
case SWI_Close:
return 1;
case SWI_Write:
- args->n = callback->write (callback, args[0].n, args[1].s, args[1].n);
+ /* Return the number of bytes *not* written */
+ args->n = args[1].n -
+ callback->write (callback, args[0].n, args[1].s, args[1].n);
return 1;
+
case SWI_Read:
{
char *copy = alloca (args[2].n);
int done = callback->read (callback, args[0].n, copy, args[2].n);
if (done > 0)
- remote_rdp_xfer_inferior_memory (args[0].n, copy, done, 1, 0);
- args->n -= done;
+ remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0, 0);
+ args->n = args[2].n - done;
return 1;
}
case SWI_Seek:
- args->n = callback->lseek (callback, args[0].n, args[1].n, 0) >= 0;
+ /* Return non-zero on failure */
+ args->n = callback->lseek (callback, args[0].n, args[1].n, 0) < 0;
return 1;
+
case SWI_Flen:
{
- long old = callback->lseek (callback, args->n, 1, 1);
- args->n = callback->lseek (callback, args->n, 2, 0);
+ long old = callback->lseek (callback, args->n, 0, SEEK_CUR);
+ args->n = callback->lseek (callback, args->n, 0, SEEK_END);
callback->lseek (callback, args->n, old, 0);
return 1;
}
args->n = callback->isatty (callback, args->n);
return 1;
+ case SWI_GetEnv:
+ if (commandline != NULL)
+ {
+ int len = strlen (commandline);
+ if (len > 255)
+ {
+ len = 255;
+ commandline[255] = '\0';
+ }
+ remote_rdp_xfer_inferior_memory (args[0].n,
+ commandline, len + 1, 1, 0, 0);
+ }
+ else
+ remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0, 0);
+ return 1;
+
default:
return 0;
}
}
-static void
-handle_swi ()
+static void
+handle_swi (void)
{
argsin args[3];
char *buf;
buf,
len,
0,
+ 0,
0);
}
else
break;
default:
- error ("Unimplented SWI argument");
+ error ("Unimplemented SWI argument");
}
type = type >> 2;
}
static void
-rdp_execute_finish ()
+rdp_execute_finish (void)
{
int running = 1;
while (running)
{
int res;
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
while (res == SERIAL_TIMEOUT)
{
- QUIT ;
+ QUIT;
printf_filtered ("Waiting for target..\n");
- res = SERIAL_READCHAR (io, 1);
+ res = serial_readchar (io, 1);
}
switch (res)
static void
-rdp_execute ()
+rdp_execute (void)
{
rdp_execute_start ();
rdp_execute_finish ();
}
static int
-remote_rdp_insert_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save;
+remote_rdp_insert_breakpoint (CORE_ADDR addr, char *save)
{
int res;
if (ds.rdi_level > 0)
}
static int
-remote_rdp_remove_breakpoint (addr, save)
- CORE_ADDR addr;
- char *save;
+remote_rdp_remove_breakpoint (CORE_ADDR addr, char *save)
{
int res;
if (ds.rdi_level > 0)
}
static void
-rdp_step ()
+rdp_step (void)
{
if (ds.can_step && 0)
{
else
{
char handle[4];
- CORE_ADDR pc = read_register (PC_REGNUM);
+ CORE_ADDR pc = read_register (ARM_PC_REGNUM);
pc = arm_get_next_pc (pc);
- remote_rdp_insert_breakpoint (pc, &handle);
+ remote_rdp_insert_breakpoint (pc, handle);
rdp_execute ();
- remote_rdp_remove_breakpoint (pc, &handle);
+ remote_rdp_remove_breakpoint (pc, handle);
}
}
static void
-remote_rdp_open (args, from_tty)
- char *args;
- int from_tty;
+remote_rdp_open (char *args, int from_tty)
{
+ int not_icebreaker;
+
if (!args)
error_no_arg ("serial port device name");
+ baud_rate = 9600;
+
target_preopen (from_tty);
- io = SERIAL_OPEN (args);
+ io = serial_open (args);
if (!io)
perror_with_name (args);
- SERIAL_RAW (io);
+ serial_raw (io);
+
+ rdp_init (1, from_tty);
- rdp_init ();
- rdp_info ();
if (from_tty)
{
- printf_unfiltered ("Remote RDP debugging using %s\n", args);
+ printf_unfiltered ("Remote RDP debugging using %s at %d baud\n", args, baud_rate);
}
+ rdp_info ();
+
+ /* Need to set up the vector interception state */
+ rdp_catch_vectors ();
+
+ /*
+ ** If it's an EmbeddedICE, we need to set the processor config.
+ ** Assume we can always have ARM7TDI...
+ */
+ send_rdp ("bw-SB", RDP_INFO, RDP_INFO_ICEBREAKER, ¬_icebreaker);
+ if (!not_icebreaker)
+ {
+ const char *CPU = "ARM7TDI";
+ int ICEversion;
+ int len = strlen (CPU);
+
+ send_rdp ("bbbbw-p-SWZ",
+ RDP_SELECT_CONFIG,
+ RDI_ConfigCPU, /* Aspect: set the CPU */
+ len, /* The number of bytes in the name */
+ RDI_MatchAny, /* We'll take whatever we get */
+ 0, /* We'll take whatever version's there */
+ CPU, len,
+ &ICEversion);
+ }
+
+ /* command line initialised on 'run' */
+
push_target (&remote_rdp_ops);
callback->init (callback);
registers_changed ();
stop_pc = read_pc ();
set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame, -1, 1);
}
/* Close out all files and local state before this target loses control. */
static void
-remote_rdp_close (quitting)
- int quitting;
+remote_rdp_close (int quitting)
{
callback->shutdown (callback);
- SERIAL_CLOSE (io);
+ if (io)
+ serial_close (io);
+ io = 0;
}
-/* Terminate the open connection to the remote debugger. */
-
-static void
-remote_rdp_detach (args, from_tty)
- char *args;
- int from_tty;
-{
- pop_target ();
-}
/* Resume execution of the target process. STEP says whether to single-step
or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
to the target, or zero for no signal. */
static void
-remote_rdp_resume (pid, step, siggnal)
- int pid, step;
- enum target_signal siggnal;
+remote_rdp_resume (ptid_t ptid, int step, enum target_signal siggnal)
{
if (step)
rdp_step ();
or -1 in case of error; store status through argument pointer STATUS,
just as `wait' would. */
-static int
-remote_rdp_wait (pid, status)
- int pid;
- struct target_waitstatus *status;
+static ptid_t
+remote_rdp_wait (ptid_t ptid, struct target_waitstatus *status)
{
switch (ds.rdi_stopped_status)
{
#endif
}
- return inferior_pid;
+ return inferior_ptid;
}
/* Get ready to modify the registers array. On machines which store
debugged. */
static void
-remote_rdp_prepare_to_store ()
+remote_rdp_prepare_to_store (void)
{
/* Do nothing, since we can store individual regs */
}
+/* Transfer LEN bytes between GDB address MYADDR and target address
+ MEMADDR. If WRITE is non-zero, transfer them to the target,
+ otherwise transfer them from the target. TARGET is unused.
+
+ Returns the number of bytes transferred. */
+
static int
-remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
- int write;
- struct target_ops *target; /* ignored */
+remote_rdp_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
+ int write, struct mem_attrib *attrib,
+ struct target_ops *target)
{
/* I infer from D Taylor's code that there's a limit on the amount
we can transfer in one chunk.. */
{"watchpoints for half-word writes supported", RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE},
{"watchpoints for word writes supported", RDP_INFO_ABOUT_BREAK_WORD_WRITE},
{"mask break/watch-points supported", RDP_INFO_ABOUT_BREAK_MASK},
- {"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
- {"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
+{"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
+{"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
{"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
{0}
};
static void
-dump_bits (t, info)
- struct yn *t;
- int info;
+dump_bits (struct yn *t, int info)
{
while (t->name)
{
}
static void
-remote_rdp_files_info (target)
- struct target_ops *target;
+remote_rdp_files_info (struct target_ops *target)
{
printf_filtered ("Target capabilities:\n");
dump_bits (stepinfo, ds.step_info);
}
+static void
+remote_rdp_create_inferior (char *exec_file, char *allargs, char **env)
+{
+ CORE_ADDR entry_point;
+
+ if (exec_file == 0 || exec_bfd == 0)
+ error ("No executable file specified.");
+
+ entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
+
+ remote_rdp_kill ();
+ remove_breakpoints ();
+ init_wait_for_inferior ();
+
+ /* This gives us a chance to set up the command line */
+ rdp_set_command_line (exec_file, allargs);
+
+ inferior_ptid = pid_to_ptid (42);
+ insert_breakpoints (); /* Needed to get correct instruction in cache */
+
+ /*
+ ** RDP targets don't provide any facility to set the top of memory,
+ ** so we don't bother to look for MEMSIZE in the environment.
+ */
+
+ /* Let's go! */
+ proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
+}
+
+/* Attach doesn't need to do anything */
+static void
+remote_rdp_attach (char *args, int from_tty)
+{
+ return;
+}
+
/* Define the target subroutine names */
-struct target_ops remote_rdp_ops =
+struct target_ops remote_rdp_ops;
+
+static void
+init_remote_rdp_ops (void)
{
- "rdp", /* to_shortname */
- /* to_longname */
- "Remote Target using the RDProtocol",
- /* to_doc */
- "Use a remote ARM system which uses the ARM Remote Debugging Protocol",
- remote_rdp_open, /* to_open */
- remote_rdp_close, /* to_close */
- NULL, /* to_attach */
- NULL, /* to_detach */
- remote_rdp_resume, /* to_resume */
- remote_rdp_wait, /* to_wait */
- remote_rdp_fetch_register, /* to_fetch_registers */
- remote_rdp_store_register, /* to_store_registers */
- remote_rdp_prepare_to_store, /* to_prepare_to_store */
- remote_rdp_xfer_inferior_memory, /* to_xfer_memory */
- remote_rdp_files_info, /* to_files_info */
- remote_rdp_insert_breakpoint, /* to_insert_breakpoint */
- remote_rdp_remove_breakpoint, /* to_remove_breakpoint */
- NULL, /* to_terminal_init */
- NULL, /* to_terminal_inferior */
- NULL, /* to_terminal_ours_for_output */
- NULL, /* to_terminal_ours */
- NULL, /* to_terminal_info */
- remote_rdp_kill, /* to_kill */
- generic_load, /* to_load */
- NULL, /* to_lookup_symbol */
- NULL, /* to_create_inferior */
- generic_mourn_inferior, /* to_mourn_inferior */
- 0, /* to_can_run */
- 0, /* to_notice_signals */
- 0, /* to_thread_alive */
- 0, /* to_stop */
- process_stratum, /* to_stratum */
- NULL, /* to_next */
- 1, /* to_has_all_memory */
- 1, /* to_has_memory */
- 1, /* to_has_stack */
- 1, /* to_has_registers */
- 1, /* to_has_execution */
- NULL, /* sections */
- NULL, /* sections_end */
- OPS_MAGIC, /* to_magic */
-};
+ remote_rdp_ops.to_shortname = "rdp";
+ remote_rdp_ops.to_longname = "Remote Target using the RDProtocol";
+ remote_rdp_ops.to_doc = "Use a remote ARM system which uses the ARM Remote Debugging Protocol";
+ remote_rdp_ops.to_open = remote_rdp_open;
+ remote_rdp_ops.to_close = remote_rdp_close;
+ remote_rdp_ops.to_attach = remote_rdp_attach;
+ remote_rdp_ops.to_post_attach = NULL;
+ remote_rdp_ops.to_require_attach = NULL;
+ remote_rdp_ops.to_detach = NULL;
+ remote_rdp_ops.to_require_detach = NULL;
+ remote_rdp_ops.to_resume = remote_rdp_resume;
+ remote_rdp_ops.to_wait = remote_rdp_wait;
+ remote_rdp_ops.to_post_wait = NULL;
+ remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
+ remote_rdp_ops.to_store_registers = remote_rdp_store_register;
+ remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store;
+ remote_rdp_ops.to_xfer_memory = remote_rdp_xfer_inferior_memory;
+ remote_rdp_ops.to_files_info = remote_rdp_files_info;
+ remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
+ remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
+ remote_rdp_ops.to_terminal_init = NULL;
+ remote_rdp_ops.to_terminal_inferior = NULL;
+ remote_rdp_ops.to_terminal_ours_for_output = NULL;
+ remote_rdp_ops.to_terminal_ours = NULL;
+ remote_rdp_ops.to_terminal_info = NULL;
+ remote_rdp_ops.to_kill = remote_rdp_kill;
+ remote_rdp_ops.to_load = generic_load;
+ remote_rdp_ops.to_lookup_symbol = NULL;
+ remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
+ remote_rdp_ops.to_post_startup_inferior = NULL;
+ remote_rdp_ops.to_acknowledge_created_inferior = NULL;
+ remote_rdp_ops.to_clone_and_follow_inferior = NULL;
+ remote_rdp_ops.to_post_follow_inferior_by_clone = NULL;
+ remote_rdp_ops.to_insert_fork_catchpoint = NULL;
+ remote_rdp_ops.to_remove_fork_catchpoint = NULL;
+ remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
+ remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
+ remote_rdp_ops.to_has_forked = NULL;
+ remote_rdp_ops.to_has_vforked = NULL;
+ remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
+ remote_rdp_ops.to_post_follow_vfork = NULL;
+ remote_rdp_ops.to_insert_exec_catchpoint = NULL;
+ remote_rdp_ops.to_remove_exec_catchpoint = NULL;
+ remote_rdp_ops.to_has_execd = NULL;
+ remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
+ remote_rdp_ops.to_has_exited = NULL;
+ remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
+ remote_rdp_ops.to_can_run = NULL;
+ remote_rdp_ops.to_notice_signals = 0;
+ remote_rdp_ops.to_thread_alive = 0;
+ remote_rdp_ops.to_stop = 0;
+ remote_rdp_ops.to_pid_to_exec_file = NULL;
+ remote_rdp_ops.to_stratum = process_stratum;
+ remote_rdp_ops.DONT_USE = NULL;
+ remote_rdp_ops.to_has_all_memory = 1;
+ remote_rdp_ops.to_has_memory = 1;
+ remote_rdp_ops.to_has_stack = 1;
+ remote_rdp_ops.to_has_registers = 1;
+ remote_rdp_ops.to_has_execution = 1;
+ remote_rdp_ops.to_sections = NULL;
+ remote_rdp_ops.to_sections_end = NULL;
+ remote_rdp_ops.to_magic = OPS_MAGIC;
+}
void
-_initialize_remote_rdp ()
+_initialize_remote_rdp (void)
{
+ init_remote_rdp_ops ();
add_target (&remote_rdp_ops);
}
projects / deliverable / binutils-gdb.git / blobdiff