/* Remote debugging for the ARM RDP interface.
|
/* Remote debugging for the ARM RDP interface.
|
Copyright 1994, 1995 Free Software Foundation, Inc.
|
Copyright 1994, 1995 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA.
|
Boston, MA 02111-1307, USA.
|
|
|
|
|
*/
|
*/
|
|
|
|
|
/*
|
/*
|
Much of this file (in particular the SWI stuff) is based on code by
|
Much of this file (in particular the SWI stuff) is based on code by
|
David Taylor (djt1000@uk.ac.cam.hermes).
|
David Taylor (djt1000@uk.ac.cam.hermes).
|
|
|
I hacked on and simplified it by removing a lot of sexy features he
|
I hacked on and simplified it by removing a lot of sexy features he
|
had added, and some of the (unix specific) workarounds he'd done
|
had added, and some of the (unix specific) workarounds he'd done
|
for other GDB problems - which if they still exist should be fixed
|
for other GDB problems - which if they still exist should be fixed
|
in GDB, not in a remote-foo thing . I also made it conform more to
|
in GDB, not in a remote-foo thing . I also made it conform more to
|
the doc I have; which may be wrong.
|
the doc I have; which may be wrong.
|
|
|
Steve Chamberlain (sac@cygnus.com).
|
Steve Chamberlain (sac@cygnus.com).
|
*/
|
*/
|
|
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include "value.h"
|
#include "value.h"
|
#include "callback.h"
|
#include "callback.h"
|
#include "command.h"
|
#include "command.h"
|
#include <ctype.h>
|
#include <ctype.h>
|
#include <fcntl.h>
|
#include <fcntl.h>
|
#include "symfile.h"
|
#include "symfile.h"
|
#include "remote-utils.h"
|
#include "remote-utils.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
|
|
#ifdef HAVE_TIME_H
|
#ifdef HAVE_TIME_H
|
#include <time.h>
|
#include <time.h>
|
#endif
|
#endif
|
|
|
extern struct target_ops remote_rdp_ops;
|
extern struct target_ops remote_rdp_ops;
|
static serial_t io;
|
static serial_t io;
|
static host_callback *callback = &default_callback;
|
static host_callback *callback = &default_callback;
|
|
|
struct
|
struct
|
{
|
{
|
int step_info;
|
int step_info;
|
int break_info;
|
int break_info;
|
int model_info;
|
int model_info;
|
int target_info;
|
int target_info;
|
int can_step;
|
int can_step;
|
char command_line[10];
|
char command_line[10];
|
int rdi_level;
|
int rdi_level;
|
int rdi_stopped_status;
|
int rdi_stopped_status;
|
}
|
}
|
ds;
|
ds;
|
|
|
|
|
|
|
/* Definitions for the RDP protocol. */
|
/* Definitions for the RDP protocol. */
|
|
|
#define RDP_MOUTHFULL (1<<6)
|
#define RDP_MOUTHFULL (1<<6)
|
#define FPU_COPRO_NUMBER 1
|
#define FPU_COPRO_NUMBER 1
|
|
|
#define RDP_OPEN 0
|
#define RDP_OPEN 0
|
#define RDP_OPEN_TYPE_COLD 0
|
#define RDP_OPEN_TYPE_COLD 0
|
#define RDP_OPEN_TYPE_WARM 1
|
#define RDP_OPEN_TYPE_WARM 1
|
#define RDP_OPEN_TYPE_BAUDRATE 2
|
#define RDP_OPEN_TYPE_BAUDRATE 2
|
|
|
#define RDP_OPEN_BAUDRATE_9600 1
|
#define RDP_OPEN_BAUDRATE_9600 1
|
#define RDP_OPEN_BAUDRATE_19200 2
|
#define RDP_OPEN_BAUDRATE_19200 2
|
#define RDP_OPEN_BAUDRATE_38400 3
|
#define RDP_OPEN_BAUDRATE_38400 3
|
|
|
#define RDP_OPEN_TYPE_RETURN_SEX (1<<3)
|
#define RDP_OPEN_TYPE_RETURN_SEX (1<<3)
|
|
|
#define RDP_CLOSE 1
|
#define RDP_CLOSE 1
|
|
|
#define RDP_MEM_READ 2
|
#define RDP_MEM_READ 2
|
|
|
#define RDP_MEM_WRITE 3
|
#define RDP_MEM_WRITE 3
|
|
|
#define RDP_CPU_READ 4
|
#define RDP_CPU_READ 4
|
#define RDP_CPU_WRITE 5
|
#define RDP_CPU_WRITE 5
|
#define RDP_CPU_READWRITE_MODE_CURRENT 255
|
#define RDP_CPU_READWRITE_MODE_CURRENT 255
|
#define RDP_CPU_READWRITE_MASK_PC (1<<16)
|
#define RDP_CPU_READWRITE_MASK_PC (1<<16)
|
#define RDP_CPU_READWRITE_MASK_CPSR (1<<17)
|
#define RDP_CPU_READWRITE_MASK_CPSR (1<<17)
|
#define RDP_CPU_READWRITE_MASK_SPSR (1<<18)
|
#define RDP_CPU_READWRITE_MASK_SPSR (1<<18)
|
|
|
#define RDP_COPRO_READ 6
|
#define RDP_COPRO_READ 6
|
#define RDP_COPRO_WRITE 7
|
#define RDP_COPRO_WRITE 7
|
#define RDP_FPU_READWRITE_MASK_FPS (1<<8)
|
#define RDP_FPU_READWRITE_MASK_FPS (1<<8)
|
|
|
#define RDP_SET_BREAK 0xa
|
#define RDP_SET_BREAK 0xa
|
#define RDP_SET_BREAK_TYPE_PC_EQUAL 0
|
#define RDP_SET_BREAK_TYPE_PC_EQUAL 0
|
#define RDP_SET_BREAK_TYPE_GET_HANDLE (0x10)
|
#define RDP_SET_BREAK_TYPE_GET_HANDLE (0x10)
|
|
|
#define RDP_CLEAR_BREAK 0xb
|
#define RDP_CLEAR_BREAK 0xb
|
|
|
#define RDP_EXEC 0x10
|
#define RDP_EXEC 0x10
|
#define RDP_EXEC_TYPE_SYNC 0
|
#define RDP_EXEC_TYPE_SYNC 0
|
|
|
#define RDP_STEP 0x11
|
#define RDP_STEP 0x11
|
|
|
#define RDP_INFO 0x12
|
#define RDP_INFO 0x12
|
#define RDP_INFO_ABOUT_STEP 2
|
#define RDP_INFO_ABOUT_STEP 2
|
#define RDP_INFO_ABOUT_STEP_GT_1 1
|
#define RDP_INFO_ABOUT_STEP_GT_1 1
|
#define RDP_INFO_ABOUT_STEP_TO_JMP 2
|
#define RDP_INFO_ABOUT_STEP_TO_JMP 2
|
#define RDP_INFO_ABOUT_STEP_1 4
|
#define RDP_INFO_ABOUT_STEP_1 4
|
#define RDP_INFO_ABOUT_TARGET 0
|
#define RDP_INFO_ABOUT_TARGET 0
|
#define RDP_INFO_ABOUT_BREAK 1
|
#define RDP_INFO_ABOUT_BREAK 1
|
#define RDP_INFO_ABOUT_BREAK_COMP 1
|
#define RDP_INFO_ABOUT_BREAK_COMP 1
|
#define RDP_INFO_ABOUT_BREAK_RANGE 2
|
#define RDP_INFO_ABOUT_BREAK_RANGE 2
|
#define RDP_INFO_ABOUT_BREAK_BYTE_READ 4
|
#define RDP_INFO_ABOUT_BREAK_BYTE_READ 4
|
#define RDP_INFO_ABOUT_BREAK_HALFWORD_READ 8
|
#define RDP_INFO_ABOUT_BREAK_HALFWORD_READ 8
|
#define RDP_INFO_ABOUT_BREAK_WORD_READ (1<<4)
|
#define RDP_INFO_ABOUT_BREAK_WORD_READ (1<<4)
|
#define RDP_INFO_ABOUT_BREAK_BYTE_WRITE (1<<5)
|
#define RDP_INFO_ABOUT_BREAK_BYTE_WRITE (1<<5)
|
#define RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE (1<<6)
|
#define RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE (1<<6)
|
#define RDP_INFO_ABOUT_BREAK_WORD_WRITE (1<<7)
|
#define RDP_INFO_ABOUT_BREAK_WORD_WRITE (1<<7)
|
#define RDP_INFO_ABOUT_BREAK_MASK (1<<8)
|
#define RDP_INFO_ABOUT_BREAK_MASK (1<<8)
|
#define RDP_INFO_ABOUT_BREAK_THREAD_BREAK (1<<9)
|
#define RDP_INFO_ABOUT_BREAK_THREAD_BREAK (1<<9)
|
#define RDP_INFO_ABOUT_BREAK_THREAD_WATCH (1<<10)
|
#define RDP_INFO_ABOUT_BREAK_THREAD_WATCH (1<<10)
|
#define RDP_INFO_ABOUT_BREAK_COND (1<<11)
|
#define RDP_INFO_ABOUT_BREAK_COND (1<<11)
|
#define RDP_INFO_VECTOR_CATCH (0x180)
|
#define RDP_INFO_VECTOR_CATCH (0x180)
|
#define RDP_INFO_ICEBREAKER (7)
|
#define RDP_INFO_ICEBREAKER (7)
|
#define RDP_INFO_SET_CMDLINE (0x300)
|
#define RDP_INFO_SET_CMDLINE (0x300)
|
|
|
#define RDP_SELECT_CONFIG (0x16)
|
#define RDP_SELECT_CONFIG (0x16)
|
#define RDI_ConfigCPU 0
|
#define RDI_ConfigCPU 0
|
#define RDI_ConfigSystem 1
|
#define RDI_ConfigSystem 1
|
#define RDI_MatchAny 0
|
#define RDI_MatchAny 0
|
#define RDI_MatchExactly 1
|
#define RDI_MatchExactly 1
|
#define RDI_MatchNoEarlier 2
|
#define RDI_MatchNoEarlier 2
|
|
|
#define RDP_RESET 0x7f
|
#define RDP_RESET 0x7f
|
|
|
/* Returns from RDP */
|
/* Returns from RDP */
|
#define RDP_RES_STOPPED 0x20
|
#define RDP_RES_STOPPED 0x20
|
#define RDP_RES_SWI 0x21
|
#define RDP_RES_SWI 0x21
|
#define RDP_RES_FATAL 0x5e
|
#define RDP_RES_FATAL 0x5e
|
#define RDP_RES_VALUE 0x5f
|
#define RDP_RES_VALUE 0x5f
|
#define RDP_RES_VALUE_LITTLE_ENDIAN 240
|
#define RDP_RES_VALUE_LITTLE_ENDIAN 240
|
#define RDP_RES_VALUE_BIG_ENDIAN 241
|
#define RDP_RES_VALUE_BIG_ENDIAN 241
|
#define RDP_RES_RESET 0x7f
|
#define RDP_RES_RESET 0x7f
|
#define RDP_RES_AT_BREAKPOINT 143
|
#define RDP_RES_AT_BREAKPOINT 143
|
#define RDP_RES_IDUNNO 0xe6
|
#define RDP_RES_IDUNNO 0xe6
|
#define RDP_OSOpReply 0x13
|
#define RDP_OSOpReply 0x13
|
#define RDP_OSOpWord 2
|
#define RDP_OSOpWord 2
|
#define RDP_OSOpNothing 0
|
#define RDP_OSOpNothing 0
|
|
|
static int timeout = 2;
|
static int timeout = 2;
|
|
|
static char *commandline = NULL;
|
static char *commandline = NULL;
|
|
|
static int
|
static int
|
remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
|
remote_rdp_xfer_inferior_memory PARAMS ((CORE_ADDR memaddr,
|
char *myaddr,
|
char *myaddr,
|
int len,
|
int len,
|
int write,
|
int write,
|
struct target_ops * target));
|
struct target_ops * target));
|
|
|
|
|
/* Stuff for talking to the serial layer. */
|
/* Stuff for talking to the serial layer. */
|
|
|
static unsigned char
|
static unsigned char
|
get_byte ()
|
get_byte ()
|
{
|
{
|
int c = SERIAL_READCHAR (io, timeout);
|
int c = SERIAL_READCHAR (io, timeout);
|
|
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", c);
|
|
|
if (c == SERIAL_TIMEOUT)
|
if (c == SERIAL_TIMEOUT)
|
{
|
{
|
if (timeout == 0)
|
if (timeout == 0)
|
return (unsigned char) c;
|
return (unsigned char) c;
|
|
|
error ("Timeout reading from remote_system");
|
error ("Timeout reading from remote_system");
|
}
|
}
|
|
|
return c;
|
return c;
|
}
|
}
|
|
|
/* Note that the target always speaks little-endian to us,
|
/* Note that the target always speaks little-endian to us,
|
even if it's a big endian machine. */
|
even if it's a big endian machine. */
|
static unsigned int
|
static unsigned int
|
get_word ()
|
get_word ()
|
{
|
{
|
unsigned int val = 0;
|
unsigned int val = 0;
|
unsigned int c;
|
unsigned int c;
|
int n;
|
int n;
|
for (n = 0; n < 4; n++)
|
for (n = 0; n < 4; n++)
|
{
|
{
|
c = get_byte ();
|
c = get_byte ();
|
val |= c << (n * 8);
|
val |= c << (n * 8);
|
}
|
}
|
return val;
|
return val;
|
}
|
}
|
|
|
static void
|
static void
|
put_byte (val)
|
put_byte (val)
|
char val;
|
char val;
|
{
|
{
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
|
fprintf_unfiltered (gdb_stdlog, "(%02x)\n", val);
|
SERIAL_WRITE (io, &val, 1);
|
SERIAL_WRITE (io, &val, 1);
|
}
|
}
|
|
|
static void
|
static void
|
put_word (val)
|
put_word (val)
|
int val;
|
int val;
|
{
|
{
|
/* We always send in little endian */
|
/* We always send in little endian */
|
unsigned char b[4];
|
unsigned char b[4];
|
b[0] = val;
|
b[0] = val;
|
b[1] = val >> 8;
|
b[1] = val >> 8;
|
b[2] = val >> 16;
|
b[2] = val >> 16;
|
b[3] = val >> 24;
|
b[3] = val >> 24;
|
|
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
|
fprintf_unfiltered (gdb_stdlog, "(%04x)", val);
|
|
|
SERIAL_WRITE (io, b, 4);
|
SERIAL_WRITE (io, b, 4);
|
}
|
}
|
|
|
|
|
|
|
/* Stuff for talking to the RDP layer. */
|
/* 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
|
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,
|
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
|
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.
|
reliably at 9600 than wait forever for a possible 19200 connection.
|
|
|
*/
|
*/
|
static void
|
static void
|
rdp_init (cold, tty)
|
rdp_init (cold, tty)
|
int cold;
|
int cold;
|
int tty;
|
int tty;
|
{
|
{
|
int sync = 0;
|
int sync = 0;
|
int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
|
int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
|
int baudtry = 9600;
|
int baudtry = 9600;
|
|
|
time_t now = time (0);
|
time_t now = time (0);
|
time_t stop_time = now + 10; /* Try and sync for 10 seconds, then give up */
|
time_t stop_time = now + 10; /* Try and sync for 10 seconds, then give up */
|
|
|
|
|
while (time (0) < stop_time && !sync)
|
while (time (0) < stop_time && !sync)
|
{
|
{
|
int restype;
|
int restype;
|
QUIT;
|
QUIT;
|
|
|
SERIAL_FLUSH_INPUT (io);
|
SERIAL_FLUSH_INPUT (io);
|
SERIAL_FLUSH_OUTPUT (io);
|
SERIAL_FLUSH_OUTPUT (io);
|
|
|
if (tty)
|
if (tty)
|
printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
|
printf_unfiltered ("Trying to connect at %d baud.\n", baudtry);
|
|
|
/*
|
/*
|
** It seems necessary to reset an EmbeddedICE to get it going.
|
** It seems necessary to reset an EmbeddedICE to get it going.
|
** This has the side benefit of displaying the startup banner.
|
** This has the side benefit of displaying the startup banner.
|
*/
|
*/
|
if (cold)
|
if (cold)
|
{
|
{
|
put_byte (RDP_RESET);
|
put_byte (RDP_RESET);
|
while ((restype = SERIAL_READCHAR (io, 1)) > 0)
|
while ((restype = SERIAL_READCHAR (io, 1)) > 0)
|
{
|
{
|
switch (restype)
|
switch (restype)
|
{
|
{
|
case SERIAL_TIMEOUT:
|
case SERIAL_TIMEOUT:
|
break;
|
break;
|
case RDP_RESET:
|
case RDP_RESET:
|
/* Sent at start of reset process: ignore */
|
/* Sent at start of reset process: ignore */
|
break;
|
break;
|
default:
|
default:
|
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
|
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (restype == 0)
|
if (restype == 0)
|
{
|
{
|
/* Got end-of-banner mark */
|
/* Got end-of-banner mark */
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
}
|
}
|
}
|
}
|
|
|
put_byte (RDP_OPEN);
|
put_byte (RDP_OPEN);
|
|
|
put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
|
put_byte (type | RDP_OPEN_TYPE_RETURN_SEX);
|
put_word (0);
|
put_word (0);
|
|
|
while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
|
while (!sync && (restype = SERIAL_READCHAR (io, 1)) > 0)
|
{
|
{
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", restype);
|
|
|
switch (restype)
|
switch (restype)
|
{
|
{
|
case SERIAL_TIMEOUT:
|
case SERIAL_TIMEOUT:
|
break;
|
break;
|
|
|
case RDP_RESET:
|
case RDP_RESET:
|
while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
|
while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
|
;
|
;
|
do
|
do
|
{
|
{
|
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
|
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
|
}
|
}
|
while ((restype = SERIAL_READCHAR (io, 1)) > 0);
|
while ((restype = SERIAL_READCHAR (io, 1)) > 0);
|
|
|
if (tty)
|
if (tty)
|
{
|
{
|
printf_unfiltered ("\nThe board has sent notification that it was reset.\n");
|
printf_unfiltered ("\nThe board has sent notification that it was reset.\n");
|
printf_unfiltered ("Waiting for it to settle down...\n");
|
printf_unfiltered ("Waiting for it to settle down...\n");
|
}
|
}
|
sleep (3);
|
sleep (3);
|
if (tty)
|
if (tty)
|
printf_unfiltered ("\nTrying again.\n");
|
printf_unfiltered ("\nTrying again.\n");
|
cold = 0;
|
cold = 0;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
|
|
case RDP_RES_VALUE:
|
case RDP_RES_VALUE:
|
{
|
{
|
int resval = SERIAL_READCHAR (io, 1);
|
int resval = SERIAL_READCHAR (io, 1);
|
|
|
if (remote_debug)
|
if (remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
|
fprintf_unfiltered (gdb_stdlog, "[%02x]\n", resval);
|
|
|
switch (resval)
|
switch (resval)
|
{
|
{
|
case SERIAL_TIMEOUT:
|
case SERIAL_TIMEOUT:
|
break;
|
break;
|
case RDP_RES_VALUE_LITTLE_ENDIAN:
|
case RDP_RES_VALUE_LITTLE_ENDIAN:
|
target_byte_order = LITTLE_ENDIAN;
|
target_byte_order = LITTLE_ENDIAN;
|
sync = 1;
|
sync = 1;
|
break;
|
break;
|
case RDP_RES_VALUE_BIG_ENDIAN:
|
case RDP_RES_VALUE_BIG_ENDIAN:
|
target_byte_order = BIG_ENDIAN;
|
target_byte_order = BIG_ENDIAN;
|
sync = 1;
|
sync = 1;
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (!sync)
|
if (!sync)
|
{
|
{
|
error ("Couldn't reset the board, try pressing the reset button");
|
error ("Couldn't reset the board, try pressing the reset button");
|
}
|
}
|
}
|
}
|
|
|
|
|
void
|
void
|
send_rdp (char *template,...)
|
send_rdp (char *template,...)
|
{
|
{
|
char buf[200];
|
char buf[200];
|
char *dst = buf;
|
char *dst = buf;
|
va_list alist;
|
va_list alist;
|
va_start (alist, template);
|
va_start (alist, template);
|
|
|
while (*template)
|
while (*template)
|
{
|
{
|
unsigned int val;
|
unsigned int val;
|
int *pi;
|
int *pi;
|
int *pstat;
|
int *pstat;
|
char *pc;
|
char *pc;
|
int i;
|
int i;
|
switch (*template++)
|
switch (*template++)
|
{
|
{
|
case 'b':
|
case 'b':
|
val = va_arg (alist, int);
|
val = va_arg (alist, int);
|
*dst++ = val;
|
*dst++ = val;
|
break;
|
break;
|
case 'w':
|
case 'w':
|
val = va_arg (alist, int);
|
val = va_arg (alist, int);
|
*dst++ = val;
|
*dst++ = val;
|
*dst++ = val >> 8;
|
*dst++ = val >> 8;
|
*dst++ = val >> 16;
|
*dst++ = val >> 16;
|
*dst++ = val >> 24;
|
*dst++ = val >> 24;
|
break;
|
break;
|
case 'S':
|
case 'S':
|
val = get_byte ();
|
val = get_byte ();
|
if (val != RDP_RES_VALUE)
|
if (val != RDP_RES_VALUE)
|
{
|
{
|
printf_unfiltered ("got bad res value of %d, %x\n", val, val);
|
printf_unfiltered ("got bad res value of %d, %x\n", val, val);
|
}
|
}
|
break;
|
break;
|
case 'V':
|
case 'V':
|
pstat = va_arg (alist, int *);
|
pstat = va_arg (alist, int *);
|
pi = va_arg (alist, int *);
|
pi = va_arg (alist, int *);
|
|
|
*pstat = get_byte ();
|
*pstat = get_byte ();
|
/* Check the result was zero, if not read the syndrome */
|
/* Check the result was zero, if not read the syndrome */
|
if (*pstat)
|
if (*pstat)
|
{
|
{
|
*pi = get_word ();
|
*pi = get_word ();
|
}
|
}
|
break;
|
break;
|
case 'Z':
|
case 'Z':
|
/* Check the result code */
|
/* Check the result code */
|
switch (get_byte ())
|
switch (get_byte ())
|
{
|
{
|
case 0:
|
case 0:
|
/* Success */
|
/* Success */
|
break;
|
break;
|
case 253:
|
case 253:
|
/* Target can't do it; never mind */
|
/* Target can't do it; never mind */
|
printf_unfiltered ("RDP: Insufficient privilege\n");
|
printf_unfiltered ("RDP: Insufficient privilege\n");
|
return;
|
return;
|
case 254:
|
case 254:
|
/* Target can't do it; never mind */
|
/* Target can't do it; never mind */
|
printf_unfiltered ("RDP: Unimplemented message\n");
|
printf_unfiltered ("RDP: Unimplemented message\n");
|
return;
|
return;
|
case 255:
|
case 255:
|
error ("Command garbled");
|
error ("Command garbled");
|
break;
|
break;
|
default:
|
default:
|
error ("Corrupt reply from target");
|
error ("Corrupt reply from target");
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
case 'W':
|
case 'W':
|
/* Read a word from the target */
|
/* Read a word from the target */
|
pi = va_arg (alist, int *);
|
pi = va_arg (alist, int *);
|
*pi = get_word ();
|
*pi = get_word ();
|
break;
|
break;
|
case 'P':
|
case 'P':
|
/* Read in some bytes from the target. */
|
/* Read in some bytes from the target. */
|
pc = va_arg (alist, char *);
|
pc = va_arg (alist, char *);
|
val = va_arg (alist, int);
|
val = va_arg (alist, int);
|
for (i = 0; i < val; i++)
|
for (i = 0; i < val; i++)
|
{
|
{
|
pc[i] = get_byte ();
|
pc[i] = get_byte ();
|
}
|
}
|
break;
|
break;
|
case 'p':
|
case 'p':
|
/* send what's being pointed at */
|
/* send what's being pointed at */
|
pc = va_arg (alist, char *);
|
pc = va_arg (alist, char *);
|
val = va_arg (alist, int);
|
val = va_arg (alist, int);
|
dst = buf;
|
dst = buf;
|
SERIAL_WRITE (io, pc, val);
|
SERIAL_WRITE (io, pc, val);
|
break;
|
break;
|
case '-':
|
case '-':
|
/* Send whats in the queue */
|
/* Send whats in the queue */
|
if (dst != buf)
|
if (dst != buf)
|
{
|
{
|
SERIAL_WRITE (io, buf, dst - buf);
|
SERIAL_WRITE (io, buf, dst - buf);
|
dst = buf;
|
dst = buf;
|
}
|
}
|
break;
|
break;
|
case 'B':
|
case 'B':
|
pi = va_arg (alist, int *);
|
pi = va_arg (alist, int *);
|
*pi = get_byte ();
|
*pi = get_byte ();
|
break;
|
break;
|
default:
|
default:
|
abort ();
|
abort ();
|
}
|
}
|
}
|
}
|
va_end (alist);
|
va_end (alist);
|
|
|
if (dst != buf)
|
if (dst != buf)
|
abort ();
|
abort ();
|
}
|
}
|
|
|
|
|
static int
|
static int
|
rdp_write (memaddr, buf, len)
|
rdp_write (memaddr, buf, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *buf;
|
char *buf;
|
int len;
|
int len;
|
{
|
{
|
int res;
|
int res;
|
int val;
|
int val;
|
|
|
send_rdp ("bww-p-SV", RDP_MEM_WRITE, memaddr, len, buf, len, &res, &val);
|
send_rdp ("bww-p-SV", RDP_MEM_WRITE, memaddr, len, buf, len, &res, &val);
|
|
|
if (res)
|
if (res)
|
{
|
{
|
return val;
|
return val;
|
}
|
}
|
return len;
|
return len;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
rdp_read (memaddr, buf, len)
|
rdp_read (memaddr, buf, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *buf;
|
char *buf;
|
int len;
|
int len;
|
{
|
{
|
int res;
|
int res;
|
int val;
|
int val;
|
send_rdp ("bww-S-P-V",
|
send_rdp ("bww-S-P-V",
|
RDP_MEM_READ, memaddr, len,
|
RDP_MEM_READ, memaddr, len,
|
buf, len,
|
buf, len,
|
&res, &val);
|
&res, &val);
|
if (res)
|
if (res)
|
{
|
{
|
return val;
|
return val;
|
}
|
}
|
return len;
|
return len;
|
}
|
}
|
|
|
static void
|
static void
|
rdp_fetch_one_register (mask, buf)
|
rdp_fetch_one_register (mask, buf)
|
int mask;
|
int mask;
|
char *buf;
|
char *buf;
|
{
|
{
|
int val;
|
int val;
|
send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
|
send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
|
store_signed_integer (buf, 4, val);
|
store_signed_integer (buf, 4, val);
|
}
|
}
|
|
|
static void
|
static void
|
rdp_fetch_one_fpu_register (mask, buf)
|
rdp_fetch_one_fpu_register (mask, buf)
|
int mask;
|
int mask;
|
char *buf;
|
char *buf;
|
{
|
{
|
#if 0
|
#if 0
|
/* !!! Since the PIE board doesn't work as documented,
|
/* !!! Since the PIE board doesn't work as documented,
|
and it doesn't have FPU hardware anyway and since it
|
and it doesn't have FPU hardware anyway and since it
|
slows everything down, I've disabled this. */
|
slows everything down, I've disabled this. */
|
int val;
|
int val;
|
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
{
|
{
|
/* this guy is only a word */
|
/* this guy is only a word */
|
send_rdp ("bbw-SWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, &val);
|
send_rdp ("bbw-SWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, &val);
|
store_signed_integer (buf, 4, val);
|
store_signed_integer (buf, 4, val);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* There are 12 bytes long
|
/* There are 12 bytes long
|
!! fixme about endianness
|
!! fixme about endianness
|
*/
|
*/
|
int dummy; /* I've seen these come back as four words !! */
|
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);
|
send_rdp ("bbw-SWWWWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, buf + 0, buf + 4, buf + 8, &dummy);
|
}
|
}
|
#endif
|
#endif
|
memset (buf, 0, MAX_REGISTER_RAW_SIZE);
|
memset (buf, 0, MAX_REGISTER_RAW_SIZE);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_store_one_register (mask, buf)
|
rdp_store_one_register (mask, buf)
|
int mask;
|
int mask;
|
char *buf;
|
char *buf;
|
{
|
{
|
int val = extract_unsigned_integer (buf, 4);
|
int val = extract_unsigned_integer (buf, 4);
|
|
|
send_rdp ("bbww-SZ",
|
send_rdp ("bbww-SZ",
|
RDP_CPU_WRITE, RDP_CPU_READWRITE_MODE_CURRENT, mask, val);
|
RDP_CPU_WRITE, RDP_CPU_READWRITE_MODE_CURRENT, mask, val);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_store_one_fpu_register (mask, buf)
|
rdp_store_one_fpu_register (mask, buf)
|
int mask;
|
int mask;
|
char *buf;
|
char *buf;
|
{
|
{
|
#if 0
|
#if 0
|
/* See comment in fetch_one_fpu_register */
|
/* See comment in fetch_one_fpu_register */
|
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
{
|
{
|
int val = extract_unsigned_integer (buf, 4);
|
int val = extract_unsigned_integer (buf, 4);
|
/* this guy is only a word */
|
/* this guy is only a word */
|
send_rdp ("bbww-SZ", RDP_COPRO_WRITE,
|
send_rdp ("bbww-SZ", RDP_COPRO_WRITE,
|
FPU_COPRO_NUMBER,
|
FPU_COPRO_NUMBER,
|
mask, val);
|
mask, val);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* There are 12 bytes long
|
/* There are 12 bytes long
|
!! fixme about endianness
|
!! fixme about endianness
|
*/
|
*/
|
int dummy = 0;
|
int dummy = 0;
|
/* I've seen these come as four words, not the three advertized !! */
|
/* I've seen these come as four words, not the three advertized !! */
|
printf ("Sending mask %x\n", mask);
|
printf ("Sending mask %x\n", mask);
|
send_rdp ("bbwwwww-SZ",
|
send_rdp ("bbwwwww-SZ",
|
RDP_COPRO_WRITE,
|
RDP_COPRO_WRITE,
|
FPU_COPRO_NUMBER,
|
FPU_COPRO_NUMBER,
|
mask,
|
mask,
|
*(int *) (buf + 0),
|
*(int *) (buf + 0),
|
*(int *) (buf + 4),
|
*(int *) (buf + 4),
|
*(int *) (buf + 8),
|
*(int *) (buf + 8),
|
0);
|
0);
|
|
|
printf ("done mask %x\n", mask);
|
printf ("done mask %x\n", mask);
|
}
|
}
|
#endif
|
#endif
|
}
|
}
|
|
|
|
|
/* Convert between GDB requests and the RDP layer. */
|
/* Convert between GDB requests and the RDP layer. */
|
|
|
static void
|
static void
|
remote_rdp_fetch_register (regno)
|
remote_rdp_fetch_register (regno)
|
int regno;
|
int regno;
|
{
|
{
|
if (regno == -1)
|
if (regno == -1)
|
{
|
{
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
remote_rdp_fetch_register (regno);
|
remote_rdp_fetch_register (regno);
|
}
|
}
|
else
|
else
|
{
|
{
|
char buf[MAX_REGISTER_RAW_SIZE];
|
char buf[MAX_REGISTER_RAW_SIZE];
|
if (regno < 15)
|
if (regno < 15)
|
rdp_fetch_one_register (1 << regno, buf);
|
rdp_fetch_one_register (1 << regno, buf);
|
else if (regno == PC_REGNUM)
|
else if (regno == PC_REGNUM)
|
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
|
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
|
else if (regno == PS_REGNUM)
|
else if (regno == PS_REGNUM)
|
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
|
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
|
else if (regno == FPS_REGNUM)
|
else if (regno == FPS_REGNUM)
|
rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
|
rdp_fetch_one_fpu_register (RDP_FPU_READWRITE_MASK_FPS, buf);
|
else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
|
else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
|
rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
|
rdp_fetch_one_fpu_register (1 << (regno - F0_REGNUM), buf);
|
else
|
else
|
{
|
{
|
printf ("Help me with fetch reg %d\n", regno);
|
printf ("Help me with fetch reg %d\n", regno);
|
}
|
}
|
supply_register (regno, buf);
|
supply_register (regno, buf);
|
}
|
}
|
}
|
}
|
|
|
|
|
static void
|
static void
|
remote_rdp_store_register (regno)
|
remote_rdp_store_register (regno)
|
int regno;
|
int regno;
|
{
|
{
|
if (regno == -1)
|
if (regno == -1)
|
{
|
{
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
remote_rdp_store_register (regno);
|
remote_rdp_store_register (regno);
|
}
|
}
|
else
|
else
|
{
|
{
|
char tmp[MAX_REGISTER_RAW_SIZE];
|
char tmp[MAX_REGISTER_RAW_SIZE];
|
read_register_gen (regno, tmp);
|
read_register_gen (regno, tmp);
|
if (regno < 15)
|
if (regno < 15)
|
rdp_store_one_register (1 << regno, tmp);
|
rdp_store_one_register (1 << regno, tmp);
|
else if (regno == PC_REGNUM)
|
else if (regno == PC_REGNUM)
|
rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
|
rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
|
else if (regno == PS_REGNUM)
|
else if (regno == PS_REGNUM)
|
rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
|
rdp_store_one_register (RDP_CPU_READWRITE_MASK_CPSR, tmp);
|
else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
|
else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
|
rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
|
rdp_store_one_fpu_register (1 << (regno - F0_REGNUM), tmp);
|
else
|
else
|
{
|
{
|
printf ("Help me with reg %d\n", regno);
|
printf ("Help me with reg %d\n", regno);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
remote_rdp_kill ()
|
remote_rdp_kill ()
|
{
|
{
|
callback->shutdown (callback);
|
callback->shutdown (callback);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_info ()
|
rdp_info ()
|
{
|
{
|
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
|
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
|
&ds.step_info);
|
&ds.step_info);
|
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_BREAK,
|
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_BREAK,
|
&ds.break_info);
|
&ds.break_info);
|
send_rdp ("bw-S-WW-Z", RDP_INFO, RDP_INFO_ABOUT_TARGET,
|
send_rdp ("bw-S-WW-Z", RDP_INFO, RDP_INFO_ABOUT_TARGET,
|
&ds.target_info,
|
&ds.target_info,
|
&ds.model_info);
|
&ds.model_info);
|
|
|
ds.can_step = ds.step_info & RDP_INFO_ABOUT_STEP_1;
|
ds.can_step = ds.step_info & RDP_INFO_ABOUT_STEP_1;
|
|
|
ds.rdi_level = (ds.target_info >> 5) & 3;
|
ds.rdi_level = (ds.target_info >> 5) & 3;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_execute_start ()
|
rdp_execute_start ()
|
{
|
{
|
/* Start it off, but don't wait for it */
|
/* Start it off, but don't wait for it */
|
send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
|
send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_set_command_line (command, args)
|
rdp_set_command_line (command, args)
|
char *command;
|
char *command;
|
char *args;
|
char *args;
|
{
|
{
|
/*
|
/*
|
** We could use RDP_INFO_SET_CMDLINE to send this, but EmbeddedICE systems
|
** 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.
|
** 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
|
** Instead, just keep a copy, and send it when the target does a SWI_GetEnv
|
*/
|
*/
|
|
|
if (commandline != NULL)
|
if (commandline != NULL)
|
free (commandline);
|
free (commandline);
|
|
|
commandline = malloc (strlen (command) + strlen (args) + 2);
|
commandline = malloc (strlen (command) + strlen (args) + 2);
|
if (commandline != NULL)
|
if (commandline != NULL)
|
{
|
{
|
strcpy (commandline, command);
|
strcpy (commandline, command);
|
strcat (commandline, " ");
|
strcat (commandline, " ");
|
strcat (commandline, args);
|
strcat (commandline, args);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
rdp_catch_vectors ()
|
rdp_catch_vectors ()
|
{
|
{
|
/*
|
/*
|
** We want the target monitor to intercept the abort vectors
|
** We want the target monitor to intercept the abort vectors
|
** i.e. stop the program if any of these are used.
|
** i.e. stop the program if any of these are used.
|
*/
|
*/
|
send_rdp ("bww-SZ", RDP_INFO, RDP_INFO_VECTOR_CATCH,
|
send_rdp ("bww-SZ", RDP_INFO, RDP_INFO_VECTOR_CATCH,
|
/*
|
/*
|
** Specify a bitmask including
|
** Specify a bitmask including
|
** the reset vector
|
** the reset vector
|
** the undefined instruction vector
|
** the undefined instruction vector
|
** the prefetch abort vector
|
** the prefetch abort vector
|
** the data abort vector
|
** the data abort vector
|
** the address exception vector
|
** the address exception vector
|
*/
|
*/
|
(1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5)
|
(1 << 0) | (1 << 1) | (1 << 3) | (1 << 4) | (1 << 5)
|
);
|
);
|
}
|
}
|
|
|
|
|
|
|
#define a_byte 1
|
#define a_byte 1
|
#define a_word 2
|
#define a_word 2
|
#define a_string 3
|
#define a_string 3
|
|
|
|
|
typedef struct
|
typedef struct
|
{
|
{
|
CORE_ADDR n;
|
CORE_ADDR n;
|
const char *s;
|
const char *s;
|
}
|
}
|
argsin;
|
argsin;
|
|
|
#define ABYTE 1
|
#define ABYTE 1
|
#define AWORD 2
|
#define AWORD 2
|
#define ASTRING 3
|
#define ASTRING 3
|
#define ADDRLEN 4
|
#define ADDRLEN 4
|
|
|
#define SWI_WriteC 0x0
|
#define SWI_WriteC 0x0
|
#define SWI_Write0 0x2
|
#define SWI_Write0 0x2
|
#define SWI_ReadC 0x4
|
#define SWI_ReadC 0x4
|
#define SWI_CLI 0x5
|
#define SWI_CLI 0x5
|
#define SWI_GetEnv 0x10
|
#define SWI_GetEnv 0x10
|
#define SWI_Exit 0x11
|
#define SWI_Exit 0x11
|
#define SWI_EnterOS 0x16
|
#define SWI_EnterOS 0x16
|
|
|
#define SWI_GetErrno 0x60
|
#define SWI_GetErrno 0x60
|
#define SWI_Clock 0x61
|
#define SWI_Clock 0x61
|
|
|
#define SWI_Time 0x63
|
#define SWI_Time 0x63
|
#define SWI_Remove 0x64
|
#define SWI_Remove 0x64
|
#define SWI_Rename 0x65
|
#define SWI_Rename 0x65
|
#define SWI_Open 0x66
|
#define SWI_Open 0x66
|
|
|
#define SWI_Close 0x68
|
#define SWI_Close 0x68
|
#define SWI_Write 0x69
|
#define SWI_Write 0x69
|
#define SWI_Read 0x6a
|
#define SWI_Read 0x6a
|
#define SWI_Seek 0x6b
|
#define SWI_Seek 0x6b
|
#define SWI_Flen 0x6c
|
#define SWI_Flen 0x6c
|
|
|
#define SWI_IsTTY 0x6e
|
#define SWI_IsTTY 0x6e
|
#define SWI_TmpNam 0x6f
|
#define SWI_TmpNam 0x6f
|
#define SWI_InstallHandler 0x70
|
#define SWI_InstallHandler 0x70
|
#define SWI_GenerateError 0x71
|
#define SWI_GenerateError 0x71
|
|
|
|
|
#ifndef O_BINARY
|
#ifndef O_BINARY
|
#define O_BINARY 0
|
#define O_BINARY 0
|
#endif
|
#endif
|
|
|
static int translate_open_mode[] =
|
static int translate_open_mode[] =
|
{
|
{
|
O_RDONLY, /* "r" */
|
O_RDONLY, /* "r" */
|
O_RDONLY + O_BINARY, /* "rb" */
|
O_RDONLY + O_BINARY, /* "rb" */
|
O_RDWR, /* "r+" */
|
O_RDWR, /* "r+" */
|
O_RDWR + O_BINARY, /* "r+b" */
|
O_RDWR + O_BINARY, /* "r+b" */
|
O_WRONLY + O_CREAT + O_TRUNC, /* "w" */
|
O_WRONLY + O_CREAT + O_TRUNC, /* "w" */
|
O_WRONLY + O_BINARY + O_CREAT + O_TRUNC, /* "wb" */
|
O_WRONLY + O_BINARY + O_CREAT + O_TRUNC, /* "wb" */
|
O_RDWR + O_CREAT + O_TRUNC, /* "w+" */
|
O_RDWR + O_CREAT + O_TRUNC, /* "w+" */
|
O_RDWR + O_BINARY + O_CREAT + O_TRUNC, /* "w+b" */
|
O_RDWR + O_BINARY + O_CREAT + O_TRUNC, /* "w+b" */
|
O_WRONLY + O_APPEND + O_CREAT, /* "a" */
|
O_WRONLY + O_APPEND + O_CREAT, /* "a" */
|
O_WRONLY + O_BINARY + O_APPEND + O_CREAT, /* "ab" */
|
O_WRONLY + O_BINARY + O_APPEND + O_CREAT, /* "ab" */
|
O_RDWR + O_APPEND + O_CREAT, /* "a+" */
|
O_RDWR + O_APPEND + O_CREAT, /* "a+" */
|
O_RDWR + O_BINARY + O_APPEND + O_CREAT /* "a+b" */
|
O_RDWR + O_BINARY + O_APPEND + O_CREAT /* "a+b" */
|
};
|
};
|
|
|
static int
|
static int
|
exec_swi (swi, args)
|
exec_swi (swi, args)
|
int swi;
|
int swi;
|
argsin *args;
|
argsin *args;
|
{
|
{
|
int i;
|
int i;
|
char c;
|
char c;
|
switch (swi)
|
switch (swi)
|
{
|
{
|
case SWI_WriteC:
|
case SWI_WriteC:
|
callback->write_stdout (callback, &c, 1);
|
callback->write_stdout (callback, &c, 1);
|
return 0;
|
return 0;
|
case SWI_Write0:
|
case SWI_Write0:
|
for (i = 0; i < args->n; i++)
|
for (i = 0; i < args->n; i++)
|
callback->write_stdout (callback, args->s, strlen (args->s));
|
callback->write_stdout (callback, args->s, strlen (args->s));
|
return 0;
|
return 0;
|
case SWI_ReadC:
|
case SWI_ReadC:
|
callback->read_stdin (callback, &c, 1);
|
callback->read_stdin (callback, &c, 1);
|
args->n = c;
|
args->n = c;
|
return 1;
|
return 1;
|
case SWI_CLI:
|
case SWI_CLI:
|
args->n = callback->system (callback, args->s);
|
args->n = callback->system (callback, args->s);
|
return 1;
|
return 1;
|
case SWI_GetErrno:
|
case SWI_GetErrno:
|
args->n = callback->get_errno (callback);
|
args->n = callback->get_errno (callback);
|
return 1;
|
return 1;
|
case SWI_Time:
|
case SWI_Time:
|
args->n = callback->time (callback, NULL);
|
args->n = callback->time (callback, NULL);
|
return 1;
|
return 1;
|
|
|
case SWI_Clock:
|
case SWI_Clock:
|
/* return number of centi-seconds... */
|
/* return number of centi-seconds... */
|
args->n =
|
args->n =
|
#ifdef CLOCKS_PER_SEC
|
#ifdef CLOCKS_PER_SEC
|
(CLOCKS_PER_SEC >= 100)
|
(CLOCKS_PER_SEC >= 100)
|
? (clock () / (CLOCKS_PER_SEC / 100))
|
? (clock () / (CLOCKS_PER_SEC / 100))
|
: ((clock () * 100) / CLOCKS_PER_SEC);
|
: ((clock () * 100) / CLOCKS_PER_SEC);
|
#else
|
#else
|
/* presume unix... clock() returns microseconds */
|
/* presume unix... clock() returns microseconds */
|
clock () / 10000;
|
clock () / 10000;
|
#endif
|
#endif
|
return 1;
|
return 1;
|
|
|
case SWI_Remove:
|
case SWI_Remove:
|
args->n = callback->unlink (callback, args->s);
|
args->n = callback->unlink (callback, args->s);
|
return 1;
|
return 1;
|
case SWI_Rename:
|
case SWI_Rename:
|
args->n = callback->rename (callback, args[0].s, args[1].s);
|
args->n = callback->rename (callback, args[0].s, args[1].s);
|
return 1;
|
return 1;
|
|
|
case SWI_Open:
|
case SWI_Open:
|
/* Now we need to decode the Demon open mode */
|
/* Now we need to decode the Demon open mode */
|
i = translate_open_mode[args[1].n];
|
i = translate_open_mode[args[1].n];
|
|
|
/* Filename ":tt" is special: it denotes stdin/out */
|
/* Filename ":tt" is special: it denotes stdin/out */
|
if (strcmp (args->s, ":tt") == 0)
|
if (strcmp (args->s, ":tt") == 0)
|
{
|
{
|
if (i == O_RDONLY) /* opening tty "r" */
|
if (i == O_RDONLY) /* opening tty "r" */
|
args->n = 0 /* stdin */ ;
|
args->n = 0 /* stdin */ ;
|
else
|
else
|
args->n = 1 /* stdout */ ;
|
args->n = 1 /* stdout */ ;
|
}
|
}
|
else
|
else
|
args->n = callback->open (callback, args->s, i);
|
args->n = callback->open (callback, args->s, i);
|
return 1;
|
return 1;
|
|
|
case SWI_Close:
|
case SWI_Close:
|
args->n = callback->close (callback, args->n);
|
args->n = callback->close (callback, args->n);
|
return 1;
|
return 1;
|
|
|
case SWI_Write:
|
case SWI_Write:
|
/* Return the number of bytes *not* written */
|
/* Return the number of bytes *not* written */
|
args->n = args[1].n -
|
args->n = args[1].n -
|
callback->write (callback, args[0].n, args[1].s, args[1].n);
|
callback->write (callback, args[0].n, args[1].s, args[1].n);
|
return 1;
|
return 1;
|
|
|
case SWI_Read:
|
case SWI_Read:
|
{
|
{
|
char *copy = alloca (args[2].n);
|
char *copy = alloca (args[2].n);
|
int done = callback->read (callback, args[0].n, copy, args[2].n);
|
int done = callback->read (callback, args[0].n, copy, args[2].n);
|
if (done > 0)
|
if (done > 0)
|
remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0);
|
remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0);
|
args->n = args[2].n - done;
|
args->n = args[2].n - done;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
case SWI_Seek:
|
case SWI_Seek:
|
/* Return non-zero on failure */
|
/* Return non-zero on failure */
|
args->n = callback->lseek (callback, args[0].n, args[1].n, 0) < 0;
|
args->n = callback->lseek (callback, args[0].n, args[1].n, 0) < 0;
|
return 1;
|
return 1;
|
|
|
case SWI_Flen:
|
case SWI_Flen:
|
{
|
{
|
long old = callback->lseek (callback, args->n, 0, SEEK_CUR);
|
long old = callback->lseek (callback, args->n, 0, SEEK_CUR);
|
args->n = callback->lseek (callback, args->n, 0, SEEK_END);
|
args->n = callback->lseek (callback, args->n, 0, SEEK_END);
|
callback->lseek (callback, args->n, old, 0);
|
callback->lseek (callback, args->n, old, 0);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
case SWI_IsTTY:
|
case SWI_IsTTY:
|
args->n = callback->isatty (callback, args->n);
|
args->n = callback->isatty (callback, args->n);
|
return 1;
|
return 1;
|
|
|
case SWI_GetEnv:
|
case SWI_GetEnv:
|
if (commandline != NULL)
|
if (commandline != NULL)
|
{
|
{
|
int len = strlen (commandline);
|
int len = strlen (commandline);
|
if (len > 255)
|
if (len > 255)
|
{
|
{
|
len = 255;
|
len = 255;
|
commandline[255] = '\0';
|
commandline[255] = '\0';
|
}
|
}
|
remote_rdp_xfer_inferior_memory (args[0].n,
|
remote_rdp_xfer_inferior_memory (args[0].n,
|
commandline, len + 1, 1, 0);
|
commandline, len + 1, 1, 0);
|
}
|
}
|
else
|
else
|
remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0);
|
remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0);
|
return 1;
|
return 1;
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
|
|
static void
|
static void
|
handle_swi ()
|
handle_swi ()
|
{
|
{
|
argsin args[3];
|
argsin args[3];
|
char *buf;
|
char *buf;
|
int len;
|
int len;
|
int count = 0;
|
int count = 0;
|
|
|
int swino = get_word ();
|
int swino = get_word ();
|
int type = get_byte ();
|
int type = get_byte ();
|
while (type != 0)
|
while (type != 0)
|
{
|
{
|
switch (type & 0x3)
|
switch (type & 0x3)
|
{
|
{
|
case ABYTE:
|
case ABYTE:
|
args[count].n = get_byte ();
|
args[count].n = get_byte ();
|
break;
|
break;
|
|
|
case AWORD:
|
case AWORD:
|
args[count].n = get_word ();
|
args[count].n = get_word ();
|
break;
|
break;
|
|
|
case ASTRING:
|
case ASTRING:
|
/* If the word is under 32 bytes it will be sent otherwise
|
/* If the word is under 32 bytes it will be sent otherwise
|
an address to it is passed. Also: Special case of 255 */
|
an address to it is passed. Also: Special case of 255 */
|
|
|
len = get_byte ();
|
len = get_byte ();
|
if (len > 32)
|
if (len > 32)
|
{
|
{
|
if (len == 255)
|
if (len == 255)
|
{
|
{
|
len = get_word ();
|
len = get_word ();
|
}
|
}
|
buf = alloca (len);
|
buf = alloca (len);
|
remote_rdp_xfer_inferior_memory (get_word (),
|
remote_rdp_xfer_inferior_memory (get_word (),
|
buf,
|
buf,
|
len,
|
len,
|
0,
|
0,
|
0);
|
0);
|
}
|
}
|
else
|
else
|
{
|
{
|
int i;
|
int i;
|
buf = alloca (len + 1);
|
buf = alloca (len + 1);
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
buf[i] = get_byte ();
|
buf[i] = get_byte ();
|
buf[i] = 0;
|
buf[i] = 0;
|
}
|
}
|
args[count].n = len;
|
args[count].n = len;
|
args[count].s = buf;
|
args[count].s = buf;
|
break;
|
break;
|
|
|
default:
|
default:
|
error ("Unimplented SWI argument");
|
error ("Unimplented SWI argument");
|
}
|
}
|
|
|
type = type >> 2;
|
type = type >> 2;
|
count++;
|
count++;
|
}
|
}
|
|
|
if (exec_swi (swino, args))
|
if (exec_swi (swino, args))
|
{
|
{
|
/* We have two options here reply with either a byte or a word
|
/* We have two options here reply with either a byte or a word
|
which is stored in args[0].n. There is no harm in replying with
|
which is stored in args[0].n. There is no harm in replying with
|
a word all the time, so thats what I do! */
|
a word all the time, so thats what I do! */
|
send_rdp ("bbw-", RDP_OSOpReply, RDP_OSOpWord, args[0].n);
|
send_rdp ("bbw-", RDP_OSOpReply, RDP_OSOpWord, args[0].n);
|
}
|
}
|
else
|
else
|
{
|
{
|
send_rdp ("bb-", RDP_OSOpReply, RDP_OSOpNothing);
|
send_rdp ("bb-", RDP_OSOpReply, RDP_OSOpNothing);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
rdp_execute_finish ()
|
rdp_execute_finish ()
|
{
|
{
|
int running = 1;
|
int running = 1;
|
|
|
while (running)
|
while (running)
|
{
|
{
|
int res;
|
int res;
|
res = SERIAL_READCHAR (io, 1);
|
res = SERIAL_READCHAR (io, 1);
|
while (res == SERIAL_TIMEOUT)
|
while (res == SERIAL_TIMEOUT)
|
{
|
{
|
QUIT;
|
QUIT;
|
printf_filtered ("Waiting for target..\n");
|
printf_filtered ("Waiting for target..\n");
|
res = SERIAL_READCHAR (io, 1);
|
res = SERIAL_READCHAR (io, 1);
|
}
|
}
|
|
|
switch (res)
|
switch (res)
|
{
|
{
|
case RDP_RES_SWI:
|
case RDP_RES_SWI:
|
handle_swi ();
|
handle_swi ();
|
break;
|
break;
|
case RDP_RES_VALUE:
|
case RDP_RES_VALUE:
|
send_rdp ("B", &ds.rdi_stopped_status);
|
send_rdp ("B", &ds.rdi_stopped_status);
|
running = 0;
|
running = 0;
|
break;
|
break;
|
case RDP_RESET:
|
case RDP_RESET:
|
printf_filtered ("Target reset\n");
|
printf_filtered ("Target reset\n");
|
running = 0;
|
running = 0;
|
break;
|
break;
|
default:
|
default:
|
printf_filtered ("Ignoring %x\n", res);
|
printf_filtered ("Ignoring %x\n", res);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
|
|
static void
|
static void
|
rdp_execute ()
|
rdp_execute ()
|
{
|
{
|
rdp_execute_start ();
|
rdp_execute_start ();
|
rdp_execute_finish ();
|
rdp_execute_finish ();
|
}
|
}
|
|
|
static int
|
static int
|
remote_rdp_insert_breakpoint (addr, save)
|
remote_rdp_insert_breakpoint (addr, save)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *save;
|
char *save;
|
{
|
{
|
int res;
|
int res;
|
if (ds.rdi_level > 0)
|
if (ds.rdi_level > 0)
|
{
|
{
|
send_rdp ("bwb-SWB",
|
send_rdp ("bwb-SWB",
|
RDP_SET_BREAK,
|
RDP_SET_BREAK,
|
addr,
|
addr,
|
RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
|
RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
|
save,
|
save,
|
&res);
|
&res);
|
}
|
}
|
else
|
else
|
{
|
{
|
send_rdp ("bwb-SB",
|
send_rdp ("bwb-SB",
|
RDP_SET_BREAK,
|
RDP_SET_BREAK,
|
addr,
|
addr,
|
RDP_SET_BREAK_TYPE_PC_EQUAL,
|
RDP_SET_BREAK_TYPE_PC_EQUAL,
|
&res);
|
&res);
|
}
|
}
|
return res;
|
return res;
|
}
|
}
|
|
|
static int
|
static int
|
remote_rdp_remove_breakpoint (addr, save)
|
remote_rdp_remove_breakpoint (addr, save)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *save;
|
char *save;
|
{
|
{
|
int res;
|
int res;
|
if (ds.rdi_level > 0)
|
if (ds.rdi_level > 0)
|
{
|
{
|
send_rdp ("b-p-S-B",
|
send_rdp ("b-p-S-B",
|
RDP_CLEAR_BREAK,
|
RDP_CLEAR_BREAK,
|
save, 4,
|
save, 4,
|
&res);
|
&res);
|
}
|
}
|
else
|
else
|
{
|
{
|
send_rdp ("bw-S-B",
|
send_rdp ("bw-S-B",
|
RDP_CLEAR_BREAK,
|
RDP_CLEAR_BREAK,
|
addr,
|
addr,
|
&res);
|
&res);
|
}
|
}
|
return res;
|
return res;
|
}
|
}
|
|
|
static void
|
static void
|
rdp_step ()
|
rdp_step ()
|
{
|
{
|
if (ds.can_step && 0)
|
if (ds.can_step && 0)
|
{
|
{
|
/* The pie board can't do steps so I can't test this, and
|
/* The pie board can't do steps so I can't test this, and
|
the other code will always work. */
|
the other code will always work. */
|
int status;
|
int status;
|
send_rdp ("bbw-S-B",
|
send_rdp ("bbw-S-B",
|
RDP_STEP, 0, 1,
|
RDP_STEP, 0, 1,
|
&status);
|
&status);
|
}
|
}
|
else
|
else
|
{
|
{
|
char handle[4];
|
char handle[4];
|
CORE_ADDR pc = read_register (PC_REGNUM);
|
CORE_ADDR pc = read_register (PC_REGNUM);
|
pc = arm_get_next_pc (pc);
|
pc = arm_get_next_pc (pc);
|
remote_rdp_insert_breakpoint (pc, &handle);
|
remote_rdp_insert_breakpoint (pc, &handle);
|
rdp_execute ();
|
rdp_execute ();
|
remote_rdp_remove_breakpoint (pc, &handle);
|
remote_rdp_remove_breakpoint (pc, &handle);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
remote_rdp_open (args, from_tty)
|
remote_rdp_open (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
int not_icebreaker;
|
int not_icebreaker;
|
|
|
if (!args)
|
if (!args)
|
error_no_arg ("serial port device name");
|
error_no_arg ("serial port device name");
|
|
|
baud_rate = 9600;
|
baud_rate = 9600;
|
|
|
target_preopen (from_tty);
|
target_preopen (from_tty);
|
|
|
io = SERIAL_OPEN (args);
|
io = SERIAL_OPEN (args);
|
|
|
if (!io)
|
if (!io)
|
perror_with_name (args);
|
perror_with_name (args);
|
|
|
SERIAL_RAW (io);
|
SERIAL_RAW (io);
|
|
|
rdp_init (1, from_tty);
|
rdp_init (1, from_tty);
|
|
|
|
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
printf_unfiltered ("Remote RDP debugging using %s at %d baud\n", args, baud_rate);
|
printf_unfiltered ("Remote RDP debugging using %s at %d baud\n", args, baud_rate);
|
}
|
}
|
|
|
rdp_info ();
|
rdp_info ();
|
|
|
/* Need to set up the vector interception state */
|
/* Need to set up the vector interception state */
|
rdp_catch_vectors ();
|
rdp_catch_vectors ();
|
|
|
/*
|
/*
|
** If it's an EmbeddedICE, we need to set the processor config.
|
** If it's an EmbeddedICE, we need to set the processor config.
|
** Assume we can always have ARM7TDI...
|
** Assume we can always have ARM7TDI...
|
*/
|
*/
|
send_rdp ("bw-SB", RDP_INFO, RDP_INFO_ICEBREAKER, ¬_icebreaker);
|
send_rdp ("bw-SB", RDP_INFO, RDP_INFO_ICEBREAKER, ¬_icebreaker);
|
if (!not_icebreaker)
|
if (!not_icebreaker)
|
{
|
{
|
const char *CPU = "ARM7TDI";
|
const char *CPU = "ARM7TDI";
|
int ICEversion;
|
int ICEversion;
|
int len = strlen (CPU);
|
int len = strlen (CPU);
|
|
|
send_rdp ("bbbbw-p-SWZ",
|
send_rdp ("bbbbw-p-SWZ",
|
RDP_SELECT_CONFIG,
|
RDP_SELECT_CONFIG,
|
RDI_ConfigCPU, /* Aspect: set the CPU */
|
RDI_ConfigCPU, /* Aspect: set the CPU */
|
len, /* The number of bytes in the name */
|
len, /* The number of bytes in the name */
|
RDI_MatchAny, /* We'll take whatever we get */
|
RDI_MatchAny, /* We'll take whatever we get */
|
0, /* We'll take whatever version's there */
|
0, /* We'll take whatever version's there */
|
CPU, len,
|
CPU, len,
|
&ICEversion);
|
&ICEversion);
|
}
|
}
|
|
|
/* command line initialised on 'run' */
|
/* command line initialised on 'run' */
|
|
|
push_target (&remote_rdp_ops);
|
push_target (&remote_rdp_ops);
|
|
|
callback->init (callback);
|
callback->init (callback);
|
flush_cached_frames ();
|
flush_cached_frames ();
|
registers_changed ();
|
registers_changed ();
|
stop_pc = read_pc ();
|
stop_pc = read_pc ();
|
set_current_frame (create_new_frame (read_fp (), stop_pc));
|
set_current_frame (create_new_frame (read_fp (), stop_pc));
|
select_frame (get_current_frame (), 0);
|
select_frame (get_current_frame (), 0);
|
print_stack_frame (selected_frame, -1, 1);
|
print_stack_frame (selected_frame, -1, 1);
|
}
|
}
|
|
|
|
|
|
|
/* Close out all files and local state before this target loses control. */
|
/* Close out all files and local state before this target loses control. */
|
|
|
static void
|
static void
|
remote_rdp_close (quitting)
|
remote_rdp_close (quitting)
|
int quitting;
|
int quitting;
|
{
|
{
|
callback->shutdown (callback);
|
callback->shutdown (callback);
|
if (io)
|
if (io)
|
SERIAL_CLOSE (io);
|
SERIAL_CLOSE (io);
|
io = 0;
|
io = 0;
|
}
|
}
|
|
|
|
|
/* Resume execution of the target process. STEP says whether to single-step
|
/* 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
|
or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
|
to the target, or zero for no signal. */
|
to the target, or zero for no signal. */
|
|
|
static void
|
static void
|
remote_rdp_resume (pid, step, siggnal)
|
remote_rdp_resume (pid, step, siggnal)
|
int pid, step;
|
int pid, step;
|
enum target_signal siggnal;
|
enum target_signal siggnal;
|
{
|
{
|
if (step)
|
if (step)
|
rdp_step ();
|
rdp_step ();
|
else
|
else
|
rdp_execute ();
|
rdp_execute ();
|
}
|
}
|
|
|
/* Wait for inferior process to do something. Return pid of child,
|
/* Wait for inferior process to do something. Return pid of child,
|
or -1 in case of error; store status through argument pointer STATUS,
|
or -1 in case of error; store status through argument pointer STATUS,
|
just as `wait' would. */
|
just as `wait' would. */
|
|
|
static int
|
static int
|
remote_rdp_wait (pid, status)
|
remote_rdp_wait (pid, status)
|
int pid;
|
int pid;
|
struct target_waitstatus *status;
|
struct target_waitstatus *status;
|
{
|
{
|
switch (ds.rdi_stopped_status)
|
switch (ds.rdi_stopped_status)
|
{
|
{
|
default:
|
default:
|
case RDP_RES_RESET:
|
case RDP_RES_RESET:
|
case RDP_RES_SWI:
|
case RDP_RES_SWI:
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->value.integer = read_register (0);
|
status->value.integer = read_register (0);
|
break;
|
break;
|
case RDP_RES_AT_BREAKPOINT:
|
case RDP_RES_AT_BREAKPOINT:
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
/* The signal in sigrc is a host signal. That probably
|
/* The signal in sigrc is a host signal. That probably
|
should be fixed. */
|
should be fixed. */
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
break;
|
break;
|
#if 0
|
#if 0
|
case rdp_signalled:
|
case rdp_signalled:
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
status->kind = TARGET_WAITKIND_SIGNALLED;
|
/* The signal in sigrc is a host signal. That probably
|
/* The signal in sigrc is a host signal. That probably
|
should be fixed. */
|
should be fixed. */
|
status->value.sig = target_signal_from_host (sigrc);
|
status->value.sig = target_signal_from_host (sigrc);
|
break;
|
break;
|
#endif
|
#endif
|
}
|
}
|
|
|
return inferior_pid;
|
return inferior_pid;
|
}
|
}
|
|
|
/* Get ready to modify the registers array. On machines which store
|
/* Get ready to modify the registers array. On machines which store
|
individual registers, this doesn't need to do anything. On machines
|
individual registers, this doesn't need to do anything. On machines
|
which store all the registers in one fell swoop, this makes sure
|
which store all the registers in one fell swoop, this makes sure
|
that registers contains all the registers from the program being
|
that registers contains all the registers from the program being
|
debugged. */
|
debugged. */
|
|
|
static void
|
static void
|
remote_rdp_prepare_to_store ()
|
remote_rdp_prepare_to_store ()
|
{
|
{
|
/* Do nothing, since we can store individual regs */
|
/* Do nothing, since we can store individual regs */
|
}
|
}
|
|
|
static int
|
static int
|
remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
|
remote_rdp_xfer_inferior_memory (memaddr, myaddr, len, write, target)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
int write;
|
int write;
|
struct target_ops *target; /* ignored */
|
struct target_ops *target; /* ignored */
|
{
|
{
|
/* I infer from D Taylor's code that there's a limit on the amount
|
/* I infer from D Taylor's code that there's a limit on the amount
|
we can transfer in one chunk.. */
|
we can transfer in one chunk.. */
|
int done = 0;
|
int done = 0;
|
while (done < len)
|
while (done < len)
|
{
|
{
|
int justdone;
|
int justdone;
|
int thisbite = len - done;
|
int thisbite = len - done;
|
if (thisbite > RDP_MOUTHFULL)
|
if (thisbite > RDP_MOUTHFULL)
|
thisbite = RDP_MOUTHFULL;
|
thisbite = RDP_MOUTHFULL;
|
|
|
QUIT;
|
QUIT;
|
|
|
if (write)
|
if (write)
|
{
|
{
|
justdone = rdp_write (memaddr + done, myaddr + done, thisbite);
|
justdone = rdp_write (memaddr + done, myaddr + done, thisbite);
|
}
|
}
|
else
|
else
|
{
|
{
|
justdone = rdp_read (memaddr + done, myaddr + done, thisbite);
|
justdone = rdp_read (memaddr + done, myaddr + done, thisbite);
|
}
|
}
|
|
|
done += justdone;
|
done += justdone;
|
|
|
if (justdone != thisbite)
|
if (justdone != thisbite)
|
break;
|
break;
|
}
|
}
|
return done;
|
return done;
|
}
|
}
|
|
|
|
|
|
|
struct yn
|
struct yn
|
{
|
{
|
const char *name;
|
const char *name;
|
int bit;
|
int bit;
|
};
|
};
|
static struct yn stepinfo[] =
|
static struct yn stepinfo[] =
|
{
|
{
|
{"Step more than one instruction", RDP_INFO_ABOUT_STEP_GT_1},
|
{"Step more than one instruction", RDP_INFO_ABOUT_STEP_GT_1},
|
{"Step to jump", RDP_INFO_ABOUT_STEP_TO_JMP},
|
{"Step to jump", RDP_INFO_ABOUT_STEP_TO_JMP},
|
{"Step one instruction", RDP_INFO_ABOUT_STEP_1},
|
{"Step one instruction", RDP_INFO_ABOUT_STEP_1},
|
{0}
|
{0}
|
};
|
};
|
|
|
static struct yn breakinfo[] =
|
static struct yn breakinfo[] =
|
{
|
{
|
{"comparison breakpoints supported", RDP_INFO_ABOUT_BREAK_COMP},
|
{"comparison breakpoints supported", RDP_INFO_ABOUT_BREAK_COMP},
|
{"range breakpoints supported", RDP_INFO_ABOUT_BREAK_RANGE},
|
{"range breakpoints supported", RDP_INFO_ABOUT_BREAK_RANGE},
|
{"watchpoints for byte reads supported", RDP_INFO_ABOUT_BREAK_BYTE_READ},
|
{"watchpoints for byte reads supported", RDP_INFO_ABOUT_BREAK_BYTE_READ},
|
{"watchpoints for half-word reads supported", RDP_INFO_ABOUT_BREAK_HALFWORD_READ},
|
{"watchpoints for half-word reads supported", RDP_INFO_ABOUT_BREAK_HALFWORD_READ},
|
{"watchpoints for word reads supported", RDP_INFO_ABOUT_BREAK_WORD_READ},
|
{"watchpoints for word reads supported", RDP_INFO_ABOUT_BREAK_WORD_READ},
|
{"watchpoints for byte writes supported", RDP_INFO_ABOUT_BREAK_BYTE_WRITE},
|
{"watchpoints for byte writes supported", RDP_INFO_ABOUT_BREAK_BYTE_WRITE},
|
{"watchpoints for half-word writes supported", RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE},
|
{"watchpoints for half-word writes supported", RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE},
|
{"watchpoints for word writes supported", RDP_INFO_ABOUT_BREAK_WORD_WRITE},
|
{"watchpoints for word writes supported", RDP_INFO_ABOUT_BREAK_WORD_WRITE},
|
{"mask break/watch-points supported", RDP_INFO_ABOUT_BREAK_MASK},
|
{"mask break/watch-points supported", RDP_INFO_ABOUT_BREAK_MASK},
|
{"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
|
{"thread-specific breakpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_BREAK},
|
{"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
|
{"thread-specific watchpoints supported", RDP_INFO_ABOUT_BREAK_THREAD_WATCH},
|
{"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
|
{"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
|
{0}
|
{0}
|
};
|
};
|
|
|
|
|
static void
|
static void
|
dump_bits (t, info)
|
dump_bits (t, info)
|
struct yn *t;
|
struct yn *t;
|
int info;
|
int info;
|
{
|
{
|
while (t->name)
|
while (t->name)
|
{
|
{
|
printf_unfiltered (" %-45s : %s\n", t->name, (info & t->bit) ? "Yes" : "No");
|
printf_unfiltered (" %-45s : %s\n", t->name, (info & t->bit) ? "Yes" : "No");
|
t++;
|
t++;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
remote_rdp_files_info (target)
|
remote_rdp_files_info (target)
|
struct target_ops *target;
|
struct target_ops *target;
|
{
|
{
|
printf_filtered ("Target capabilities:\n");
|
printf_filtered ("Target capabilities:\n");
|
dump_bits (stepinfo, ds.step_info);
|
dump_bits (stepinfo, ds.step_info);
|
dump_bits (breakinfo, ds.break_info);
|
dump_bits (breakinfo, ds.break_info);
|
printf_unfiltered ("target level RDI %x\n", (ds.target_info >> 5) & 3);
|
printf_unfiltered ("target level RDI %x\n", (ds.target_info >> 5) & 3);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
remote_rdp_create_inferior (exec_file, allargs, env)
|
remote_rdp_create_inferior (exec_file, allargs, env)
|
char *exec_file;
|
char *exec_file;
|
char *allargs;
|
char *allargs;
|
char **env;
|
char **env;
|
{
|
{
|
CORE_ADDR entry_point;
|
CORE_ADDR entry_point;
|
|
|
if (exec_file == 0 || exec_bfd == 0)
|
if (exec_file == 0 || exec_bfd == 0)
|
error ("No executable file specified.");
|
error ("No executable file specified.");
|
|
|
entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
|
entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);
|
|
|
remote_rdp_kill ();
|
remote_rdp_kill ();
|
remove_breakpoints ();
|
remove_breakpoints ();
|
init_wait_for_inferior ();
|
init_wait_for_inferior ();
|
|
|
/* This gives us a chance to set up the command line */
|
/* This gives us a chance to set up the command line */
|
rdp_set_command_line (exec_file, allargs);
|
rdp_set_command_line (exec_file, allargs);
|
|
|
inferior_pid = 42;
|
inferior_pid = 42;
|
insert_breakpoints (); /* Needed to get correct instruction in cache */
|
insert_breakpoints (); /* Needed to get correct instruction in cache */
|
|
|
/*
|
/*
|
** RDP targets don't provide any facility to set the top of memory,
|
** 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.
|
** so we don't bother to look for MEMSIZE in the environment.
|
*/
|
*/
|
|
|
/* Let's go! */
|
/* Let's go! */
|
proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
|
proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
|
}
|
}
|
|
|
/* Accept any stray run/attach commands */
|
/* Accept any stray run/attach commands */
|
static int
|
static int
|
remote_rdp_can_run ()
|
remote_rdp_can_run ()
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Attach doesn't need to do anything */
|
/* Attach doesn't need to do anything */
|
static void
|
static void
|
remote_rdp_attach (args, from_tty)
|
remote_rdp_attach (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
return;
|
return;
|
}
|
}
|
|
|
/* Define the target subroutine names */
|
/* Define the target subroutine names */
|
|
|
struct target_ops remote_rdp_ops;
|
struct target_ops remote_rdp_ops;
|
|
|
static void
|
static void
|
init_remote_rdp_ops (void)
|
init_remote_rdp_ops (void)
|
{
|
{
|
remote_rdp_ops.to_shortname = "rdp";
|
remote_rdp_ops.to_shortname = "rdp";
|
remote_rdp_ops.to_longname = "Remote Target using the RDProtocol";
|
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_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_open = remote_rdp_open;
|
remote_rdp_ops.to_close = remote_rdp_close;
|
remote_rdp_ops.to_close = remote_rdp_close;
|
remote_rdp_ops.to_attach = remote_rdp_attach;
|
remote_rdp_ops.to_attach = remote_rdp_attach;
|
remote_rdp_ops.to_post_attach = NULL;
|
remote_rdp_ops.to_post_attach = NULL;
|
remote_rdp_ops.to_require_attach = NULL;
|
remote_rdp_ops.to_require_attach = NULL;
|
remote_rdp_ops.to_detach = NULL;
|
remote_rdp_ops.to_detach = NULL;
|
remote_rdp_ops.to_require_detach = NULL;
|
remote_rdp_ops.to_require_detach = NULL;
|
remote_rdp_ops.to_resume = remote_rdp_resume;
|
remote_rdp_ops.to_resume = remote_rdp_resume;
|
remote_rdp_ops.to_wait = remote_rdp_wait;
|
remote_rdp_ops.to_wait = remote_rdp_wait;
|
remote_rdp_ops.to_post_wait = NULL;
|
remote_rdp_ops.to_post_wait = NULL;
|
remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
|
remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register;
|
remote_rdp_ops.to_store_registers = remote_rdp_store_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_prepare_to_store = remote_rdp_prepare_to_store;
|
remote_rdp_ops.to_xfer_memory = remote_rdp_xfer_inferior_memory;
|
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_files_info = remote_rdp_files_info;
|
remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
|
remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint;
|
remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
|
remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint;
|
remote_rdp_ops.to_terminal_init = NULL;
|
remote_rdp_ops.to_terminal_init = NULL;
|
remote_rdp_ops.to_terminal_inferior = NULL;
|
remote_rdp_ops.to_terminal_inferior = NULL;
|
remote_rdp_ops.to_terminal_ours_for_output = NULL;
|
remote_rdp_ops.to_terminal_ours_for_output = NULL;
|
remote_rdp_ops.to_terminal_ours = NULL;
|
remote_rdp_ops.to_terminal_ours = NULL;
|
remote_rdp_ops.to_terminal_info = NULL;
|
remote_rdp_ops.to_terminal_info = NULL;
|
remote_rdp_ops.to_kill = remote_rdp_kill;
|
remote_rdp_ops.to_kill = remote_rdp_kill;
|
remote_rdp_ops.to_load = generic_load;
|
remote_rdp_ops.to_load = generic_load;
|
remote_rdp_ops.to_lookup_symbol = NULL;
|
remote_rdp_ops.to_lookup_symbol = NULL;
|
remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
|
remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior;
|
remote_rdp_ops.to_post_startup_inferior = NULL;
|
remote_rdp_ops.to_post_startup_inferior = NULL;
|
remote_rdp_ops.to_acknowledge_created_inferior = NULL;
|
remote_rdp_ops.to_acknowledge_created_inferior = NULL;
|
remote_rdp_ops.to_clone_and_follow_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_post_follow_inferior_by_clone = NULL;
|
remote_rdp_ops.to_insert_fork_catchpoint = NULL;
|
remote_rdp_ops.to_insert_fork_catchpoint = NULL;
|
remote_rdp_ops.to_remove_fork_catchpoint = NULL;
|
remote_rdp_ops.to_remove_fork_catchpoint = NULL;
|
remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
|
remote_rdp_ops.to_insert_vfork_catchpoint = NULL;
|
remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
|
remote_rdp_ops.to_remove_vfork_catchpoint = NULL;
|
remote_rdp_ops.to_has_forked = NULL;
|
remote_rdp_ops.to_has_forked = NULL;
|
remote_rdp_ops.to_has_vforked = NULL;
|
remote_rdp_ops.to_has_vforked = NULL;
|
remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
|
remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL;
|
remote_rdp_ops.to_post_follow_vfork = NULL;
|
remote_rdp_ops.to_post_follow_vfork = NULL;
|
remote_rdp_ops.to_insert_exec_catchpoint = NULL;
|
remote_rdp_ops.to_insert_exec_catchpoint = NULL;
|
remote_rdp_ops.to_remove_exec_catchpoint = NULL;
|
remote_rdp_ops.to_remove_exec_catchpoint = NULL;
|
remote_rdp_ops.to_has_execd = NULL;
|
remote_rdp_ops.to_has_execd = NULL;
|
remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
|
remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL;
|
remote_rdp_ops.to_has_exited = NULL;
|
remote_rdp_ops.to_has_exited = NULL;
|
remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
|
remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior;
|
remote_rdp_ops.to_can_run = remote_rdp_can_run;
|
remote_rdp_ops.to_can_run = remote_rdp_can_run;
|
remote_rdp_ops.to_notice_signals = 0;
|
remote_rdp_ops.to_notice_signals = 0;
|
remote_rdp_ops.to_thread_alive = 0;
|
remote_rdp_ops.to_thread_alive = 0;
|
remote_rdp_ops.to_stop = 0;
|
remote_rdp_ops.to_stop = 0;
|
remote_rdp_ops.to_pid_to_exec_file = NULL;
|
remote_rdp_ops.to_pid_to_exec_file = NULL;
|
remote_rdp_ops.to_core_file_to_sym_file = NULL;
|
remote_rdp_ops.to_core_file_to_sym_file = NULL;
|
remote_rdp_ops.to_stratum = process_stratum;
|
remote_rdp_ops.to_stratum = process_stratum;
|
remote_rdp_ops.DONT_USE = NULL;
|
remote_rdp_ops.DONT_USE = NULL;
|
remote_rdp_ops.to_has_all_memory = 1;
|
remote_rdp_ops.to_has_all_memory = 1;
|
remote_rdp_ops.to_has_memory = 1;
|
remote_rdp_ops.to_has_memory = 1;
|
remote_rdp_ops.to_has_stack = 1;
|
remote_rdp_ops.to_has_stack = 1;
|
remote_rdp_ops.to_has_registers = 1;
|
remote_rdp_ops.to_has_registers = 1;
|
remote_rdp_ops.to_has_execution = 1;
|
remote_rdp_ops.to_has_execution = 1;
|
remote_rdp_ops.to_sections = NULL;
|
remote_rdp_ops.to_sections = NULL;
|
remote_rdp_ops.to_sections_end = NULL;
|
remote_rdp_ops.to_sections_end = NULL;
|
remote_rdp_ops.to_magic = OPS_MAGIC;
|
remote_rdp_ops.to_magic = OPS_MAGIC;
|
}
|
}
|
|
|
void
|
void
|
_initialize_remote_rdp ()
|
_initialize_remote_rdp ()
|
{
|
{
|
init_remote_rdp_ops ();
|
init_remote_rdp_ops ();
|
add_target (&remote_rdp_ops);
|
add_target (&remote_rdp_ops);
|
}
|
}
|
|
|
