/* Remote debugging interface for Hitachi E7000 ICE, for GDB
- Copyright 1993, 1994, 1996 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1996, 1997, 1998 Free Software Foundation, Inc.
Contributed by Cygnus Support.
Written by Steve Chamberlain for Cygnus Support.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
/* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and
Hitachi-SH processor. It has serial port and a lan port.
#include "defs.h"
#include "gdbcore.h"
+#include "gdbarch.h"
#include "inferior.h"
#include "target.h"
#include "wait.h"
#include "command.h"
#include <signal.h>
#include "gdb_string.h"
+#include "gdbcmd.h"
#include <sys/types.h>
#include "serial.h"
#include "remote-utils.h"
#include "symfile.h"
#include <time.h>
+#include <ctype.h>
-#if 0
-#define HARD_BREAKPOINTS
-#define BC_BREAKPOINTS 0
+
+#if 1
+#define HARD_BREAKPOINTS /* Now handled by set option. */
+#define BC_BREAKPOINTS use_hard_breakpoints
#endif
#define CTRLC 0x03
static void expect_prompt PARAMS ((void));
+static int e7000_parse_device PARAMS ((char *args, char *dev_name,
+ int baudrate));
/* Variables. */
static serial_t e7000_desc;
+/* Allow user to chose between using hardware breakpoints or memory. */
+static int use_hard_breakpoints = 0; /* use sw breakpoints by default */
+
/* Nonzero if using the tcp serial driver. */
-static int using_tcp;
+static int using_tcp; /* direct tcp connection to target */
+static int using_tcp_remote; /* indirect connection to target
+ via tcp to controller */
/* Nonzero if using the pc isa card. */
static int ctrl_c;
-static int timeout = 5;
+static int timeout = 20;
/* Send data to e7000debug. */
error ("Use \"target e7000 ...\" first.");
if (remote_debug)
- printf("Sending %s\n", buf);
+ printf_unfiltered ("Sending %s\n", buf);
if (SERIAL_WRITE (e7000_desc, buf, strlen (buf)))
- fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
+ fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
/* And expect to see it echoed, unless using the pc interface */
#if 0
}
/* Read a character from the remote system, doing all the fancy timeout
- stuff. */
+ stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars,
+ returns -1, else returns next char. Discards chars > 127. */
static int
readchar (timeout)
echo = 0;
error ("Timeout reading from remote system.");
}
- if (remote_debug)
+ else if (c < 0)
+ error ("Serial communication error");
+
+ if (remote_debug)
{
- putchar (c);
- fflush (stdout);
+ putchar_unfiltered (c);
+ gdb_flush (gdb_stdout);
}
return normal (c);
p++;
p &= 7;
- if (x >= ' ')
- {
+ if (x >= ' ')
+ {
b[p][0] = x;
b[p][1] = 0;
}
else
{
- sprintf(b[p], "<%d>", x);
+ sprintf (b[p], "<%d>", x);
}
return b[p];
while (1)
{
c = readchar (timeout);
+#if 0
notice_quit ();
- if (quit_flag == 1)
+ if (quit_flag == 1)
{
if (ctrl_c)
{
- putchar_e7000(CTRLC);
+ putchar_e7000 (CTRLC);
--ctrl_c;
}
- else
+ else
{
quit ();
}
}
-
- if (c == SERIAL_ERROR)
- {
- error ("Serial communication error");
- }
- if (echo || remote_debug)
+#endif
+
+ if (echo)
{
if (c == '\r' || c == '\n')
{
if (!nl)
- putchar ('\n');
+ putchar_unfiltered ('\n');
nl = 1;
}
else
{
nl = 0;
- putchar (c);
+ putchar_unfiltered (c);
}
- fflush (stdout);
+ gdb_flush (gdb_stdout);
}
if (normal (c) == normal (*p++))
{
error ("Can't pass arguments to remote E7000DEBUG process");
if (execfile == 0 || exec_bfd == 0)
- error ("No exec file specified");
+ error ("No executable file specified");
entry_pt = (int) bfd_get_start_address (exec_bfd);
dir = next (&args);
if (from_tty)
{
- printf ("Set info to %s %s %s %s\n", machine, user, passwd, dir);
+ printf_unfiltered ("Set info to %s %s %s %s\n", machine, user, passwd, dir);
}
}
else
char buf[200];
int oldtimeout = timeout;
- timeout = 10;
+ timeout = remote_timeout;
sprintf (buf, "ftp %s\r", machine);
puts_e7000debug (buf);
timeout = oldtimeout;
}
-static void
-e7000_open (args, from_tty)
+static int
+e7000_parse_device (args, dev_name, baudrate)
char *args;
- int from_tty;
+ char *dev_name;
+ int baudrate;
{
- int n;
- int loop;
- char junk[100];
- int sync;
- target_preopen (from_tty);
-
- n = 0;
+ char junk[128];
+ int n = 0;
if (args && strcasecmp (args, "pc") == 0)
{
strcpy (dev_name, args);
+ using_pc = 1;
}
- else
+ else
{
- if (args)
+ /* FIXME! temp hack to allow use with port master -
+ target tcp_remote <device> */
+ if (args && strncmp (args, "tcp", 10) == 0)
+ {
+ char com_type[128];
+ n = sscanf (args, " %s %s %d %s", com_type, dev_name, &baudrate, junk);
+ using_tcp_remote = 1;
+ n--;
+ }
+ else if (args)
{
n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
}
{
error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
or \t\ttarget e7000 <host>[:<port>]\n\
+or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
or \t\ttarget e7000 pc\n");
}
-#if !defined(__GO32__) && !defined(__WIN32__)
+#if !defined(__GO32__) && !defined(_WIN32)
+ /* FIXME! test for ':' is ambiguous */
if (n == 1 && strchr (dev_name, ':') == 0)
{
/* Default to normal telnet port */
+ /* serial_open will use this to determine tcp communication */
strcat (dev_name, ":23");
}
#endif
+ if (!using_tcp_remote && strchr (dev_name, ':'))
+ using_tcp = 1;
}
- push_target (&e7000_ops);
+ return n;
+}
- e7000_desc = SERIAL_OPEN (dev_name);
+/* Stub for catch_errors. */
- if (!e7000_desc)
- perror_with_name (dev_name);
+static int
+e7000_start_remote (dummy)
+ char *dummy;
+{
+ int loop;
+ int sync;
+ int try;
+ int quit_trying;
- using_tcp = strcmp (e7000_desc->ops->name, "tcp") == 0;
- using_pc = strcmp (e7000_desc->ops->name, "pc") == 0;
-
- SERIAL_SETBAUDRATE (e7000_desc, baudrate);
- SERIAL_RAW (e7000_desc);
+ immediate_quit = 1; /* Allow user to interrupt it */
/* Hello? Are you there? */
sync = 0;
- loop = 0;
+ loop = 0;
+ try = 0;
+ quit_trying = 20;
putchar_e7000 (CTRLC);
- while (!sync)
+ while (!sync && ++try <= quit_trying)
{
int c;
- if (from_tty)
- printf_unfiltered ("[waiting for e7000...]\n");
+ printf_unfiltered ("[waiting for e7000...]\n");
write_e7000 ("\r");
- c = SERIAL_READCHAR (e7000_desc, 1);
- while (c != SERIAL_TIMEOUT)
+ c = readchar (1);
+
+ /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
+ * we get stuck in this loop ...
+ * We may never timeout, and never sync up :-(
+ */
+ while (!sync && c != -1)
{
/* Dont echo cr's */
- if (from_tty && c != '\r')
+ if (c != '\r')
{
- putchar (c);
- fflush (stdout);
+ putchar_unfiltered (c);
+ gdb_flush (gdb_stdout);
}
+ /* Shouldn't we either break here, or check for sync in inner loop? */
if (c == ':')
sync = 1;
- if (loop++ == 20)
+ if (loop++ == 20)
{
putchar_e7000 (CTRLC);
loop = 0;
}
- QUIT ;
-
+ QUIT;
if (quit_flag)
{
putchar_e7000 (CTRLC);
- quit_flag = 0;
+ /* Was-> quit_flag = 0; */
+ c = -1;
+ quit_trying = try + 1; /* we don't want to try anymore */
+ }
+ else
+ {
+ c = readchar (1);
}
- c = SERIAL_READCHAR (e7000_desc, 1);
}
}
- puts_e7000debug ("\r");
+ if (!sync)
+ {
+ fprintf_unfiltered (gdb_stderr, "Giving up after %d tries...\n", try);
+ error ("Unable to syncronize with target.\n");
+ }
+
+ puts_e7000debug ("\r");
+ expect_prompt ();
+ puts_e7000debug ("b -\r"); /* Clear breakpoints */
expect_prompt ();
- puts_e7000debug ("b -\r");
+ immediate_quit = 0;
- expect_prompt ();
+/* This is really the job of start_remote however, that makes an assumption
+ that the target is about to print out a status message of some sort. That
+ doesn't happen here. */
- if (from_tty)
- printf_filtered ("Remote target %s connected to %s\n", target_shortname,
- dev_name);
+ 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);
+
+ return 1;
+}
+
+static void
+e7000_open (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ int n;
+
+ target_preopen (from_tty);
+
+ n = e7000_parse_device (args, dev_name, baudrate);
+
+ push_target (&e7000_ops);
+
+ e7000_desc = SERIAL_OPEN (dev_name);
+
+ if (!e7000_desc)
+ perror_with_name (dev_name);
+
+ SERIAL_SETBAUDRATE (e7000_desc, baudrate);
+ SERIAL_RAW (e7000_desc);
#ifdef GDB_TARGET_IS_H8300
h8300hmode = 1;
#endif
+
+ /* Start the remote connection; if error (0), discard this target.
+ In particular, if the user quits, be sure to discard it
+ (we'd be in an inconsistent state otherwise). */
+ if (!catch_errors (e7000_start_remote, (char *) 0,
+ "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
+ if (from_tty)
+ printf_filtered ("Remote target %s connected to %s\n", target_shortname,
+ dev_name);
}
/* Close out all files and local state before this target loses control. */
{
pop_target (); /* calls e7000_close to do the real work */
if (from_tty)
- printf ("Ending remote %s debugging\n", target_shortname);
+ printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
}
/* Tell the remote machine to resume. */
000218 MOV.B R1L,R2L
STEP NORMAL END or
BREAK POINT
- */
+ */
#ifdef GDB_TARGET_IS_H8300
-char *want = "PC=%p CCR=%c\n\
+char *want_h8300h = "PC=%p CCR=%c\n\
+ ER0 - ER3 %0 %1 %2 %3\n\
+ ER4 - ER7 %4 %5 %6 %7\n";
+
+char *want_nopc_h8300h = "%p CCR=%c\n\
+ ER0 - ER3 %0 %1 %2 %3\n\
+ ER4 - ER7 %4 %5 %6 %7";
+
+char *want_h8300s = "PC=%p CCR=%c\n\
+ MACH=\n\
ER0 - ER3 %0 %1 %2 %3\n\
ER4 - ER7 %4 %5 %6 %7\n";
-char *want_nopc = "%p CCR=%c\n\
+char *want_nopc_h8300s = "%p CCR=%c EXR=%9\n\
ER0 - ER3 %0 %1 %2 %3\n\
ER4 - ER7 %4 %5 %6 %7";
static int
gch ()
{
- int c = readchar (timeout);
-
- if (remote_debug)
- {
- if (c >= ' ')
- printf ("%c", c);
- else if (c == '\n')
- printf ("\n");
- }
- return c;
+ return readchar (timeout);
}
static unsigned int
void
fetch_regs_from_dump (nextchar, want)
- int (*nextchar)();
+ int (*nextchar) ();
char *want;
{
int regno;
{
case '\n':
/* Skip to end of line and then eat all new line type stuff */
- while (thischar != '\n' && thischar != '\r')
+ while (thischar != '\n' && thischar != '\r')
thischar = nextchar ();
- while (thischar == '\n' || thischar == '\r')
+ while (thischar == '\n' || thischar == '\r')
thischar = nextchar ();
want++;
break;
thischar = nextchar ();
want++;
break;
-
+
default:
if (*want == thischar)
{
want++;
if (*want)
thischar = nextchar ();
-
+
}
else if (thischar == ' ' || thischar == '\n' || thischar == '\r')
{
thischar = nextchar ();
}
- else {
- error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
- want, thischar, thischar);
- }
-
+ else
+ {
+ error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
+ want, thischar, thischar);
+ }
+
break;
case '%':
/* Got a register command */
#endif
default:
- if (isdigit (want[0]))
+ if (isdigit (want[0]))
{
if (isdigit (want[1]))
{
regno = (want[0] - '0') * 10 + want[1] - '0';
want += 2;
}
- else
+ else
{
regno = want[0] - '0';
want++;
}
}
-
+
else
abort ();
}
store_signed_integer (buf,
- REGISTER_RAW_SIZE(regno),
+ REGISTER_RAW_SIZE (regno),
(LONGEST) get_hex (&thischar, nextchar));
supply_register (regno, buf);
break;
e7000_fetch_registers ()
{
int regno;
+ char *wanted;
puts_e7000debug ("R\r");
#ifdef GDB_TARGET_IS_SH
- if ((sh_processor_type != NULL) && (*(sh_processor_type+2) == '3'))
- fetch_regs_from_dump (gch, want_sh3);
- else
- fetch_regs_from_dump (gch, want);
+ wanted = want;
+ if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
+ switch (TARGET_ARCHITECTURE->mach)
+ {
+ case bfd_mach_sh3:
+ case bfd_mach_sh3e:
+ case bfd_mach_sh4:
+ wanted = want_sh3;
+ }
#else
- fetch_regs_from_dump (gch, want);
+ if (h8300smode)
+ wanted = want_h8300s;
+ else
+ wanted = want_h8300h;
#endif
-
+ fetch_regs_from_dump (gch, wanted);
/* And supply the extra ones the simulator uses */
for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
static void
e7000_files_info ()
{
- printf ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
+ printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
}
static int
/* Write a large ammount of memory, this only works with the serial
mode enabled. Command is sent as
- il ;s:s\r ->
- <- il ;s:s\r
- <- ENQ
- ACK ->
- <- LO s\r
- Srecords...
- ^Z ->
- <- ENQ
- ACK ->
- <- :
- */
+ il ;s:s\r ->
+ <- il ;s:s\r
+ <- ENQ
+ ACK ->
+ <- LO s\r
+ Srecords...
+ ^Z ->
+ <- ENQ
+ ACK ->
+ <- :
+ */
static int
write_large (memaddr, myaddr, len)
compose[where++] = 0;
SERIAL_WRITE (e7000_desc, compose, where);
- j = SERIAL_READCHAR (e7000_desc, 0);
- if (j == SERIAL_TIMEOUT)
+ j = readchar (0);
+ if (j == -1)
{
/* This is ok - nothing there */
}
}
else
{
- printf ("@%d}@", j);
- while ((j = SERIAL_READCHAR(e7000_desc,0)) > 0)
+ printf_unfiltered ("@%d}@", j);
+ while ((j = readchar (0)) > 0)
{
- printf ("@{%d}@",j);
+ printf_unfiltered ("@{%d}@", j);
}
}
}
/* Read LEN bytes from inferior memory at MEMADDR. Put the result
at debugger address MYADDR. Returns length moved.
- Small transactions we send
- m <addr>;l
- and receive
- 00000000 12345678 ?
+ Small transactions we send
+ m <addr>;l
+ and receive
+ 00000000 12345678 ?
*/
static int
char buf[200];
/* Starting address of this pass. */
-/* printf("READ INF %x %x %d\n", memaddr, myaddr, len);*/
+/* printf("READ INF %x %x %d\n", memaddr, myaddr, len); */
if (((memaddr - 1) + len) < memaddr)
{
errno = EIO;
sprintf (buf, "m %x;l\r", memaddr);
puts_e7000debug (buf);
- for (count = 0; count < len; count += 4)
+ for (count = 0; count < len; count += 4)
{
/* Suck away the address */
- c = gch ();
+ c = gch ();
while (c != ' ')
- c = gch ();
+ c = gch ();
c = gch ();
- if (c == '*')
+ if (c == '*')
{ /* Some kind of error */
- expect_prompt();
+ puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
+ expect_full_prompt ();
return -1;
}
while (c != ' ')
- c = gch ();
+ c = gch ();
/* Now read in the data */
- for (i = 0; i < 4; i++)
+ for (i = 0; i < 4; i++)
{
- int b = gbyte();
- if (count + i < len) {
- myaddr[count + i] = b;
- }
+ int b = gbyte ();
+ if (count + i < len)
+ {
+ myaddr[count + i] = b;
+ }
}
/* Skip the trailing ? and send a . to end and a cr for more */
- gch ();
+ gch ();
gch ();
if (count + 4 >= len)
- puts_e7000debug(".\r");
+ puts_e7000debug (".\r");
else
- puts_e7000debug("\r");
+ puts_e7000debug ("\r");
}
- expect_prompt();
+ expect_prompt ();
return len;
}
/*
- For large transfers we used to send
+ For large transfers we used to send
- d <addr> <endaddr>\r
+ d <addr> <endaddr>\r
- and receive
+ and receive
<ADDRESS> < D A T A > < ASCII CODE >
00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
- A cost in chars for each transaction of 80 + 5*n-bytes.
+ A cost in chars for each transaction of 80 + 5*n-bytes.
- Large transactions could be done with the srecord load code, but
- there is a pause for a second before dumping starts, which slows the
- average rate down!
-*/
+ Large transactions could be done with the srecord load code, but
+ there is a pause for a second before dumping starts, which slows the
+ average rate down!
+ */
static int
e7000_read_inferior_memory_large (memaddr, myaddr, len)
count = 0;
c = gch ();
-
+
/* skip down to the first ">" */
- while( c != '>' )
+ while (c != '>')
c = gch ();
/* now skip to the end of that line */
- while( c != '\r' )
+ while (c != '\r')
c = gch ();
c = gch ();
}
}
/* throw out the rest of the line */
- while( c != '\r' )
+ while (c != '\r')
c = gch ();
}
struct target_ops *target; /* ignored */
{
if (write)
- return e7000_write_inferior_memory( memaddr, myaddr, len);
- else
- if( len < 16 )
- return e7000_read_inferior_memory( memaddr, myaddr, len);
- else
- return e7000_read_inferior_memory_large( memaddr, myaddr, len);
+ return e7000_write_inferior_memory (memaddr, myaddr, len);
+ else if (len < 16)
+ return e7000_read_inferior_memory (memaddr, myaddr, len);
+ else
+ return e7000_read_inferior_memory_large (memaddr, myaddr, len);
}
static void
asection *section;
bfd *pbfd;
bfd_vma entry;
- int i;
#define WRITESIZE 0x1000
- char buf[2 + 4 + 4 + WRITESIZE]; /* `DT' + <addr> + <len> + <data> */
+ char buf[2 + 4 + 4 + WRITESIZE]; /* `DT' + <addr> + <len> + <data> */
char *filename;
int quiet;
int nostart;
time_t start_time, end_time; /* Start and end times of download */
unsigned long data_count; /* Number of bytes transferred to memory */
+ int oldtimeout = timeout;
+
+ timeout = remote_timeout;
- if (!strchr (dev_name, ':'))
+
+ /* FIXME! change test to test for type of download */
+ if (!using_tcp)
{
generic_load (args, from_tty);
return;
}
+ /* for direct tcp connections, we can do a fast binary download */
buf[0] = 'D';
buf[1] = 'T';
quiet = 0;
{
char *arg;
- while (isspace (*args)) args++;
+ while (isspace (*args))
+ args++;
arg = args;
- while ((*args != '\000') && !isspace (*args)) args++;
+ while ((*args != '\000') && !isspace (*args))
+ args++;
if (*args != '\000')
*args++ = '\000';
perror_with_name (filename);
return;
}
- old_chain = make_cleanup (bfd_close, pbfd);
+ old_chain = make_cleanup ((make_cleanup_func) bfd_close, pbfd);
- if (!bfd_check_format (pbfd, bfd_object))
+ if (!bfd_check_format (pbfd, bfd_object))
error ("\"%s\" is not an object file: %s", filename,
bfd_errmsg (bfd_get_error ()));
expect ("\nOK");
- for (section = pbfd->sections; section; section = section->next)
+ for (section = pbfd->sections; section; section = section->next)
{
if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
{
section_size);
fptr = 0;
-
+
data_count += section_size;
while (section_size > 0)
if (SERIAL_WRITE (e7000_desc, buf, count + 10))
fprintf_unfiltered (gdb_stderr,
"e7000_load: SERIAL_WRITE failed: %s\n",
- safe_strerror(errno));
+ safe_strerror (errno));
expect ("OK");
if (!quiet)
printf_unfiltered ("[Starting %s at 0x%x]\n", filename, entry);
-/* start_routine (entry);*/
+/* start_routine (entry); */
}
report_transfer_performance (data_count, start_time, end_time);
do_cleanups (old_chain);
+ timeout = oldtimeout;
}
/* Clean up when a program exits.
generic_mourn_inferior (); /* Do all the proper things now */
}
+#define MAX_BREAKPOINTS 200
#ifdef HARD_BREAKPOINTS
-#define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : 200)
+#define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
#else
-#define MAX_E7000DEBUG_BREAKPOINTS 200
+#define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
#endif
-extern int memory_breakpoint_size;
-
-static CORE_ADDR breakaddr[MAX_E7000DEBUG_BREAKPOINTS] = {0};
+/* Since we can change to soft breakpoints dynamically, we must define
+ more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
+static CORE_ADDR breakaddr[MAX_BREAKPOINTS] =
+{0};
static int
e7000_insert_breakpoint (addr, shadow)
{
int i;
char buf[200];
+#if 0
static char nop[2] = NOP;
+#endif
for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++)
if (breakaddr[i] == 0)
breakaddr[i] = addr;
/* Save old contents, and insert a nop in the space */
#ifdef HARD_BREAKPOINTS
- if (BC_BREAKPOINTS)
+ if (BC_BREAKPOINTS)
{
- sprintf (buf, "BC%d A=%x\r", i+1, addr);
+ sprintf (buf, "BC%d A=%x\r", i + 1, addr);
puts_e7000debug (buf);
}
- else
+ else
{
sprintf (buf, "B %x\r", addr);
puts_e7000debug (buf);
{
breakaddr[i] = 0;
#ifdef HARD_BREAKPOINTS
- if (BC_BREAKPOINTS)
+ if (BC_BREAKPOINTS)
{
- sprintf (buf, "BC%d - \r", i+1);
+ sprintf (buf, "BC%d - \r", i + 1);
puts_e7000debug (buf);
}
- else
+ else
{
- sprintf (buf, "B - %x\r", addr);
+ sprintf (buf, "B - %x\r", addr);
puts_e7000debug (buf);
}
expect_prompt ();
{
int c;
- puts_e7000debug("end\r");
+ puts_e7000debug ("end\r");
putchar_e7000 (CTRLC);
- while ((c = SERIAL_READCHAR (e7000_desc, 1) != SERIAL_TIMEOUT))
+ while ((c = readchar (1) != -1))
{
if (quit_flag)
{
- putchar_e7000(CTRLC);
+ putchar_e7000 (CTRLC);
quit_flag = 0;
}
if (c > ' ' && c < 127)
- printf ("%c", c & 0xff);
+ printf_unfiltered ("%c", c & 0xff);
else
- printf ("<%x>", c & 0xff);
+ printf_unfiltered ("<%x>", c & 0xff);
}
}
static int
why_stop ()
{
- static char *strings[NITEMS] = {
+ static char *strings[NITEMS] =
+ {
"STEP NORMAL",
"BREAK POINT",
"BREAK KEY",
for (i = 0; i < NITEMS; ++i)
p[i] = strings[i];
-
+
c = gch ();
while (1)
{
for (i = 0; i < NITEMS; i++)
{
- if (c == *(p[i]))
+ if (c == *(p[i]))
{
p[i]++;
- if (*(p[i]) == 0)
- {
+ if (*(p[i]) == 0)
+ {
/* found one of the choices */
return i;
}
int
expect_n (strings)
-char **strings;
+ char **strings;
{
char *(ptr[10]);
- int n;
+ int n;
int c;
char saveaway[100];
char *buffer = saveaway;
/* Count number of expect strings */
- for (n = 0; strings[n]; n++)
+ for (n = 0; strings[n]; n++)
{
ptr[n] = strings[n];
}
int i;
int gotone = 0;
- c = SERIAL_READCHAR (e7000_desc, 1);
- if (c == SERIAL_TIMEOUT)
+ c = readchar (1);
+ if (c == -1)
{
printf_unfiltered ("[waiting for e7000...]\n");
}
#ifdef __GO32__
if (kbhit ())
{
- int k = getkey();
+ int k = getkey ();
if (k == 1)
quit_flag = 1;
for (i = 0; i < n; i++)
{
- if (c == ptr[i][0])
+ if (c == ptr[i][0])
{
ptr[i]++;
if (ptr[i][0] == 0)
ptr[i] = strings[i];
}
}
-
+
if (gotone)
{
/* Save it up incase we find that there was no match */
- *buffer ++ = c;
+ *buffer++ = c;
}
else
{
- if (buffer != saveaway)
+ if (buffer != saveaway)
{
*buffer++ = 0;
- printf ("%s", buffer);
+ printf_unfiltered ("%s", buffer);
buffer = saveaway;
}
- if (c != SERIAL_TIMEOUT)
+ if (c != -1)
{
- putchar (c);
- fflush (stdout);
+ putchar_unfiltered (c);
+ gdb_flush (gdb_stdout);
}
}
}
char buf2[200];
store_signed_integer (buf,
- REGISTER_RAW_SIZE(PC_REGNUM),
- read_register (PC_REGNUM) -2);
+ REGISTER_RAW_SIZE (PC_REGNUM),
+ read_register (PC_REGNUM) - 2);
supply_register (PC_REGNUM, buf);
sprintf (buf2, ".PC %x\r", read_register (PC_REGNUM));
puts_e7000debug (buf2);
#define WAS_RUNNING 2
#define WAS_OTHER 3
-static char *estrings[] = {
+static char *estrings[] =
+{
"** SLEEP",
"BREAK !",
"** PC",
int running_count = 0;
int had_sleep = 0;
int loop = 1;
+ char *wanted_nopc;
/* Then echo chars until PC= string seen */
gch (); /* Drop cr */
while (loop)
{
switch (expect_n (estrings))
- {
+ {
case WAS_OTHER:
/* how did this happen ? */
loop = 0;
expect ("=");
#ifdef GDB_TARGET_IS_SH
- if ((sh_processor_type != NULL) && (*(sh_processor_type+2) == '3'))
- fetch_regs_from_dump (gch, want_sh3_nopc);
- else
- fetch_regs_from_dump (gch, want_nopc);
+ wanted_nopc = want_nopc;
+ if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
+ switch (TARGET_ARCHITECTURE->mach)
+ {
+ case bfd_mach_sh3:
+ case bfd_mach_sh3e:
+ case bfd_mach_sh4:
+ wanted_nopc = want_sh3_nopc;
+ }
#else
- fetch_regs_from_dump (gch, want_nopc);
+ if (h8300smode)
+ wanted_nopc = want_nopc_h8300s;
+ else
+ wanted_nopc = want_nopc_h8300h;
#endif
+ fetch_regs_from_dump (gch, wanted_nopc);
/* And supply the extra ones the simulator uses */
for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
switch (stop_reason)
{
case 1: /* Breakpoint */
- write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
- status->value.sig = TARGET_SIGNAL_TRAP;
+ write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 0: /* Single step */
- status->value.sig = TARGET_SIGNAL_TRAP;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 2: /* Interrupt */
if (had_sleep)
{
- status->value.sig = TARGET_SIGNAL_TRAP;
+ status->value.sig = TARGET_SIGNAL_TRAP;
sub2_from_pc ();
}
else
{
- status->value.sig = TARGET_SIGNAL_INT;
+ status->value.sig = TARGET_SIGNAL_INT;
}
break;
case 3:
break;
case 4:
printf_unfiltered ("a cycle address error?\n");
- status->value.sig = TARGET_SIGNAL_UNKNOWN;
+ status->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
case 5:
- status->value.sig = TARGET_SIGNAL_ILL;
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 6:
- status->value.sig = TARGET_SIGNAL_SEGV;
+ status->value.sig = TARGET_SIGNAL_SEGV;
break;
case 7: /* Anything else (NITEMS + 1) */
printf_unfiltered ("a write protect error?\n");
- status->value.sig = TARGET_SIGNAL_UNKNOWN;
+ status->value.sig = TARGET_SIGNAL_UNKNOWN;
break;
default:
/* Get the user's attention - this should never happen. */
return 0;
}
+/* Stop the running program. */
+
+static void
+e7000_stop ()
+{
+ /* Sending a ^C is supposed to stop the running program. */
+ putchar_e7000 (CTRLC);
+}
+
/* Define the target subroutine names. */
-struct target_ops e7000_ops =
+struct target_ops e7000_ops;
+
+static void
+init_e7000_ops (void)
{
- "e7000",
- "Remote Hitachi e7000 target",
- "Use a remote Hitachi e7000 ICE connected by a serial line,\n\
+ e7000_ops.to_shortname = "e7000";
+ e7000_ops.to_longname = "Remote Hitachi e7000 target";
+ e7000_ops.to_doc = "Use a remote Hitachi e7000 ICE connected by a serial line;\n\
or a network connection.\n\
Arguments are the name of the device for the serial line,\n\
the speed to connect at in bits per second.\n\
eg\n\
target e7000 /dev/ttya 9600\n\
-target e7000 foobar",
- e7000_open, /* to_open */
- e7000_close, /* to_close */
- 0, /* to_attach */
- e7000_detach, /* to_detach */
- e7000_resume, /* to_resume */
- e7000_wait, /* to_wait */
- e7000_fetch_register, /* to_fetch_registers */
- e7000_store_register, /* to_store_registers */
- e7000_prepare_to_store, /* to_prepare_to_store */
- e7000_xfer_inferior_memory, /* to_xfer_memory */
- e7000_files_info, /* to_files_info */
- e7000_insert_breakpoint, /* to_insert_breakpoint */
- e7000_remove_breakpoint, /* to_remove_breakpoint */
- 0, /* to_terminal_init */
- 0, /* to_terminal_inferior */
- 0, /* to_terminal_ours_for_output */
- 0, /* to_terminal_ours */
- 0, /* to_terminal_info */
- e7000_kill, /* to_kill */
- e7000_load, /* to_load */
- 0, /* to_lookup_symbol */
- e7000_create_inferior, /* to_create_inferior */
- e7000_mourn_inferior, /* to_mourn_inferior */
- 0, /* to_can_run */
- 0, /* to_notice_signals */
- 0, /* to_thread_alive */
- 0, /* to_stop */
- process_stratum, /* to_stratum */
- 0, /* next (unused) */
- 1, /* to_has_all_memory */
- 1, /* to_has_memory */
- 1, /* to_has_stack */
- 1, /* to_has_registers */
- 1, /* to_has_execution */
- 0, /* to_sections */
- 0, /* to_sections_end */
- OPS_MAGIC, /* Always the last thing */
+target e7000 foobar";
+ e7000_ops.to_open = e7000_open;
+ e7000_ops.to_close = e7000_close;
+ e7000_ops.to_attach = 0;
+ e7000_ops.to_post_attach = NULL;
+ e7000_ops.to_require_attach = NULL;
+ e7000_ops.to_detach = e7000_detach;
+ e7000_ops.to_require_detach = NULL;
+ e7000_ops.to_resume = e7000_resume;
+ e7000_ops.to_wait = e7000_wait;
+ e7000_ops.to_post_wait = NULL;
+ e7000_ops.to_fetch_registers = e7000_fetch_register;
+ e7000_ops.to_store_registers = e7000_store_register;
+ e7000_ops.to_prepare_to_store = e7000_prepare_to_store;
+ e7000_ops.to_xfer_memory = e7000_xfer_inferior_memory;
+ e7000_ops.to_files_info = e7000_files_info;
+ e7000_ops.to_insert_breakpoint = e7000_insert_breakpoint;
+ e7000_ops.to_remove_breakpoint = e7000_remove_breakpoint;
+ e7000_ops.to_terminal_init = 0;
+ e7000_ops.to_terminal_inferior = 0;
+ e7000_ops.to_terminal_ours_for_output = 0;
+ e7000_ops.to_terminal_ours = 0;
+ e7000_ops.to_terminal_info = 0;
+ e7000_ops.to_kill = e7000_kill;
+ e7000_ops.to_load = e7000_load;
+ e7000_ops.to_lookup_symbol = 0;
+ e7000_ops.to_create_inferior = e7000_create_inferior;
+ e7000_ops.to_post_startup_inferior = NULL;
+ e7000_ops.to_acknowledge_created_inferior = NULL;
+ e7000_ops.to_clone_and_follow_inferior = NULL;
+ e7000_ops.to_post_follow_inferior_by_clone = NULL;
+ e7000_ops.to_insert_fork_catchpoint = NULL;
+ e7000_ops.to_remove_fork_catchpoint = NULL;
+ e7000_ops.to_insert_vfork_catchpoint = NULL;
+ e7000_ops.to_remove_vfork_catchpoint = NULL;
+ e7000_ops.to_has_forked = NULL;
+ e7000_ops.to_has_vforked = NULL;
+ e7000_ops.to_can_follow_vfork_prior_to_exec = NULL;
+ e7000_ops.to_post_follow_vfork = NULL;
+ e7000_ops.to_insert_exec_catchpoint = NULL;
+ e7000_ops.to_remove_exec_catchpoint = NULL;
+ e7000_ops.to_has_execd = NULL;
+ e7000_ops.to_reported_exec_events_per_exec_call = NULL;
+ e7000_ops.to_has_exited = NULL;
+ e7000_ops.to_mourn_inferior = e7000_mourn_inferior;
+ e7000_ops.to_can_run = 0;
+ e7000_ops.to_notice_signals = 0;
+ e7000_ops.to_thread_alive = 0;
+ e7000_ops.to_stop = e7000_stop;
+ e7000_ops.to_pid_to_exec_file = NULL;
+ e7000_ops.to_core_file_to_sym_file = NULL;
+ e7000_ops.to_stratum = process_stratum;
+ e7000_ops.DONT_USE = 0;
+ e7000_ops.to_has_all_memory = 1;
+ e7000_ops.to_has_memory = 1;
+ e7000_ops.to_has_stack = 1;
+ e7000_ops.to_has_registers = 1;
+ e7000_ops.to_has_execution = 1;
+ e7000_ops.to_sections = 0;
+ e7000_ops.to_sections_end = 0;
+ e7000_ops.to_magic = OPS_MAGIC;
};
void
_initialize_remote_e7000 ()
{
+ init_e7000_ops ();
add_target (&e7000_ops);
- add_com ("e7000 <command>", class_obscure, e7000_command,
+ add_com ("e7000", class_obscure, e7000_command,
"Send a command to the e7000 monitor.");
- add_com ("ftplogin <machine> <name> <passwd> <dir>", class_obscure, e7000_login_command,
+ add_com ("ftplogin", class_obscure, e7000_login_command,
"Login to machine and change to directory.");
- add_com ("ftpload <file>", class_obscure, e7000_ftp_command,
+ add_com ("ftpload", class_obscure, e7000_ftp_command,
"Fetch and load a file from previously described place.");
add_com ("drain", class_obscure, e7000_drain_command,
"Drain pending e7000 text buffers.");
+
+ add_show_from_set (add_set_cmd ("usehardbreakpoints", no_class,
+ var_integer, (char *) &use_hard_breakpoints,
+ "Set use of hardware breakpoints for all breakpoints.\n", &setlist),
+ &showlist);
}