1 /* Remote debugging interface for Renesas E7000 ICE, for GDB
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004 Free Software Foundation, Inc.
6 Contributed by Cygnus Support.
8 Written by Steve Chamberlain for Cygnus Support.
10 This file is part of GDB.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place - Suite 330,
25 Boston, MA 02111-1307, USA. */
27 /* The E7000 is an in-circuit emulator for the Renesas H8/300-H and
28 Renesas-SH processor. It has serial port and a lan port.
30 The monitor command set makes it difficult to load large ammounts of
31 data over the lan without using ftp - so try not to issue load
32 commands when communicating over ethernet; use the ftpload command.
34 The monitor pauses for a second when dumping srecords to the serial
35 line too, so we use a slower per byte mechanism but without the
36 startup overhead. Even so, it's pretty slow... */
45 #include "gdb_string.h"
46 #include "exceptions.h"
48 #include <sys/types.h>
50 #include "remote-utils.h"
58 #define HARD_BREAKPOINTS /* Now handled by set option. */
59 #define BC_BREAKPOINTS use_hard_breakpoints
67 /* This file is used by 2 different targets, sh-elf and h8300. The
68 h8300 is not multiarched and doesn't use the registers defined in
69 tm-sh.h. To avoid using a macro GDB_TARGET_IS_SH, we do runtime check
70 of the target, which requires that these namse below are always
71 defined also in the h8300 case. */
73 #if !defined (PR_REGNUM)
76 #if !defined (GBR_REGNUM)
79 #if !defined (VBR_REGNUM)
82 #if !defined (MACH_REGNUM)
83 #define MACH_REGNUM -1
85 #if !defined (MACL_REGNUM)
86 #define MACL_REGNUM -1
88 #if !defined (SR_REGNUM)
92 extern void report_transfer_performance (unsigned long, time_t, time_t);
94 extern char *sh_processor_type;
96 /* Local function declarations. */
98 static void e7000_close (int);
100 static void e7000_fetch_register (int);
102 static void e7000_store_register (int);
104 static void e7000_command (char *, int);
106 static void e7000_login_command (char *, int);
108 static void e7000_ftp_command (char *, int);
110 static void e7000_drain_command (char *, int);
112 static void expect (char *);
114 static void expect_full_prompt (void);
116 static void expect_prompt (void);
118 static int e7000_parse_device (char *args, char *dev_name, int baudrate);
121 static struct serial *e7000_desc;
123 /* Allow user to chose between using hardware breakpoints or memory. */
124 static int use_hard_breakpoints = 0; /* use sw breakpoints by default */
126 /* Nonzero if using the tcp serial driver. */
128 static int using_tcp; /* direct tcp connection to target */
129 static int using_tcp_remote; /* indirect connection to target
130 via tcp to controller */
132 /* Nonzero if using the pc isa card. */
136 extern struct target_ops e7000_ops; /* Forward declaration */
138 char *ENQSTRING = "\005";
140 /* Nonzero if some routine (as opposed to the user) wants echoing.
141 FIXME: Do this reentrantly with an extra parameter. */
147 static int timeout = 20;
149 /* Send data to e7000debug. */
152 puts_e7000debug (char *buf)
155 error (_("Use \"target e7000 ...\" first."));
158 printf_unfiltered ("Sending %s\n", buf);
160 if (serial_write (e7000_desc, buf, strlen (buf)))
161 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", safe_strerror (errno));
163 /* And expect to see it echoed, unless using the pc interface */
171 putchar_e7000 (int x)
176 serial_write (e7000_desc, b, 1);
180 write_e7000 (char *s)
182 serial_write (e7000_desc, s, strlen (s));
193 /* Read a character from the remote system, doing all the fancy timeout
194 stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars,
195 returns -1, else returns next char. Discards chars > 127. */
198 readchar (int timeout)
204 c = serial_readchar (e7000_desc, timeout);
208 if (c == SERIAL_TIMEOUT)
213 error (_("Timeout reading from remote system."));
216 error (_("Serial communication error"));
220 putchar_unfiltered (c);
221 gdb_flush (gdb_stdout);
231 static char b[8][10];
243 sprintf (b[p], "<%d>", x);
250 /* Scan input from the remote system, until STRING is found. If
251 DISCARD is non-zero, then discard non-matching input, else print it
252 out. Let the user break out immediately. */
255 expect (char *string)
263 c = readchar (timeout);
267 if (c == '\r' || c == '\n')
270 putchar_unfiltered ('\n');
276 putchar_unfiltered (c);
278 gdb_flush (gdb_stdout);
280 if (normal (c) == normal (*p++))
289 if (normal (c) == normal (string[0]))
295 /* Keep discarding input until we see the e7000 prompt.
297 The convention for dealing with the prompt is that you
299 o *then* wait for the prompt.
301 Thus the last thing that a procedure does with the serial line will
302 be an expect_prompt(). Exception: e7000_resume does not wait for
303 the prompt, because the terminal is being handed over to the
304 inferior. However, the next thing which happens after that is a
305 e7000_wait which does wait for the prompt. Note that this includes
306 abnormal exit, e.g. error(). This is necessary to prevent getting
307 into states from which we can't recover. */
316 expect_full_prompt (void)
322 convert_hex_digit (int ch)
324 if (ch >= '0' && ch <= '9')
326 else if (ch >= 'A' && ch <= 'F')
327 return ch - 'A' + 10;
328 else if (ch >= 'a' && ch <= 'f')
329 return ch - 'a' + 10;
336 int value = convert_hex_digit (*start);
339 *start = readchar (timeout);
340 while ((try = convert_hex_digit (*start)) >= 0)
344 *start = readchar (timeout);
350 /* Get N 32-bit words from remote, each preceded by a space, and put
351 them in registers starting at REGNO. */
354 get_hex_regs (int n, int regno)
359 for (i = 0; i < n; i++)
364 for (j = 0; j < 8; j++)
365 val = (val << 4) + get_hex_digit (j == 0);
366 regcache_raw_supply (current_regcache, regno++, (char *) &val);
371 /* This is called not only when we first attach, but also when the
372 user types "run" after having attached. */
375 e7000_create_inferior (char *execfile, char *args, char **env,
381 error (_("Can't pass arguments to remote E7000DEBUG process"));
383 if (execfile == 0 || exec_bfd == 0)
384 error (_("No executable file specified"));
386 entry_pt = (int) bfd_get_start_address (exec_bfd);
388 #ifdef CREATE_INFERIOR_HOOK
389 CREATE_INFERIOR_HOOK (0); /* No process-ID */
392 /* The "process" (board) is already stopped awaiting our commands, and
393 the program is already downloaded. We just set its PC and go. */
395 clear_proceed_status ();
397 /* Tell wait_for_inferior that we've started a new process. */
398 init_wait_for_inferior ();
400 /* Set up the "saved terminal modes" of the inferior
401 based on what modes we are starting it with. */
402 target_terminal_init ();
404 /* Install inferior's terminal modes. */
405 target_terminal_inferior ();
407 /* insert_step_breakpoint (); FIXME, do we need this? */
408 proceed ((CORE_ADDR) entry_pt, -1, 0); /* Let 'er rip... */
411 /* Open a connection to a remote debugger. NAME is the filename used
412 for communication. */
414 static int baudrate = 9600;
415 static char dev_name[100];
417 static char *machine = "";
418 static char *user = "";
419 static char *passwd = "";
420 static char *dir = "";
422 /* Grab the next token and buy some space for it */
432 while (*p && *p == ' ')
435 while (*p && (*p != ' ' && *p != '\t'))
448 e7000_login_command (char *args, int from_tty)
452 machine = next (&args);
454 passwd = next (&args);
458 printf_unfiltered ("Set info to %s %s %s %s\n", machine, user, passwd, dir);
463 error (_("Syntax is ftplogin <machine> <user> <passwd> <directory>"));
467 /* Start an ftp transfer from the E7000 to a host */
470 e7000_ftp_command (char *args, int from_tty)
472 /* FIXME: arbitrary limit on machine names and such. */
475 int oldtimeout = timeout;
476 timeout = remote_timeout;
478 sprintf (buf, "ftp %s\r", machine);
479 puts_e7000debug (buf);
480 expect (" Username : ");
481 sprintf (buf, "%s\r", user);
482 puts_e7000debug (buf);
483 expect (" Password : ");
484 write_e7000 (passwd);
486 expect ("success\r");
488 sprintf (buf, "cd %s\r", dir);
489 puts_e7000debug (buf);
491 sprintf (buf, "ll 0;s:%s\r", args);
492 puts_e7000debug (buf);
494 puts_e7000debug ("bye\r");
496 timeout = oldtimeout;
500 e7000_parse_device (char *args, char *dev_name, int baudrate)
504 if (args && strcasecmp (args, "pc") == 0)
506 strcpy (dev_name, args);
511 /* FIXME! temp hack to allow use with port master -
512 target tcp_remote <device> */
513 if (args && strncmp (args, "tcp", 10) == 0)
516 n = sscanf (args, " %s %s %d %s", com_type, dev_name, &baudrate, junk);
517 using_tcp_remote = 1;
522 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
525 if (n != 1 && n != 2)
527 error (_("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
528 or \t\ttarget e7000 <host>[:<port>]\n\
529 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
530 or \t\ttarget e7000 pc\n"));
533 #if !defined(__GO32__) && !defined(_WIN32) && !defined(__CYGWIN__)
534 /* FIXME! test for ':' is ambiguous */
535 if (n == 1 && strchr (dev_name, ':') == 0)
537 /* Default to normal telnet port */
538 /* serial_open will use this to determine tcp communication */
539 strcat (dev_name, ":23");
542 if (!using_tcp_remote && strchr (dev_name, ':'))
549 /* Stub for catch_errors. */
552 e7000_start_remote (void *dummy)
559 immediate_quit++; /* Allow user to interrupt it */
561 /* Hello? Are you there? */
566 putchar_e7000 (CTRLC);
567 while (!sync && ++try <= quit_trying)
571 printf_unfiltered ("[waiting for e7000...]\n");
576 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
577 * we get stuck in this loop ...
578 * We may never timeout, and never sync up :-(
580 while (!sync && c != -1)
585 putchar_unfiltered (c);
586 gdb_flush (gdb_stdout);
588 /* Shouldn't we either break here, or check for sync in inner loop? */
594 putchar_e7000 (CTRLC);
602 putchar_e7000 (CTRLC);
603 /* Was-> quit_flag = 0; */
605 quit_trying = try + 1; /* we don't want to try anymore */
616 fprintf_unfiltered (gdb_stderr, "Giving up after %d tries...\n", try);
617 error (_("Unable to synchronize with target."));
620 puts_e7000debug ("\r");
622 puts_e7000debug ("b -\r"); /* Clear breakpoints */
627 /* This is really the job of start_remote however, that makes an assumption
628 that the target is about to print out a status message of some sort. That
629 doesn't happen here. */
631 flush_cached_frames ();
632 registers_changed ();
633 stop_pc = read_pc ();
634 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
640 e7000_open (char *args, int from_tty)
644 target_preopen (from_tty);
646 n = e7000_parse_device (args, dev_name, baudrate);
648 push_target (&e7000_ops);
650 e7000_desc = serial_open (dev_name);
653 perror_with_name (dev_name);
655 if (serial_setbaudrate (e7000_desc, baudrate))
657 serial_close (e7000_desc);
658 perror_with_name (dev_name);
660 serial_raw (e7000_desc);
662 /* Start the remote connection; if error (0), discard this target.
663 In particular, if the user quits, be sure to discard it
664 (we'd be in an inconsistent state otherwise). */
665 if (!catch_errors (e7000_start_remote, (char *) 0,
666 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
668 printf_filtered ("Remote target %s connected to %s\n", target_shortname,
672 /* Close out all files and local state before this target loses control. */
675 e7000_close (int quitting)
679 serial_close (e7000_desc);
684 /* Terminate the open connection to the remote debugger. Use this
685 when you want to detach and do something else with your gdb. */
688 e7000_detach (char *arg, int from_tty)
690 pop_target (); /* calls e7000_close to do the real work */
692 printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
695 /* Tell the remote machine to resume. */
698 e7000_resume (ptid_t ptid, int step, enum target_signal sigal)
701 puts_e7000debug ("S\r");
703 puts_e7000debug ("G\r");
706 /* Read the remote registers into the block REGS.
708 For the H8/300 a register dump looks like:
710 PC=00021A CCR=80:I*******
711 ER0 - ER3 0000000A 0000002E 0000002E 00000000
712 ER4 - ER7 00000000 00000000 00000000 00FFEFF6
718 char *want_h8300h = "PC=%p CCR=%c\n\
719 ER0 - ER3 %0 %1 %2 %3\n\
720 ER4 - ER7 %4 %5 %6 %7\n";
722 char *want_nopc_h8300h = "%p CCR=%c\n\
723 ER0 - ER3 %0 %1 %2 %3\n\
724 ER4 - ER7 %4 %5 %6 %7";
726 char *want_h8300s = "PC=%p CCR=%c\n\
728 ER0 - ER3 %0 %1 %2 %3\n\
729 ER4 - ER7 %4 %5 %6 %7\n";
731 char *want_nopc_h8300s = "%p CCR=%c EXR=%9\n\
732 ER0 - ER3 %0 %1 %2 %3\n\
733 ER4 - ER7 %4 %5 %6 %7";
735 char *want_sh = "PC=%16 SR=%22\n\
736 PR=%17 GBR=%18 VBR=%19\n\
738 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
739 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
741 char *want_nopc_sh = "%16 SR=%22\n\
742 PR=%17 GBR=%18 VBR=%19\n\
744 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
745 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
747 char *want_sh3 = "PC=%16 SR=%22\n\
748 PR=%17 GBR=%18 VBR=%19\n\
749 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
750 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
751 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
752 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
753 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
754 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
755 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
757 char *want_nopc_sh3 = "%16 SR=%22\n\
758 PR=%17 GBR=%18 VBR=%19\n\
759 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\
760 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
761 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
762 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
763 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
764 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
765 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
770 return readchar (timeout);
776 int high = convert_hex_digit (gch ());
777 int low = convert_hex_digit (gch ());
779 return (high << 4) + low;
783 fetch_regs_from_dump (int (*nextchar) (), char *want)
786 char buf[MAX_REGISTER_SIZE];
788 int thischar = nextchar ();
791 internal_error (__FILE__, __LINE__, _("Register set not selected."));
798 /* Skip to end of line and then eat all new line type stuff */
799 while (thischar != '\n' && thischar != '\r')
800 thischar = nextchar ();
801 while (thischar == '\n' || thischar == '\r')
802 thischar = nextchar ();
807 while (thischar == ' '
811 thischar = nextchar ();
816 if (*want == thischar)
820 thischar = nextchar ();
823 else if (thischar == ' ' || thischar == '\n' || thischar == '\r')
825 thischar = nextchar ();
829 error (_("out of sync in fetch registers wanted <%s>, got <%c 0x%x>"),
830 want, thischar, thischar);
835 /* Got a register command */
857 #ifdef DEPRECATED_FP_REGNUM
859 regno = DEPRECATED_FP_REGNUM;
865 if (isdigit (want[0]))
867 if (isdigit (want[1]))
869 regno = (want[0] - '0') * 10 + want[1] - '0';
874 regno = want[0] - '0';
880 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
882 store_signed_integer (buf,
883 register_size (current_gdbarch, regno),
884 (LONGEST) get_hex (&thischar));
885 regcache_raw_supply (current_regcache, regno, buf);
892 e7000_fetch_registers (void)
898 puts_e7000debug ("R\r");
900 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
904 switch (TARGET_ARCHITECTURE->mach)
912 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
914 wanted = want_h8300h;
916 switch (TARGET_ARCHITECTURE->mach)
918 case bfd_mach_h8300s:
919 case bfd_mach_h8300sn:
920 case bfd_mach_h8300sx:
921 case bfd_mach_h8300sxn:
922 wanted = want_h8300s;
927 fetch_regs_from_dump (gch, wanted);
929 /* And supply the extra ones the simulator uses */
930 for (regno = realregs; regno < NUM_REGS; regno++)
934 regcache_raw_supply (current_regcache, regno, (char *) (&buf));
938 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
942 e7000_fetch_register (int regno)
944 e7000_fetch_registers ();
947 /* Store the remote registers from the contents of the block REGS. */
950 e7000_store_registers (void)
955 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
957 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300) {
958 realregs = ((TARGET_ARCHITECTURE->mach == bfd_mach_h8300s ||
959 TARGET_ARCHITECTURE->mach == bfd_mach_h8300sn ||
960 TARGET_ARCHITECTURE->mach == bfd_mach_h8300sx ||
961 TARGET_ARCHITECTURE->mach == bfd_mach_h8300sxn) ? 11 : 10);
964 for (regno = 0; regno < realregs; regno++)
965 e7000_store_register (regno);
967 registers_changed ();
970 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
973 e7000_store_register (int regno)
979 e7000_store_registers ();
983 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
987 sprintf (buf, ".ER%d %s\r", regno, phex_nz (read_register (regno), 0));
988 puts_e7000debug (buf);
990 else if (regno == PC_REGNUM)
992 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0));
993 puts_e7000debug (buf);
996 else if (regno == CCR_REGNUM)
998 sprintf (buf, ".CCR %s\r", phex_nz (read_register (regno), 0));
999 puts_e7000debug (buf);
1004 else if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
1006 if (regno == PC_REGNUM)
1008 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0));
1009 puts_e7000debug (buf);
1012 else if (regno == SR_REGNUM)
1014 sprintf (buf, ".SR %s\r", phex_nz (read_register (regno), 0));
1015 puts_e7000debug (buf);
1018 else if (regno == PR_REGNUM)
1020 sprintf (buf, ".PR %s\r", phex_nz (read_register (regno), 0));
1021 puts_e7000debug (buf);
1024 else if (regno == GBR_REGNUM)
1026 sprintf (buf, ".GBR %s\r", phex_nz (read_register (regno), 0));
1027 puts_e7000debug (buf);
1030 else if (regno == VBR_REGNUM)
1032 sprintf (buf, ".VBR %s\r", phex_nz (read_register (regno), 0));
1033 puts_e7000debug (buf);
1036 else if (regno == MACH_REGNUM)
1038 sprintf (buf, ".MACH %s\r", phex_nz (read_register (regno), 0));
1039 puts_e7000debug (buf);
1042 else if (regno == MACL_REGNUM)
1044 sprintf (buf, ".MACL %s\r", phex_nz (read_register (regno), 0));
1045 puts_e7000debug (buf);
1049 sprintf (buf, ".R%d %s\r", regno, phex_nz (read_register (regno), 0));
1050 puts_e7000debug (buf);
1057 /* Get ready to modify the registers array. On machines which store
1058 individual registers, this doesn't need to do anything. On machines
1059 which store all the registers in one fell swoop, this makes sure
1060 that registers contains all the registers from the program being
1064 e7000_prepare_to_store (void)
1066 /* Do nothing, since we can store individual regs */
1070 e7000_files_info (struct target_ops *ops)
1072 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
1076 stickbyte (char *where, unsigned int what)
1078 static CONST char digs[] = "0123456789ABCDEF";
1080 where[0] = digs[(what >> 4) & 0xf];
1081 where[1] = digs[(what & 0xf) & 0xf];
1086 /* Write a small ammount of memory. */
1089 write_small (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1094 for (i = 0; i < len; i++)
1096 if (((memaddr + i) & 3) == 0 && (i + 3 < len))
1098 /* Can be done with a long word */
1099 sprintf (buf, "m %s %x%02x%02x%02x;l\r",
1100 paddr_nz (memaddr + i),
1101 myaddr[i], myaddr[i + 1], myaddr[i + 2], myaddr[i + 3]);
1102 puts_e7000debug (buf);
1107 sprintf (buf, "m %s %x\r", paddr_nz (memaddr + i), myaddr[i]);
1108 puts_e7000debug (buf);
1117 /* Write a large ammount of memory, this only works with the serial
1118 mode enabled. Command is sent as
1133 write_large (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1136 #define maxstride 128
1139 puts_e7000debug ("IL ;S:FK\r");
1141 putchar_e7000 (ACK);
1144 for (i = 0; i < len; i += stride)
1146 char compose[maxstride * 2 + 50];
1147 int address = i + memaddr;
1154 if (stride > maxstride)
1157 compose[where++] = 'S';
1159 if (address >= 0xffffff)
1161 else if (address >= 0xffff)
1166 compose[where++] = alen - 1 + '0';
1167 /* Insert length. */
1168 check_sum += stickbyte (compose + where, alen + stride + 1);
1173 check_sum += stickbyte (compose + where, address >> (8 * (alen)));
1177 for (j = 0; j < stride; j++)
1179 check_sum += stickbyte (compose + where, myaddr[i + j]);
1182 stickbyte (compose + where, ~check_sum);
1184 compose[where++] = '\r';
1185 compose[where++] = '\n';
1186 compose[where++] = 0;
1188 serial_write (e7000_desc, compose, where);
1192 /* This is ok - nothing there */
1196 /* Hmm, it's trying to tell us something */
1198 error (_("Error writing memory"));
1202 printf_unfiltered ("@%d}@", j);
1203 while ((j = readchar (0)) > 0)
1205 printf_unfiltered ("@{%d}@", j);
1210 /* Send the trailer record */
1211 write_e7000 ("S70500000000FA\r");
1212 putchar_e7000 (CTRLZ);
1214 putchar_e7000 (ACK);
1220 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1221 memory at MEMADDR. Returns length moved.
1223 Can't use the Srecord load over ethernet, so don't use fast method
1227 e7000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1229 if (len < 16 || using_tcp || using_pc)
1230 return write_small (memaddr, myaddr, len);
1232 return write_large (memaddr, myaddr, len);
1235 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1236 at debugger address MYADDR. Returns length moved.
1238 Small transactions we send
1245 e7000_read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1251 /* Starting address of this pass. */
1253 /* printf("READ INF %x %x %d\n", memaddr, myaddr, len); */
1254 if (((memaddr - 1) + len) < memaddr)
1260 sprintf (buf, "m %s;l\r", paddr_nz (memaddr));
1261 puts_e7000debug (buf);
1263 for (count = 0; count < len; count += 4)
1265 /* Suck away the address */
1271 { /* Some kind of error */
1272 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
1273 expect_full_prompt ();
1279 /* Now read in the data */
1280 for (i = 0; i < 4; i++)
1283 if (count + i < len)
1285 myaddr[count + i] = b;
1289 /* Skip the trailing ? and send a . to end and a cr for more */
1292 if (count + 4 >= len)
1293 puts_e7000debug (".\r");
1295 puts_e7000debug ("\r");
1305 For large transfers we used to send
1308 d <addr> <endaddr>\r
1311 <ADDRESS> < D A T A > < ASCII CODE >
1312 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1313 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1314 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1316 A cost in chars for each transaction of 80 + 5*n-bytes.
1318 Large transactions could be done with the srecord load code, but
1319 there is a pause for a second before dumping starts, which slows the
1324 e7000_read_inferior_memory_large (CORE_ADDR memaddr, unsigned char *myaddr,
1331 /* Starting address of this pass. */
1333 if (((memaddr - 1) + len) < memaddr)
1339 sprintf (buf, "d %s %s\r", paddr_nz (memaddr), paddr_nz (memaddr + len - 1));
1340 puts_e7000debug (buf);
1345 /* skip down to the first ">" */
1348 /* now skip to the end of that line */
1355 /* get rid of any white space before the address */
1359 /* Skip the address */
1362 /* read in the bytes on the line */
1363 while (c != '"' && count < len)
1369 myaddr[count++] = get_hex (&c);
1372 /* throw out the rest of the line */
1377 /* wait for the ":" prompt */
1387 fast_but_for_the_pause_e7000_read_inferior_memory (CORE_ADDR memaddr,
1388 char *myaddr, int len)
1394 if (((memaddr - 1) + len) < memaddr)
1400 sprintf (buf, "is %x@%x:s\r", memaddr, len);
1401 puts_e7000debug (buf);
1407 error (_("Memory read error"));
1409 putchar_e7000 (ACK);
1422 case ENQ: /* ENQ, at the end */
1426 /* Start of an Srecord */
1431 case '7': /* Termination record, ignore */
1435 /* Header record - ignore it */
1447 alen = type - '0' + 1;
1451 addr = (addr << 8) + gbyte ();
1455 for (i = 0; i < length - 1; i++)
1456 myaddr[i + addr - memaddr] = gbyte ();
1458 gbyte (); /* Ignore checksum */
1464 putchar_e7000 (ACK);
1465 expect ("TOP ADDRESS =");
1466 expect ("END ADDRESS =");
1474 /* Transfer LEN bytes between GDB address MYADDR and target address
1475 MEMADDR. If WRITE is non-zero, transfer them to the target,
1476 otherwise transfer them from the target. TARGET is unused.
1478 Returns the number of bytes transferred. */
1481 e7000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
1482 int write, struct mem_attrib *attrib,
1483 struct target_ops *target)
1486 return e7000_write_inferior_memory (memaddr, myaddr, len);
1488 return e7000_read_inferior_memory (memaddr, myaddr, len);
1490 return e7000_read_inferior_memory_large (memaddr, myaddr, len);
1499 e7000_load (char *args, int from_tty)
1501 struct cleanup *old_chain;
1505 #define WRITESIZE 0x1000
1506 char buf[2 + 4 + 4 + WRITESIZE]; /* `DT' + <addr> + <len> + <data> */
1510 time_t start_time, end_time; /* Start and end times of download */
1511 unsigned long data_count; /* Number of bytes transferred to memory */
1512 int oldtimeout = timeout;
1514 timeout = remote_timeout;
1517 /* FIXME! change test to test for type of download */
1520 generic_load (args, from_tty);
1524 /* for direct tcp connections, we can do a fast binary download */
1531 while (*args != '\000')
1535 while (isspace (*args))
1540 while ((*args != '\000') && !isspace (*args))
1543 if (*args != '\000')
1548 else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1550 else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1553 error (_("unknown option `%s'"), arg);
1557 filename = get_exec_file (1);
1559 pbfd = bfd_openr (filename, gnutarget);
1562 perror_with_name (filename);
1565 old_chain = make_cleanup_bfd_close (pbfd);
1567 if (!bfd_check_format (pbfd, bfd_object))
1568 error (_("\"%s\" is not an object file: %s"), filename,
1569 bfd_errmsg (bfd_get_error ()));
1571 start_time = time (NULL);
1574 puts_e7000debug ("mw\r");
1578 for (section = pbfd->sections; section; section = section->next)
1580 if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1582 bfd_vma section_address;
1583 bfd_size_type section_size;
1586 section_address = bfd_get_section_vma (pbfd, section);
1587 section_size = bfd_get_section_size (section);
1590 printf_filtered ("[Loading section %s at 0x%s (%s bytes)]\n",
1591 bfd_get_section_name (pbfd, section),
1592 paddr_nz (section_address),
1593 paddr_u (section_size));
1597 data_count += section_size;
1599 while (section_size > 0)
1602 static char inds[] = "|/-\\";
1607 count = min (section_size, WRITESIZE);
1609 buf[2] = section_address >> 24;
1610 buf[3] = section_address >> 16;
1611 buf[4] = section_address >> 8;
1612 buf[5] = section_address;
1614 buf[6] = count >> 24;
1615 buf[7] = count >> 16;
1616 buf[8] = count >> 8;
1619 bfd_get_section_contents (pbfd, section, buf + 10, fptr, count);
1621 if (serial_write (e7000_desc, buf, count + 10))
1622 fprintf_unfiltered (gdb_stderr,
1623 "e7000_load: serial_write failed: %s\n",
1624 safe_strerror (errno));
1630 printf_unfiltered ("\r%c", inds[k++ % 4]);
1631 gdb_flush (gdb_stdout);
1634 section_address += count;
1636 section_size -= count;
1645 end_time = time (NULL);
1647 /* Finally, make the PC point at the start address */
1650 write_pc (bfd_get_start_address (exec_bfd));
1652 inferior_ptid = null_ptid; /* No process now */
1654 /* This is necessary because many things were based on the PC at the time that
1655 we attached to the monitor, which is no longer valid now that we have loaded
1656 new code (and just changed the PC). Another way to do this might be to call
1657 normal_stop, except that the stack may not be valid, and things would get
1658 horribly confused... */
1660 clear_symtab_users ();
1664 entry = bfd_get_start_address (pbfd);
1667 printf_unfiltered ("[Starting %s at 0x%s]\n", filename, paddr_nz (entry));
1669 /* start_routine (entry); */
1672 report_transfer_performance (data_count, start_time, end_time);
1674 do_cleanups (old_chain);
1675 timeout = oldtimeout;
1678 /* Clean up when a program exits.
1680 The program actually lives on in the remote processor's RAM, and may be
1681 run again without a download. Don't leave it full of breakpoint
1685 e7000_mourn_inferior (void)
1687 remove_breakpoints ();
1688 unpush_target (&e7000_ops);
1689 generic_mourn_inferior (); /* Do all the proper things now */
1692 #define MAX_BREAKPOINTS 200
1693 #ifdef HARD_BREAKPOINTS
1694 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
1696 #define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
1699 /* Since we can change to soft breakpoints dynamically, we must define
1700 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
1701 static CORE_ADDR breakaddr[MAX_BREAKPOINTS] =
1705 e7000_insert_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
1710 static char nop[2] = NOP;
1713 for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++)
1714 if (breakaddr[i] == 0)
1716 breakaddr[i] = addr;
1717 /* Save old contents, and insert a nop in the space */
1718 #ifdef HARD_BREAKPOINTS
1721 sprintf (buf, "BC%d A=%s\r", i + 1, paddr_nz (addr));
1722 puts_e7000debug (buf);
1726 sprintf (buf, "B %s\r", paddr_nz (addr));
1727 puts_e7000debug (buf);
1731 e7000_read_inferior_memory (addr, shadow, 2);
1732 e7000_write_inferior_memory (addr, nop, 2);
1735 sprintf (buf, "B %x\r", addr);
1736 puts_e7000debug (buf);
1742 error (_("Too many breakpoints ( > %d) for the E7000."),
1743 MAX_E7000DEBUG_BREAKPOINTS);
1748 e7000_remove_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
1753 for (i = 0; i < MAX_E7000DEBUG_BREAKPOINTS; i++)
1754 if (breakaddr[i] == addr)
1757 #ifdef HARD_BREAKPOINTS
1760 sprintf (buf, "BC%d - \r", i + 1);
1761 puts_e7000debug (buf);
1765 sprintf (buf, "B - %s\r", paddr_nz (addr));
1766 puts_e7000debug (buf);
1770 sprintf (buf, "B - %s\r", paddr_nz (addr));
1771 puts_e7000debug (buf);
1775 /* Replace the insn under the break */
1776 e7000_write_inferior_memory (addr, shadow, 2);
1783 warning (_("Can't find breakpoint associated with 0x%s."), paddr_nz (addr));
1787 /* Put a command string, in args, out to STDBUG. Output from STDBUG
1788 is placed on the users terminal until the prompt is seen. */
1791 e7000_command (char *args, int fromtty)
1793 /* FIXME: arbitrary limit on length of args. */
1799 error (_("e7000 target not open."));
1802 puts_e7000debug ("\r");
1806 sprintf (buf, "%s\r", args);
1807 puts_e7000debug (buf);
1812 expect_full_prompt ();
1815 printf_unfiltered ("\n");
1817 /* Who knows what the command did... */
1818 registers_changed ();
1823 e7000_drain_command (char *args, int fromtty)
1827 puts_e7000debug ("end\r");
1828 putchar_e7000 (CTRLC);
1830 while ((c = readchar (1)) != -1)
1834 putchar_e7000 (CTRLC);
1837 if (c > ' ' && c < 127)
1838 printf_unfiltered ("%c", c & 0xff);
1840 printf_unfiltered ("<%x>", c & 0xff);
1849 static char *strings[NITEMS] =
1856 "ILLEGAL INSTRUCTION",
1863 for (i = 0; i < NITEMS; ++i)
1869 for (i = 0; i < NITEMS; i++)
1876 /* found one of the choices */
1888 /* Suck characters, if a string match, then return the strings index
1889 otherwise echo them. */
1892 expect_n (char **strings)
1898 char *buffer = saveaway;
1899 /* Count number of expect strings */
1901 for (n = 0; strings[n]; n++)
1903 ptr[n] = strings[n];
1914 printf_unfiltered ("[waiting for e7000...]\n");
1927 putchar_e7000 (CTRLC); /* interrupt the running program */
1931 for (i = 0; i < n; i++)
1938 /* Gone all the way */
1945 ptr[i] = strings[i];
1951 /* Save it up incase we find that there was no match */
1956 if (buffer != saveaway)
1959 printf_unfiltered ("%s", buffer);
1964 putchar_unfiltered (c);
1965 gdb_flush (gdb_stdout);
1971 /* We subtract two from the pc here rather than use
1972 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1973 pc, and the simulators never do. */
1981 store_signed_integer (buf,
1982 register_size (current_gdbarch, PC_REGNUM),
1983 read_register (PC_REGNUM) - 2);
1984 regcache_raw_supply (current_regcache, PC_REGNUM, buf);
1985 sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0));
1986 puts_e7000debug (buf2);
1991 #define WAS_RUNNING 2
1994 static char *estrings[] =
2003 /* Wait until the remote machine stops, then return, storing status in
2004 STATUS just as `wait' would. */
2007 e7000_wait (ptid_t ptid, struct target_waitstatus *status)
2011 int running_count = 0;
2014 char *wanted_nopc = NULL;
2017 /* Then echo chars until PC= string seen */
2018 gch (); /* Drop cr */
2019 gch (); /* and space */
2023 switch (expect_n (estrings))
2026 /* how did this happen ? */
2031 putchar_e7000 (CTRLC);
2039 if (running_count == 20)
2041 printf_unfiltered ("[running...]\n");
2051 /* Skip till the PC= */
2054 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
2056 wanted_nopc = want_nopc_sh;
2058 switch (TARGET_ARCHITECTURE->mach)
2063 wanted_nopc = want_nopc_sh3;
2066 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
2068 wanted_nopc = want_nopc_h8300h;
2070 switch (TARGET_ARCHITECTURE->mach)
2072 case bfd_mach_h8300s:
2073 case bfd_mach_h8300sn:
2074 case bfd_mach_h8300sx:
2075 case bfd_mach_h8300sxn:
2076 wanted_nopc = want_nopc_h8300s;
2080 fetch_regs_from_dump (gch, wanted_nopc);
2082 /* And supply the extra ones the simulator uses */
2083 for (regno = realregs; regno < NUM_REGS; regno++)
2086 regcache_raw_supply (current_regcache, regno, (char *) &buf);
2089 stop_reason = why_stop ();
2090 expect_full_prompt ();
2092 status->kind = TARGET_WAITKIND_STOPPED;
2093 status->value.sig = TARGET_SIGNAL_TRAP;
2095 switch (stop_reason)
2097 case 1: /* Breakpoint */
2098 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
2099 status->value.sig = TARGET_SIGNAL_TRAP;
2101 case 0: /* Single step */
2102 status->value.sig = TARGET_SIGNAL_TRAP;
2104 case 2: /* Interrupt */
2107 status->value.sig = TARGET_SIGNAL_TRAP;
2112 status->value.sig = TARGET_SIGNAL_INT;
2118 printf_unfiltered ("a cycle address error?\n");
2119 status->value.sig = TARGET_SIGNAL_UNKNOWN;
2122 status->value.sig = TARGET_SIGNAL_ILL;
2125 status->value.sig = TARGET_SIGNAL_SEGV;
2127 case 7: /* Anything else (NITEMS + 1) */
2128 printf_unfiltered ("a write protect error?\n");
2129 status->value.sig = TARGET_SIGNAL_UNKNOWN;
2132 /* Get the user's attention - this should never happen. */
2133 internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
2136 return inferior_ptid;
2139 /* Stop the running program. */
2144 /* Sending a ^C is supposed to stop the running program. */
2145 putchar_e7000 (CTRLC);
2148 /* Define the target subroutine names. */
2150 struct target_ops e7000_ops;
2153 init_e7000_ops (void)
2155 e7000_ops.to_shortname = "e7000";
2156 e7000_ops.to_longname = "Remote Renesas e7000 target";
2157 e7000_ops.to_doc = "Use a remote Renesas e7000 ICE connected by a serial line;\n\
2158 or a network connection.\n\
2159 Arguments are the name of the device for the serial line,\n\
2160 the speed to connect at in bits per second.\n\
2162 target e7000 /dev/ttya 9600\n\
2163 target e7000 foobar";
2164 e7000_ops.to_open = e7000_open;
2165 e7000_ops.to_close = e7000_close;
2166 e7000_ops.to_detach = e7000_detach;
2167 e7000_ops.to_resume = e7000_resume;
2168 e7000_ops.to_wait = e7000_wait;
2169 e7000_ops.to_fetch_registers = e7000_fetch_register;
2170 e7000_ops.to_store_registers = e7000_store_register;
2171 e7000_ops.to_prepare_to_store = e7000_prepare_to_store;
2172 e7000_ops.deprecated_xfer_memory = e7000_xfer_inferior_memory;
2173 e7000_ops.to_files_info = e7000_files_info;
2174 e7000_ops.to_insert_breakpoint = e7000_insert_breakpoint;
2175 e7000_ops.to_remove_breakpoint = e7000_remove_breakpoint;
2176 e7000_ops.to_kill = e7000_kill;
2177 e7000_ops.to_load = e7000_load;
2178 e7000_ops.to_create_inferior = e7000_create_inferior;
2179 e7000_ops.to_mourn_inferior = e7000_mourn_inferior;
2180 e7000_ops.to_stop = e7000_stop;
2181 e7000_ops.to_stratum = process_stratum;
2182 e7000_ops.to_has_all_memory = 1;
2183 e7000_ops.to_has_memory = 1;
2184 e7000_ops.to_has_stack = 1;
2185 e7000_ops.to_has_registers = 1;
2186 e7000_ops.to_has_execution = 1;
2187 e7000_ops.to_magic = OPS_MAGIC;
2190 extern initialize_file_ftype _initialize_remote_e7000; /* -Wmissing-prototypes */
2193 _initialize_remote_e7000 (void)
2196 add_target (&e7000_ops);
2198 add_com ("e7000", class_obscure, e7000_command,
2199 _("Send a command to the e7000 monitor."));
2201 add_com ("ftplogin", class_obscure, e7000_login_command,
2202 _("Login to machine and change to directory."));
2204 add_com ("ftpload", class_obscure, e7000_ftp_command,
2205 _("Fetch and load a file from previously described place."));
2207 add_com ("drain", class_obscure, e7000_drain_command,
2208 _("Drain pending e7000 text buffers."));
2210 add_setshow_integer_cmd ("usehardbreakpoints", no_class,
2211 &use_hard_breakpoints, _("\
2212 Set use of hardware breakpoints for all breakpoints."), _("\
2213 Show use of hardware breakpoints for all breakpoints."), NULL,
2215 NULL, /* FIXME: i18n: */
2216 &setlist, &showlist);