1450 lines
32 KiB
C
1450 lines
32 KiB
C
/* Remote debugging for the ARM RDP interface.
|
||
Copyright 1994, 1995 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 2 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||
|
||
|
||
*/
|
||
|
||
|
||
/*
|
||
Much of this file (in particular the SWI stuff) is based on code by
|
||
David Taylor (djt1000@uk.ac.cam.hermes).
|
||
|
||
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
|
||
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
|
||
the doc I have; which may be wrong.
|
||
|
||
Steve Chamberlain (sac@cygnus.com).
|
||
*/
|
||
|
||
|
||
#include "defs.h"
|
||
#include "inferior.h"
|
||
#include "wait.h"
|
||
#include "value.h"
|
||
#include "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"
|
||
#ifdef HAVE_UNISTD_H
|
||
#include <unistd.h>
|
||
#endif
|
||
#include "gdbcore.h"
|
||
|
||
|
||
extern struct target_ops remote_rdp_ops;
|
||
static serial_t 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;
|
||
|
||
|
||
|
||
/* Definitions for the RDP protocol. */
|
||
|
||
#define RDP_MOUTHFULL (1<<6)
|
||
#define FPU_COPRO_NUMBER 1
|
||
|
||
#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_MEM_READ 2
|
||
|
||
#define RDP_MEM_WRITE 3
|
||
|
||
#define RDP_CPU_READ 4
|
||
#define RDP_CPU_WRITE 5
|
||
#define RDP_CPU_READWRITE_MODE_CURRENT 255
|
||
#define RDP_CPU_READWRITE_MASK_PC (1<<16)
|
||
#define RDP_CPU_READWRITE_MASK_CPSR (1<<17)
|
||
#define RDP_CPU_READWRITE_MASK_SPSR (1<<18)
|
||
|
||
#define RDP_COPRO_READ 6
|
||
#define RDP_COPRO_WRITE 7
|
||
#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_CLEAR_BREAK 0xb
|
||
|
||
#define RDP_EXEC 0x10
|
||
#define RDP_EXEC_TYPE_SYNC 0
|
||
|
||
#define RDP_STEP 0x11
|
||
|
||
#define RDP_INFO 0x12
|
||
#define RDP_INFO_ABOUT_STEP 2
|
||
#define RDP_INFO_ABOUT_STEP_GT_1 1
|
||
#define RDP_INFO_ABOUT_STEP_TO_JMP 2
|
||
#define RDP_INFO_ABOUT_STEP_1 4
|
||
#define RDP_INFO_ABOUT_TARGET 0
|
||
#define RDP_INFO_ABOUT_BREAK 1
|
||
#define RDP_INFO_ABOUT_BREAK_COMP 1
|
||
#define RDP_INFO_ABOUT_BREAK_RANGE 2
|
||
#define RDP_INFO_ABOUT_BREAK_BYTE_READ 4
|
||
#define RDP_INFO_ABOUT_BREAK_HALFWORD_READ 8
|
||
#define RDP_INFO_ABOUT_BREAK_WORD_READ (1<<4)
|
||
#define RDP_INFO_ABOUT_BREAK_BYTE_WRITE (1<<5)
|
||
#define RDP_INFO_ABOUT_BREAK_HALFWORD_WRITE (1<<6)
|
||
#define RDP_INFO_ABOUT_BREAK_WORD_WRITE (1<<7)
|
||
#define RDP_INFO_ABOUT_BREAK_MASK (1<<8)
|
||
#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
|
||
|
||
/* Returns from RDP */
|
||
#define RDP_RES_STOPPED 0x20
|
||
#define RDP_RES_SWI 0x21
|
||
#define RDP_RES_FATAL 0x5e
|
||
#define RDP_RES_VALUE 0x5f
|
||
#define RDP_RES_VALUE_LITTLE_ENDIAN 240
|
||
#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));
|
||
|
||
|
||
/* Stuff for talking to the serial layer. */
|
||
|
||
static unsigned char
|
||
get_byte ()
|
||
{
|
||
int c = SERIAL_READCHAR (io, timeout);
|
||
|
||
if (remote_debug)
|
||
printf ("[%02x]\n", c);
|
||
|
||
if (c == SERIAL_TIMEOUT)
|
||
{
|
||
if (timeout == 0)
|
||
return (unsigned char) c;
|
||
|
||
error ("Timeout reading from remote_system");
|
||
}
|
||
|
||
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 ()
|
||
{
|
||
unsigned int val = 0;
|
||
unsigned int c;
|
||
int n;
|
||
for (n = 0; n < 4; n++)
|
||
{
|
||
c = get_byte ();
|
||
val |= c << (n * 8);
|
||
}
|
||
return val;
|
||
}
|
||
|
||
static void
|
||
put_byte (val)
|
||
char val;
|
||
{
|
||
if (remote_debug)
|
||
printf ("(%02x)\n", val);
|
||
SERIAL_WRITE (io, &val, 1);
|
||
}
|
||
|
||
static void
|
||
put_word (val)
|
||
int val;
|
||
{
|
||
/* We always send in little endian */
|
||
unsigned char b[4];
|
||
b[0] = val;
|
||
b[1] = val >> 8;
|
||
b[2] = val >> 16;
|
||
b[3] = val >> 24;
|
||
|
||
if (remote_debug)
|
||
printf ("(%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.
|
||
|
||
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 (cold, tty)
|
||
int cold;
|
||
int tty;
|
||
{
|
||
int sync = 0;
|
||
int type = cold ? RDP_OPEN_TYPE_COLD : RDP_OPEN_TYPE_WARM;
|
||
int baudtry = 9600;
|
||
|
||
time_t now = time (0);
|
||
time_t stop_time = now + 10; /* Try and sync for 10 seconds, then give up */
|
||
|
||
|
||
while (time (0) < stop_time && !sync)
|
||
{
|
||
int restype;
|
||
QUIT;
|
||
|
||
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:
|
||
break;
|
||
case RDP_RESET:
|
||
/* Sent at start of reset process: ignore */
|
||
break;
|
||
default:
|
||
printf_unfiltered ("%c", isgraph (restype) ? restype : ' ');
|
||
break;
|
||
}
|
||
}
|
||
|
||
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)
|
||
printf_unfiltered ("[%02x]\n", restype);
|
||
|
||
switch (restype)
|
||
{
|
||
case SERIAL_TIMEOUT:
|
||
break;
|
||
case RDP_RESET:
|
||
while ((restype = SERIAL_READCHAR (io, 1)) == RDP_RESET)
|
||
;
|
||
while ((restype = SERIAL_READCHAR (io, 1)) > 0)
|
||
{
|
||
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");
|
||
break;
|
||
default:
|
||
break;
|
||
case RDP_RES_VALUE:
|
||
{
|
||
int resval = SERIAL_READCHAR (io, 1);
|
||
|
||
if (remote_debug)
|
||
printf_unfiltered ("[%02x]\n", resval);
|
||
|
||
switch (resval)
|
||
{
|
||
case SERIAL_TIMEOUT:
|
||
break;
|
||
case RDP_RES_VALUE_LITTLE_ENDIAN:
|
||
target_byte_order = LITTLE_ENDIAN;
|
||
sync = 1;
|
||
break;
|
||
case RDP_RES_VALUE_BIG_ENDIAN:
|
||
target_byte_order = BIG_ENDIAN;
|
||
sync = 1;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
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)
|
||
{
|
||
unsigned int val;
|
||
int *pi;
|
||
int *pstat;
|
||
char *pc;
|
||
int i;
|
||
switch (*template++)
|
||
{
|
||
case 'b':
|
||
val = va_arg (alist, int);
|
||
*dst++ = val;
|
||
break;
|
||
case 'w':
|
||
val = va_arg (alist, int);
|
||
*dst++ = val;
|
||
*dst++ = val >> 8;
|
||
*dst++ = val >> 16;
|
||
*dst++ = val >> 24;
|
||
break;
|
||
case 'S':
|
||
val = get_byte ();
|
||
if (val != RDP_RES_VALUE)
|
||
{
|
||
printf_unfiltered ("got bad res value of %d, %x\n", val, val);
|
||
}
|
||
break;
|
||
case 'V':
|
||
pstat = va_arg (alist, int *);
|
||
pi = va_arg (alist, int *);
|
||
|
||
*pstat = get_byte ();
|
||
/* Check the result was zero, if not read the syndrome */
|
||
if (*pstat)
|
||
{
|
||
*pi = get_word ();
|
||
}
|
||
break;
|
||
case 'Z':
|
||
/* 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 */
|
||
pi = va_arg (alist, int *);
|
||
*pi = get_word ();
|
||
break;
|
||
case 'P':
|
||
/* Read in some bytes from the target. */
|
||
pc = va_arg (alist, char *);
|
||
val = va_arg (alist, int);
|
||
for (i = 0; i < val; i++)
|
||
{
|
||
pc[i] = get_byte ();
|
||
}
|
||
break;
|
||
case 'p':
|
||
/* send what's being pointed at */
|
||
pc = va_arg (alist, char *);
|
||
val = va_arg (alist, int);
|
||
dst = buf;
|
||
SERIAL_WRITE (io, pc, val);
|
||
break;
|
||
case '-':
|
||
/* Send whats in the queue */
|
||
if (dst != buf)
|
||
{
|
||
SERIAL_WRITE (io, buf, dst - buf);
|
||
dst = buf;
|
||
}
|
||
break;
|
||
case 'B':
|
||
pi = va_arg (alist, int *);
|
||
*pi = get_byte ();
|
||
break;
|
||
default:
|
||
abort ();
|
||
}
|
||
}
|
||
va_end (args);
|
||
|
||
if (dst != buf)
|
||
abort ();
|
||
}
|
||
|
||
|
||
static int
|
||
rdp_write (memaddr, buf, len)
|
||
CORE_ADDR memaddr;
|
||
char *buf;
|
||
int len;
|
||
{
|
||
int res;
|
||
int val;
|
||
|
||
send_rdp ("bww-p-SV", RDP_MEM_WRITE, memaddr, len, buf, len, &res, &val);
|
||
|
||
if (res)
|
||
{
|
||
return val;
|
||
}
|
||
return len;
|
||
}
|
||
|
||
|
||
static int
|
||
rdp_read (memaddr, buf, len)
|
||
CORE_ADDR memaddr;
|
||
char *buf;
|
||
int len;
|
||
{
|
||
int res;
|
||
int val;
|
||
send_rdp ("bww-S-P-V",
|
||
RDP_MEM_READ, memaddr, len,
|
||
buf, len,
|
||
&res, &val);
|
||
if (res)
|
||
{
|
||
return val;
|
||
}
|
||
return len;
|
||
}
|
||
|
||
static void
|
||
rdp_fetch_one_register (mask, buf)
|
||
int mask;
|
||
char *buf;
|
||
{
|
||
int val;
|
||
send_rdp ("bbw-SWZ", RDP_CPU_READ, RDP_CPU_READWRITE_MODE_CURRENT, mask, &val);
|
||
store_signed_integer (buf, 4, val);
|
||
}
|
||
|
||
static void
|
||
rdp_fetch_one_fpu_register (mask, buf)
|
||
int mask;
|
||
char *buf;
|
||
{
|
||
#if 0
|
||
/* !!! Since the PIE board doesn't work as documented,
|
||
and it doesn't have FPU hardware anyway and since it
|
||
slows everything down, I've disabled this. */
|
||
int val;
|
||
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
||
{
|
||
/* this guy is only a word */
|
||
send_rdp ("bbw-SWZ", RDP_COPRO_READ, FPU_COPRO_NUMBER, mask, &val);
|
||
store_signed_integer (buf, 4, val);
|
||
}
|
||
else
|
||
{
|
||
/* 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);
|
||
}
|
||
#endif
|
||
memset (buf, 0, MAX_REGISTER_RAW_SIZE);
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_store_one_register (mask, buf)
|
||
int mask;
|
||
char *buf;
|
||
{
|
||
int val = extract_unsigned_integer (buf, 4);
|
||
|
||
send_rdp ("bbww-SZ",
|
||
RDP_CPU_WRITE, RDP_CPU_READWRITE_MODE_CURRENT, mask, val);
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_store_one_fpu_register (mask, buf)
|
||
int mask;
|
||
char *buf;
|
||
{
|
||
#if 0
|
||
/* See comment in fetch_one_fpu_register */
|
||
if (mask == RDP_FPU_READWRITE_MASK_FPS)
|
||
{
|
||
int val = extract_unsigned_integer (buf, 4);
|
||
/* this guy is only a word */
|
||
send_rdp ("bbww-SZ", RDP_COPRO_WRITE,
|
||
FPU_COPRO_NUMBER,
|
||
mask, val);
|
||
}
|
||
else
|
||
{
|
||
/* There are 12 bytes long
|
||
!! fixme about endianness
|
||
*/
|
||
int dummy = 0;
|
||
/* I've seen these come as four words, not the three advertized !! */
|
||
printf ("Sending mask %x\n", mask);
|
||
send_rdp ("bbwwwww-SZ",
|
||
RDP_COPRO_WRITE,
|
||
FPU_COPRO_NUMBER,
|
||
mask,
|
||
*(int *) (buf + 0),
|
||
*(int *) (buf + 4),
|
||
*(int *) (buf + 8),
|
||
0);
|
||
|
||
printf ("done mask %x\n", mask);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
|
||
/* Convert between GDB requests and the RDP layer. */
|
||
|
||
static void
|
||
remote_rdp_fetch_register (regno)
|
||
int regno;
|
||
{
|
||
if (regno == -1)
|
||
{
|
||
for (regno = 0; regno < NUM_REGS; regno++)
|
||
remote_rdp_fetch_register (regno);
|
||
}
|
||
else
|
||
{
|
||
char buf[MAX_REGISTER_RAW_SIZE];
|
||
if (regno < 15)
|
||
rdp_fetch_one_register (1 << regno, buf);
|
||
else if (regno == PC_REGNUM)
|
||
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_PC, buf);
|
||
else if (regno == PS_REGNUM)
|
||
rdp_fetch_one_register (RDP_CPU_READWRITE_MASK_CPSR, buf);
|
||
else if (regno == 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
|
||
{
|
||
printf ("Help me with fetch reg %d\n", regno);
|
||
}
|
||
supply_register (regno, buf);
|
||
}
|
||
}
|
||
|
||
|
||
static void
|
||
remote_rdp_store_register (regno)
|
||
int regno;
|
||
{
|
||
if (regno == -1)
|
||
{
|
||
for (regno = 0; regno < NUM_REGS; regno++)
|
||
remote_rdp_store_register (regno);
|
||
}
|
||
else
|
||
{
|
||
char tmp[MAX_REGISTER_RAW_SIZE];
|
||
read_register_gen (regno, tmp);
|
||
if (regno < 15)
|
||
rdp_store_one_register (1 << regno, tmp);
|
||
else if (regno == PC_REGNUM)
|
||
rdp_store_one_register (RDP_CPU_READWRITE_MASK_PC, tmp);
|
||
else if (regno == 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
|
||
{
|
||
printf ("Help me with reg %d\n", regno);
|
||
}
|
||
}
|
||
}
|
||
|
||
static void
|
||
remote_rdp_kill ()
|
||
{
|
||
callback->shutdown (callback);
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_info ()
|
||
{
|
||
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_STEP,
|
||
&ds.step_info);
|
||
send_rdp ("bw-S-W-Z", RDP_INFO, RDP_INFO_ABOUT_BREAK,
|
||
&ds.break_info);
|
||
send_rdp ("bw-S-WW-Z", RDP_INFO, RDP_INFO_ABOUT_TARGET,
|
||
&ds.target_info,
|
||
&ds.model_info);
|
||
|
||
ds.can_step = ds.step_info & RDP_INFO_ABOUT_STEP_1;
|
||
|
||
ds.rdi_level = (ds.target_info >> 5) & 3;
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_execute_start ()
|
||
{
|
||
/* Start it off, but don't wait for it */
|
||
send_rdp ("bb-", RDP_EXEC, RDP_EXEC_TYPE_SYNC);
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_set_command_line (command, args)
|
||
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)
|
||
free (commandline);
|
||
|
||
commandline = malloc (strlen (command) + strlen (args) + 2);
|
||
if (commandline != NULL)
|
||
{
|
||
strcpy (commandline, command);
|
||
strcat (commandline, " ");
|
||
strcat (commandline, args);
|
||
}
|
||
}
|
||
|
||
static void
|
||
rdp_catch_vectors ()
|
||
{
|
||
/*
|
||
** 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 a_string 3
|
||
|
||
|
||
typedef struct
|
||
{
|
||
CORE_ADDR n;
|
||
const char *s;
|
||
}
|
||
argsin;
|
||
|
||
#define ABYTE 1
|
||
#define AWORD 2
|
||
#define ASTRING 3
|
||
#define ADDRLEN 4
|
||
|
||
#define SWI_WriteC 0x0
|
||
#define SWI_Write0 0x2
|
||
#define SWI_ReadC 0x4
|
||
#define SWI_CLI 0x5
|
||
#define SWI_GetEnv 0x10
|
||
#define SWI_Exit 0x11
|
||
#define SWI_EnterOS 0x16
|
||
|
||
#define SWI_GetErrno 0x60
|
||
#define SWI_Clock 0x61
|
||
|
||
#define SWI_Time 0x63
|
||
#define SWI_Remove 0x64
|
||
#define SWI_Rename 0x65
|
||
#define SWI_Open 0x66
|
||
|
||
#define SWI_Close 0x68
|
||
#define SWI_Write 0x69
|
||
#define SWI_Read 0x6a
|
||
#define SWI_Seek 0x6b
|
||
#define SWI_Flen 0x6c
|
||
|
||
#define SWI_IsTTY 0x6e
|
||
#define SWI_TmpNam 0x6f
|
||
#define SWI_InstallHandler 0x70
|
||
#define SWI_GenerateError 0x71
|
||
|
||
|
||
static int
|
||
exec_swi (swi, args)
|
||
int swi;
|
||
argsin *args;
|
||
{
|
||
int i;
|
||
char c;
|
||
switch (swi)
|
||
{
|
||
case SWI_WriteC:
|
||
callback->write_stdout (callback, &c, 1);
|
||
return 0;
|
||
case SWI_Write0:
|
||
for (i = 0; i < args->n; i++)
|
||
callback->write_stdout (callback, args->s, strlen (args->s));
|
||
return 0;
|
||
case SWI_ReadC:
|
||
callback->read_stdin (callback, &c, 1);
|
||
args->n = c;
|
||
return 1;
|
||
case SWI_CLI:
|
||
args->n = callback->system (callback, args->s);
|
||
return 1;
|
||
case SWI_GetErrno:
|
||
args->n = callback->get_errno (callback);
|
||
return 1;
|
||
case SWI_Time:
|
||
args->n = callback->time (callback, NULL);
|
||
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;
|
||
|
||
if (args[1].n & 4)
|
||
{
|
||
i |= O_CREAT;
|
||
}
|
||
|
||
if (args[1].n & 8)
|
||
i |= O_APPEND;
|
||
|
||
args->n = callback->open (callback, args->s, i);
|
||
return 1;
|
||
|
||
case SWI_Close:
|
||
args->n = callback->close (callback, args->n);
|
||
return 1;
|
||
|
||
case SWI_Write:
|
||
args->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;
|
||
return 1;
|
||
}
|
||
|
||
case SWI_Seek:
|
||
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);
|
||
callback->lseek (callback, args->n, old, 0);
|
||
return 1;
|
||
}
|
||
|
||
case SWI_IsTTY:
|
||
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);
|
||
}
|
||
else
|
||
remote_rdp_xfer_inferior_memory (args[0].n, "", 1, 1, 0);
|
||
return 1;
|
||
|
||
default:
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
static void
|
||
handle_swi ()
|
||
{
|
||
argsin args[3];
|
||
char *buf;
|
||
int len;
|
||
int count = 0;
|
||
|
||
int swino = get_word ();
|
||
int type = get_byte ();
|
||
while (type != 0)
|
||
{
|
||
switch (type & 0x3)
|
||
{
|
||
case ABYTE:
|
||
args[count].n = get_byte ();
|
||
break;
|
||
|
||
case AWORD:
|
||
args[count].n = get_word ();
|
||
break;
|
||
|
||
case ASTRING:
|
||
/* If the word is under 32 bytes it will be sent otherwise
|
||
an address to it is passed. Also: Special case of 255 */
|
||
|
||
len = get_byte ();
|
||
if (len > 32)
|
||
{
|
||
if (len == 255)
|
||
{
|
||
len = get_word ();
|
||
}
|
||
buf = alloca (len);
|
||
remote_rdp_xfer_inferior_memory (get_word (),
|
||
buf,
|
||
len,
|
||
0,
|
||
0);
|
||
}
|
||
else
|
||
{
|
||
int i;
|
||
buf = alloca (len + 1);
|
||
for (i = 0; i < len; i++)
|
||
buf[i] = get_byte ();
|
||
buf[i] = 0;
|
||
}
|
||
args[count].n = len;
|
||
args[count].s = buf;
|
||
break;
|
||
|
||
default:
|
||
error ("Unimplented SWI argument");
|
||
}
|
||
|
||
type = type >> 2;
|
||
count++;
|
||
}
|
||
|
||
if (exec_swi (swino, args))
|
||
{
|
||
/* 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
|
||
a word all the time, so thats what I do! */
|
||
send_rdp ("bbw-", RDP_OSOpReply, RDP_OSOpWord, args[0].n);
|
||
}
|
||
else
|
||
{
|
||
send_rdp ("bb-", RDP_OSOpReply, RDP_OSOpNothing);
|
||
}
|
||
}
|
||
|
||
static void
|
||
rdp_execute_finish ()
|
||
{
|
||
int running = 1;
|
||
|
||
while (running)
|
||
{
|
||
int res;
|
||
res = SERIAL_READCHAR (io, 1);
|
||
while (res == SERIAL_TIMEOUT)
|
||
{
|
||
QUIT;
|
||
printf_filtered ("Waiting for target..\n");
|
||
res = SERIAL_READCHAR (io, 1);
|
||
}
|
||
|
||
switch (res)
|
||
{
|
||
case RDP_RES_SWI:
|
||
handle_swi ();
|
||
break;
|
||
case RDP_RES_VALUE:
|
||
send_rdp ("B", &ds.rdi_stopped_status);
|
||
running = 0;
|
||
break;
|
||
case RDP_RESET:
|
||
printf_filtered ("Target reset\n");
|
||
running = 0;
|
||
break;
|
||
default:
|
||
printf_filtered ("Ignoring %x\n", res);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static void
|
||
rdp_execute ()
|
||
{
|
||
rdp_execute_start ();
|
||
rdp_execute_finish ();
|
||
}
|
||
|
||
static int
|
||
remote_rdp_insert_breakpoint (addr, save)
|
||
CORE_ADDR addr;
|
||
char *save;
|
||
{
|
||
int res;
|
||
if (ds.rdi_level > 0)
|
||
{
|
||
send_rdp ("bwb-SWB",
|
||
RDP_SET_BREAK,
|
||
addr,
|
||
RDP_SET_BREAK_TYPE_PC_EQUAL | RDP_SET_BREAK_TYPE_GET_HANDLE,
|
||
save,
|
||
&res);
|
||
}
|
||
else
|
||
{
|
||
send_rdp ("bwb-SB",
|
||
RDP_SET_BREAK,
|
||
addr,
|
||
RDP_SET_BREAK_TYPE_PC_EQUAL,
|
||
&res);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
static int
|
||
remote_rdp_remove_breakpoint (addr, save)
|
||
CORE_ADDR addr;
|
||
char *save;
|
||
{
|
||
int res;
|
||
if (ds.rdi_level > 0)
|
||
{
|
||
send_rdp ("b-p-S-B",
|
||
RDP_CLEAR_BREAK,
|
||
save, 4,
|
||
&res);
|
||
}
|
||
else
|
||
{
|
||
send_rdp ("bw-S-B",
|
||
RDP_CLEAR_BREAK,
|
||
addr,
|
||
&res);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
static void
|
||
rdp_step ()
|
||
{
|
||
if (ds.can_step && 0)
|
||
{
|
||
/* The pie board can't do steps so I can't test this, and
|
||
the other code will always work. */
|
||
int status;
|
||
send_rdp ("bbw-S-B",
|
||
RDP_STEP, 0, 1,
|
||
&status);
|
||
}
|
||
else
|
||
{
|
||
char handle[4];
|
||
CORE_ADDR pc = read_register (PC_REGNUM);
|
||
pc = arm_get_next_pc (pc);
|
||
remote_rdp_insert_breakpoint (pc, &handle);
|
||
rdp_execute ();
|
||
remote_rdp_remove_breakpoint (pc, &handle);
|
||
}
|
||
}
|
||
|
||
static void
|
||
remote_rdp_open (args, from_tty)
|
||
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);
|
||
|
||
if (!io)
|
||
perror_with_name (args);
|
||
|
||
SERIAL_RAW (io);
|
||
|
||
rdp_init (1, from_tty);
|
||
|
||
|
||
if (from_tty)
|
||
{
|
||
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, & not_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);
|
||
flush_cached_frames ();
|
||
registers_changed ();
|
||
stop_pc = read_pc ();
|
||
set_current_frame (create_new_frame (read_fp (), stop_pc));
|
||
select_frame (get_current_frame (), 0);
|
||
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;
|
||
{
|
||
callback->shutdown (callback);
|
||
if (io)
|
||
SERIAL_CLOSE (io);
|
||
io = 0;
|
||
}
|
||
|
||
|
||
/* 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;
|
||
{
|
||
if (step)
|
||
rdp_step ();
|
||
else
|
||
rdp_execute ();
|
||
}
|
||
|
||
/* Wait for inferior process to do something. Return pid of child,
|
||
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;
|
||
{
|
||
switch (ds.rdi_stopped_status)
|
||
{
|
||
default:
|
||
case RDP_RES_RESET:
|
||
case RDP_RES_SWI:
|
||
status->kind = TARGET_WAITKIND_EXITED;
|
||
status->value.integer = read_register (0);
|
||
break;
|
||
case RDP_RES_AT_BREAKPOINT:
|
||
status->kind = TARGET_WAITKIND_STOPPED;
|
||
/* The signal in sigrc is a host signal. That probably
|
||
should be fixed. */
|
||
status->value.sig = TARGET_SIGNAL_TRAP;
|
||
break;
|
||
#if 0
|
||
case rdp_signalled:
|
||
status->kind = TARGET_WAITKIND_SIGNALLED;
|
||
/* The signal in sigrc is a host signal. That probably
|
||
should be fixed. */
|
||
status->value.sig = target_signal_from_host (sigrc);
|
||
break;
|
||
#endif
|
||
}
|
||
|
||
return inferior_pid;
|
||
}
|
||
|
||
/* Get ready to modify the registers array. On machines which store
|
||
individual registers, this doesn't need to do anything. On machines
|
||
which store all the registers in one fell swoop, this makes sure
|
||
that registers contains all the registers from the program being
|
||
debugged. */
|
||
|
||
static void
|
||
remote_rdp_prepare_to_store ()
|
||
{
|
||
/* Do nothing, since we can store individual regs */
|
||
}
|
||
|
||
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 */
|
||
{
|
||
/* I infer from D Taylor's code that there's a limit on the amount
|
||
we can transfer in one chunk.. */
|
||
int done = 0;
|
||
while (done < len)
|
||
{
|
||
int justdone;
|
||
int thisbite = len - done;
|
||
if (thisbite > RDP_MOUTHFULL)
|
||
thisbite = RDP_MOUTHFULL;
|
||
|
||
QUIT;
|
||
|
||
if (write)
|
||
{
|
||
justdone = rdp_write (memaddr + done, myaddr + done, thisbite);
|
||
}
|
||
else
|
||
{
|
||
justdone = rdp_read (memaddr + done, myaddr + done, thisbite);
|
||
}
|
||
|
||
done += justdone;
|
||
|
||
if (justdone != thisbite)
|
||
break;
|
||
}
|
||
return done;
|
||
}
|
||
|
||
|
||
|
||
struct yn
|
||
{
|
||
const char *name;
|
||
int bit;
|
||
};
|
||
static struct yn stepinfo[] =
|
||
{
|
||
{"Step more than one instruction", RDP_INFO_ABOUT_STEP_GT_1},
|
||
{"Step to jump", RDP_INFO_ABOUT_STEP_TO_JMP},
|
||
{"Step one instruction", RDP_INFO_ABOUT_STEP_1},
|
||
{0}
|
||
};
|
||
|
||
static struct yn breakinfo[] =
|
||
{
|
||
{"comparison breakpoints supported", RDP_INFO_ABOUT_BREAK_COMP},
|
||
{"range breakpoints supported", RDP_INFO_ABOUT_BREAK_RANGE},
|
||
{"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 word reads supported", RDP_INFO_ABOUT_BREAK_WORD_READ},
|
||
{"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 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},
|
||
{"conditional breakpoints supported", RDP_INFO_ABOUT_BREAK_COND},
|
||
{0}
|
||
};
|
||
|
||
|
||
static void
|
||
dump_bits (t, info)
|
||
struct yn *t;
|
||
int info;
|
||
{
|
||
while (t->name)
|
||
{
|
||
printf_unfiltered (" %-45s : %s\n", t->name, (info & t->bit) ? "Yes" : "No");
|
||
t++;
|
||
}
|
||
}
|
||
|
||
static void
|
||
remote_rdp_files_info (target)
|
||
struct target_ops *target;
|
||
{
|
||
printf_filtered ("Target capabilities:\n");
|
||
dump_bits (stepinfo, ds.step_info);
|
||
dump_bits (breakinfo, ds.break_info);
|
||
printf_unfiltered ("target level RDI %x\n", (ds.target_info >> 5) & 3);
|
||
}
|
||
|
||
|
||
static void
|
||
remote_rdp_create_inferior (exec_file, allargs, env)
|
||
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_pid = 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);
|
||
}
|
||
|
||
/* Accept any stray run/attach commands */
|
||
static int
|
||
remote_rdp_can_run()
|
||
{
|
||
return 1;
|
||
}
|
||
|
||
/* Attach doesn't need to do anything */
|
||
static void
|
||
remote_rdp_attach(args, from_tty)
|
||
char * args;
|
||
int from_tty;
|
||
{
|
||
return;
|
||
}
|
||
|
||
/* Define the target subroutine names */
|
||
|
||
struct target_ops remote_rdp_ops ;
|
||
|
||
static void init_remote_rdp_ops(void)
|
||
{
|
||
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_detach = NULL;
|
||
remote_rdp_ops.to_resume = remote_rdp_resume;
|
||
remote_rdp_ops.to_wait = remote_rdp_wait;
|
||
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_mourn_inferior = generic_mourn_inferior;
|
||
remote_rdp_ops.to_can_run = remote_rdp_can_run;
|
||
remote_rdp_ops.to_notice_signals = 0;
|
||
remote_rdp_ops.to_thread_alive = 0;
|
||
remote_rdp_ops.to_stop = 0;
|
||
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 ()
|
||
{
|
||
init_remote_rdp_ops() ;
|
||
add_target (&remote_rdp_ops);
|
||
}
|