diff options
Diffstat (limited to 'gdb/remote-rdp.c')
| -rw-r--r-- | gdb/remote-rdp.c | 1512 |
1 files changed, 1512 insertions, 0 deletions
diff --git a/gdb/remote-rdp.c b/gdb/remote-rdp.c new file mode 100644 index 0000000..1d596a4 --- /dev/null +++ b/gdb/remote-rdp.c @@ -0,0 +1,1512 @@ +/* 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) + ; + do + { + printf_unfiltered ("%c", isgraph (restype) ? restype : ' '); + } + while ((restype = SERIAL_READCHAR (io, 1)) > 0); + + if (tty) + { + printf_unfiltered ("\nThe board has sent notification that it was reset.\n"); + printf_unfiltered ("Waiting for it to settle down...\n"); + } + sleep (3); + if (tty) + printf_unfiltered ("\nTrying again.\n"); + cold = 0; + break; + + default: + break; + + case RDP_RES_VALUE: + { + int resval = SERIAL_READCHAR (io, 1); + + if (remote_debug) + 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 + + +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +static int translate_open_mode[] = +{ + O_RDONLY, /* "r" */ + O_RDONLY+O_BINARY, /* "rb" */ + O_RDWR, /* "r+" */ + O_RDWR +O_BINARY, /* "r+b" */ + O_WRONLY +O_CREAT+O_TRUNC, /* "w" */ + O_WRONLY+O_BINARY+O_CREAT+O_TRUNC, /* "wb" */ + O_RDWR +O_CREAT+O_TRUNC, /* "w+" */ + O_RDWR +O_BINARY+O_CREAT+O_TRUNC, /* "w+b" */ + O_WRONLY +O_APPEND+O_CREAT,/* "a" */ + O_WRONLY+O_BINARY+O_APPEND+O_CREAT,/* "ab" */ + O_RDWR +O_APPEND+O_CREAT,/* "a+" */ + O_RDWR +O_BINARY+O_APPEND+O_CREAT /* "a+b" */ +}; + +static int +exec_swi (swi, args) + int swi; + argsin *args; +{ + 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_Clock : + /* return number of centi-seconds... */ + args->n = +#ifdef CLOCKS_PER_SEC + (CLOCKS_PER_SEC >= 100) + ? (clock() / (CLOCKS_PER_SEC / 100)) + : ((clock() * 100) / CLOCKS_PER_SEC) ; +#else + /* presume unix... clock() returns microseconds */ + clock() / 10000 ; +#endif + return 1 ; + + case SWI_Remove: + args->n = callback->unlink (callback, args->s); + return 1; + case SWI_Rename: + args->n = callback->rename (callback, args[0].s, args[1].s); + return 1; + + case SWI_Open: + /* Now we need to decode the Demon open mode */ + i = translate_open_mode[args[1].n]; + + /* Filename ":tt" is special: it denotes stdin/out */ + if (strcmp(args->s,":tt")==0) + { + if (i == O_RDONLY ) /* opening tty "r" */ + args->n = 0 /* stdin */ ; + else + args->n = 1 /* stdout */ ; + } + else + 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: + /* Return the number of bytes *not* written */ + args->n = args[1].n - + callback->write (callback, args[0].n, args[1].s, args[1].n); + return 1; + + case SWI_Read: + { + char *copy = alloca (args[2].n); + int done = callback->read (callback, args[0].n, copy, args[2].n); + if (done > 0) + remote_rdp_xfer_inferior_memory (args[1].n, copy, done, 1, 0); + args->n = args[2].n-done; + return 1; + } + + case SWI_Seek: + /* Return non-zero on failure */ + args->n = callback->lseek (callback, args[0].n, args[1].n, 0) < 0; + return 1; + + case SWI_Flen: + { + long old = callback->lseek (callback, args->n, 0, SEEK_CUR); + args->n = callback->lseek (callback, args->n, 0, SEEK_END); + 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_post_attach = NULL; + remote_rdp_ops.to_require_attach = NULL; + remote_rdp_ops.to_detach = NULL; + remote_rdp_ops.to_require_detach = NULL; + remote_rdp_ops.to_resume = remote_rdp_resume; + remote_rdp_ops.to_wait = remote_rdp_wait; + remote_rdp_ops.to_post_wait = NULL; + remote_rdp_ops.to_fetch_registers = remote_rdp_fetch_register; + remote_rdp_ops.to_store_registers = remote_rdp_store_register; + remote_rdp_ops.to_prepare_to_store = remote_rdp_prepare_to_store; + remote_rdp_ops.to_xfer_memory = remote_rdp_xfer_inferior_memory; + remote_rdp_ops.to_files_info = remote_rdp_files_info; + remote_rdp_ops.to_insert_breakpoint = remote_rdp_insert_breakpoint; + remote_rdp_ops.to_remove_breakpoint = remote_rdp_remove_breakpoint; + remote_rdp_ops.to_terminal_init = NULL; + remote_rdp_ops.to_terminal_inferior = NULL; + remote_rdp_ops.to_terminal_ours_for_output = NULL; + remote_rdp_ops.to_terminal_ours = NULL; + remote_rdp_ops.to_terminal_info = NULL; + remote_rdp_ops.to_kill = remote_rdp_kill; + remote_rdp_ops.to_load = generic_load; + remote_rdp_ops.to_lookup_symbol = NULL; + remote_rdp_ops.to_create_inferior = remote_rdp_create_inferior; + remote_rdp_ops.to_post_startup_inferior = NULL; + remote_rdp_ops.to_acknowledge_created_inferior = NULL; + remote_rdp_ops.to_clone_and_follow_inferior = NULL; + remote_rdp_ops.to_post_follow_inferior_by_clone = NULL; + remote_rdp_ops.to_insert_fork_catchpoint = NULL; + remote_rdp_ops.to_remove_fork_catchpoint = NULL; + remote_rdp_ops.to_insert_vfork_catchpoint = NULL; + remote_rdp_ops.to_remove_vfork_catchpoint = NULL; + remote_rdp_ops.to_has_forked = NULL; + remote_rdp_ops.to_has_vforked = NULL; + remote_rdp_ops.to_can_follow_vfork_prior_to_exec = NULL; + remote_rdp_ops.to_post_follow_vfork = NULL; + remote_rdp_ops.to_insert_exec_catchpoint = NULL; + remote_rdp_ops.to_remove_exec_catchpoint = NULL; + remote_rdp_ops.to_has_execd = NULL; + remote_rdp_ops.to_reported_exec_events_per_exec_call = NULL; + remote_rdp_ops.to_has_exited = NULL; + remote_rdp_ops.to_mourn_inferior = generic_mourn_inferior; + remote_rdp_ops.to_can_run = 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_pid_to_exec_file = NULL; + remote_rdp_ops.to_core_file_to_sym_file = NULL; + remote_rdp_ops.to_stratum = process_stratum; + remote_rdp_ops.DONT_USE = NULL; + remote_rdp_ops.to_has_all_memory = 1; + remote_rdp_ops.to_has_memory = 1; + remote_rdp_ops.to_has_stack = 1; + remote_rdp_ops.to_has_registers = 1; + remote_rdp_ops.to_has_execution = 1; + remote_rdp_ops.to_sections = NULL; + remote_rdp_ops.to_sections_end = NULL; + remote_rdp_ops.to_magic = OPS_MAGIC; +} + +void +_initialize_remote_rdp () +{ + init_remote_rdp_ops() ; + add_target (&remote_rdp_ops); +} |