1 /* Remote debugging interface for Hitachi E7000 ICE, for GDB
2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support.
6 Written by Steve Chamberlain for Cygnus Support.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and
26 Hitachi-SH processor. It has serial port and a lan port.
28 The monitor command set makes it difficult to load large ammounts of
29 data over the lan without using ftp - so try not to issue load
30 commands when communicating over ethernet; use the ftpload command.
32 The monitor pauses for a second when dumping srecords to the serial
33 line too, so we use a slower per byte mechanism but without the
34 startup overhead. Even so, it's pretty slow... */
43 #include "gdb_string.h"
45 #include <sys/types.h>
47 #include "remote-utils.h"
55 #define HARD_BREAKPOINTS /* Now handled by set option. */
56 #define BC_BREAKPOINTS use_hard_breakpoints
64 /* This file is used by 2 different targets, sh-elf and h8300. The
65 h8300 is not multiarched and doesn't use the registers defined in
66 tm-sh.h. To avoid using a macro GDB_TARGET_IS_SH, we do runtime check
67 of the target, which requires that these namse below are always
68 defined also in the h8300 case. */
70 #if !defined (PR_REGNUM)
73 #if !defined (GBR_REGNUM)
76 #if !defined (VBR_REGNUM)
79 #if !defined (MACH_REGNUM)
80 #define MACH_REGNUM -1
82 #if !defined (MACL_REGNUM)
83 #define MACL_REGNUM -1
85 #if !defined (SR_REGNUM)
89 extern void notice_quit (void);
91 extern void report_transfer_performance (unsigned long, time_t, time_t);
93 extern char *sh_processor_type
;
95 /* Local function declarations. */
97 static void e7000_close (int);
99 static void e7000_fetch_register (int);
101 static void e7000_store_register (int);
103 static void e7000_command (char *, int);
105 static void e7000_login_command (char *, int);
107 static void e7000_ftp_command (char *, int);
109 static void e7000_drain_command (char *, int);
111 static void expect (char *);
113 static void expect_full_prompt (void);
115 static void expect_prompt (void);
117 static int e7000_parse_device (char *args
, char *dev_name
, int baudrate
);
120 static serial_t e7000_desc
;
122 /* Allow user to chose between using hardware breakpoints or memory. */
123 static int use_hard_breakpoints
= 0; /* use sw breakpoints by default */
125 /* Nonzero if using the tcp serial driver. */
127 static int using_tcp
; /* direct tcp connection to target */
128 static int using_tcp_remote
; /* indirect connection to target
129 via tcp to controller */
131 /* Nonzero if using the pc isa card. */
135 extern struct target_ops e7000_ops
; /* Forward declaration */
137 char *ENQSTRING
= "\005";
139 /* Nonzero if some routine (as opposed to the user) wants echoing.
140 FIXME: Do this reentrantly with an extra parameter. */
146 static int timeout
= 20;
148 /* Send data to e7000debug. */
151 puts_e7000debug (char *buf
)
154 error ("Use \"target e7000 ...\" first.");
157 printf_unfiltered ("Sending %s\n", buf
);
159 if (SERIAL_WRITE (e7000_desc
, buf
, strlen (buf
)))
160 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
162 /* And expect to see it echoed, unless using the pc interface */
170 putchar_e7000 (int x
)
175 SERIAL_WRITE (e7000_desc
, b
, 1);
179 write_e7000 (char *s
)
181 SERIAL_WRITE (e7000_desc
, s
, strlen (s
));
192 /* Read a character from the remote system, doing all the fancy timeout
193 stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars,
194 returns -1, else returns next char. Discards chars > 127. */
197 readchar (int timeout
)
203 c
= SERIAL_READCHAR (e7000_desc
, timeout
);
207 if (c
== SERIAL_TIMEOUT
)
212 error ("Timeout reading from remote system.");
215 error ("Serial communication error");
219 putchar_unfiltered (c
);
220 gdb_flush (gdb_stdout
);
230 static char b
[8][10];
242 sprintf (b
[p
], "<%d>", x
);
249 /* Scan input from the remote system, until STRING is found. If
250 DISCARD is non-zero, then discard non-matching input, else print it
251 out. Let the user break out immediately. */
254 expect (char *string
)
262 c
= readchar (timeout
);
269 putchar_e7000 (CTRLC
);
281 if (c
== '\r' || c
== '\n')
284 putchar_unfiltered ('\n');
290 putchar_unfiltered (c
);
292 gdb_flush (gdb_stdout
);
294 if (normal (c
) == normal (*p
++))
303 if (normal (c
) == normal (string
[0]))
309 /* Keep discarding input until we see the e7000 prompt.
311 The convention for dealing with the prompt is that you
313 o *then* wait for the prompt.
315 Thus the last thing that a procedure does with the serial line will
316 be an expect_prompt(). Exception: e7000_resume does not wait for
317 the prompt, because the terminal is being handed over to the
318 inferior. However, the next thing which happens after that is a
319 e7000_wait which does wait for the prompt. Note that this includes
320 abnormal exit, e.g. error(). This is necessary to prevent getting
321 into states from which we can't recover. */
330 expect_full_prompt (void)
336 convert_hex_digit (int ch
)
338 if (ch
>= '0' && ch
<= '9')
340 else if (ch
>= 'A' && ch
<= 'F')
341 return ch
- 'A' + 10;
342 else if (ch
>= 'a' && ch
<= 'f')
343 return ch
- 'a' + 10;
350 int value
= convert_hex_digit (*start
);
353 *start
= readchar (timeout
);
354 while ((try = convert_hex_digit (*start
)) >= 0)
358 *start
= readchar (timeout
);
364 /* Get N 32-bit words from remote, each preceded by a space, and put
365 them in registers starting at REGNO. */
368 get_hex_regs (int n
, int regno
)
373 for (i
= 0; i
< n
; i
++)
378 for (j
= 0; j
< 8; j
++)
379 val
= (val
<< 4) + get_hex_digit (j
== 0);
380 supply_register (regno
++, (char *) &val
);
385 /* This is called not only when we first attach, but also when the
386 user types "run" after having attached. */
389 e7000_create_inferior (char *execfile
, char *args
, char **env
)
394 error ("Can't pass arguments to remote E7000DEBUG process");
396 if (execfile
== 0 || exec_bfd
== 0)
397 error ("No executable file specified");
399 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
401 #ifdef CREATE_INFERIOR_HOOK
402 CREATE_INFERIOR_HOOK (0); /* No process-ID */
405 /* The "process" (board) is already stopped awaiting our commands, and
406 the program is already downloaded. We just set its PC and go. */
408 clear_proceed_status ();
410 /* Tell wait_for_inferior that we've started a new process. */
411 init_wait_for_inferior ();
413 /* Set up the "saved terminal modes" of the inferior
414 based on what modes we are starting it with. */
415 target_terminal_init ();
417 /* Install inferior's terminal modes. */
418 target_terminal_inferior ();
420 /* insert_step_breakpoint (); FIXME, do we need this? */
421 proceed ((CORE_ADDR
) entry_pt
, -1, 0); /* Let 'er rip... */
424 /* Open a connection to a remote debugger. NAME is the filename used
425 for communication. */
427 static int baudrate
= 9600;
428 static char dev_name
[100];
430 static char *machine
= "";
431 static char *user
= "";
432 static char *passwd
= "";
433 static char *dir
= "";
435 /* Grab the next token and buy some space for it */
445 while (*p
&& *p
== ' ')
448 while (*p
&& (*p
!= ' ' && *p
!= '\t'))
461 e7000_login_command (char *args
, int from_tty
)
465 machine
= next (&args
);
467 passwd
= next (&args
);
471 printf_unfiltered ("Set info to %s %s %s %s\n", machine
, user
, passwd
, dir
);
476 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
480 /* Start an ftp transfer from the E7000 to a host */
483 e7000_ftp_command (char *args
, int from_tty
)
485 /* FIXME: arbitrary limit on machine names and such. */
488 int oldtimeout
= timeout
;
489 timeout
= remote_timeout
;
491 sprintf (buf
, "ftp %s\r", machine
);
492 puts_e7000debug (buf
);
493 expect (" Username : ");
494 sprintf (buf
, "%s\r", user
);
495 puts_e7000debug (buf
);
496 expect (" Password : ");
497 write_e7000 (passwd
);
499 expect ("success\r");
501 sprintf (buf
, "cd %s\r", dir
);
502 puts_e7000debug (buf
);
504 sprintf (buf
, "ll 0;s:%s\r", args
);
505 puts_e7000debug (buf
);
507 puts_e7000debug ("bye\r");
509 timeout
= oldtimeout
;
513 e7000_parse_device (char *args
, char *dev_name
, int baudrate
)
517 if (args
&& strcasecmp (args
, "pc") == 0)
519 strcpy (dev_name
, args
);
524 /* FIXME! temp hack to allow use with port master -
525 target tcp_remote <device> */
526 if (args
&& strncmp (args
, "tcp", 10) == 0)
529 n
= sscanf (args
, " %s %s %d %s", com_type
, dev_name
, &baudrate
, junk
);
530 using_tcp_remote
= 1;
535 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
538 if (n
!= 1 && n
!= 2)
540 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
541 or \t\ttarget e7000 <host>[:<port>]\n\
542 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
543 or \t\ttarget e7000 pc\n");
546 #if !defined(__GO32__) && !defined(_WIN32)
547 /* FIXME! test for ':' is ambiguous */
548 if (n
== 1 && strchr (dev_name
, ':') == 0)
550 /* Default to normal telnet port */
551 /* serial_open will use this to determine tcp communication */
552 strcat (dev_name
, ":23");
555 if (!using_tcp_remote
&& strchr (dev_name
, ':'))
562 /* Stub for catch_errors. */
565 e7000_start_remote (void *dummy
)
572 immediate_quit
++; /* Allow user to interrupt it */
574 /* Hello? Are you there? */
579 putchar_e7000 (CTRLC
);
580 while (!sync
&& ++try <= quit_trying
)
584 printf_unfiltered ("[waiting for e7000...]\n");
589 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
590 * we get stuck in this loop ...
591 * We may never timeout, and never sync up :-(
593 while (!sync
&& c
!= -1)
598 putchar_unfiltered (c
);
599 gdb_flush (gdb_stdout
);
601 /* Shouldn't we either break here, or check for sync in inner loop? */
607 putchar_e7000 (CTRLC
);
615 putchar_e7000 (CTRLC
);
616 /* Was-> quit_flag = 0; */
618 quit_trying
= try + 1; /* we don't want to try anymore */
629 fprintf_unfiltered (gdb_stderr
, "Giving up after %d tries...\n", try);
630 error ("Unable to synchronize with target.\n");
633 puts_e7000debug ("\r");
635 puts_e7000debug ("b -\r"); /* Clear breakpoints */
640 /* This is really the job of start_remote however, that makes an assumption
641 that the target is about to print out a status message of some sort. That
642 doesn't happen here. */
644 flush_cached_frames ();
645 registers_changed ();
646 stop_pc
= read_pc ();
647 set_current_frame (create_new_frame (read_fp (), stop_pc
));
648 select_frame (get_current_frame (), 0);
649 print_stack_frame (selected_frame
, -1, 1);
655 e7000_open (char *args
, int from_tty
)
659 target_preopen (from_tty
);
661 n
= e7000_parse_device (args
, dev_name
, baudrate
);
663 push_target (&e7000_ops
);
665 e7000_desc
= SERIAL_OPEN (dev_name
);
668 perror_with_name (dev_name
);
670 SERIAL_SETBAUDRATE (e7000_desc
, baudrate
);
671 SERIAL_RAW (e7000_desc
);
673 #ifdef GDB_TARGET_IS_H8300
677 /* Start the remote connection; if error (0), discard this target.
678 In particular, if the user quits, be sure to discard it
679 (we'd be in an inconsistent state otherwise). */
680 if (!catch_errors (e7000_start_remote
, (char *) 0,
681 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL
))
683 printf_filtered ("Remote target %s connected to %s\n", target_shortname
,
687 /* Close out all files and local state before this target loses control. */
690 e7000_close (int quitting
)
694 SERIAL_CLOSE (e7000_desc
);
699 /* Terminate the open connection to the remote debugger. Use this
700 when you want to detach and do something else with your gdb. */
703 e7000_detach (char *arg
, int from_tty
)
705 pop_target (); /* calls e7000_close to do the real work */
707 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
710 /* Tell the remote machine to resume. */
713 e7000_resume (int pid
, int step
, enum target_signal sigal
)
716 puts_e7000debug ("S\r");
718 puts_e7000debug ("G\r");
721 /* Read the remote registers into the block REGS.
723 For the H8/300 a register dump looks like:
725 PC=00021A CCR=80:I*******
726 ER0 - ER3 0000000A 0000002E 0000002E 00000000
727 ER4 - ER7 00000000 00000000 00000000 00FFEFF6
733 char *want_h8300h
= "PC=%p CCR=%c\n\
734 ER0 - ER3 %0 %1 %2 %3\n\
735 ER4 - ER7 %4 %5 %6 %7\n";
737 char *want_nopc_h8300h
= "%p CCR=%c\n\
738 ER0 - ER3 %0 %1 %2 %3\n\
739 ER4 - ER7 %4 %5 %6 %7";
741 char *want_h8300s
= "PC=%p CCR=%c\n\
743 ER0 - ER3 %0 %1 %2 %3\n\
744 ER4 - ER7 %4 %5 %6 %7\n";
746 char *want_nopc_h8300s
= "%p CCR=%c EXR=%9\n\
747 ER0 - ER3 %0 %1 %2 %3\n\
748 ER4 - ER7 %4 %5 %6 %7";
750 char *want_sh
= "PC=%16 SR=%22\n\
751 PR=%17 GBR=%18 VBR=%19\n\
753 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
754 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
756 char *want_nopc_sh
= "%16 SR=%22\n\
757 PR=%17 GBR=%18 VBR=%19\n\
759 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
760 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
762 char *want_sh3
= "PC=%16 SR=%22\n\
763 PR=%17 GBR=%18 VBR=%19\n\
764 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
765 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
766 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
767 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
768 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
769 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
770 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
772 char *want_nopc_sh3
= "%16 SR=%22\n\
773 PR=%17 GBR=%18 VBR=%19\n\
774 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\
775 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
776 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
777 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
778 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
779 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
780 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
785 return readchar (timeout
);
791 int high
= convert_hex_digit (gch ());
792 int low
= convert_hex_digit (gch ());
794 return (high
<< 4) + low
;
798 fetch_regs_from_dump (int (*nextchar
) (), char *want
)
801 char buf
[MAX_REGISTER_RAW_SIZE
];
803 int thischar
= nextchar ();
810 /* Skip to end of line and then eat all new line type stuff */
811 while (thischar
!= '\n' && thischar
!= '\r')
812 thischar
= nextchar ();
813 while (thischar
== '\n' || thischar
== '\r')
814 thischar
= nextchar ();
819 while (thischar
== ' '
823 thischar
= nextchar ();
828 if (*want
== thischar
)
832 thischar
= nextchar ();
835 else if (thischar
== ' ' || thischar
== '\n' || thischar
== '\r')
837 thischar
= nextchar ();
841 error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
842 want
, thischar
, thischar
);
847 /* Got a register command */
877 if (isdigit (want
[0]))
879 if (isdigit (want
[1]))
881 regno
= (want
[0] - '0') * 10 + want
[1] - '0';
886 regno
= want
[0] - '0';
892 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
894 store_signed_integer (buf
,
895 REGISTER_RAW_SIZE (regno
),
896 (LONGEST
) get_hex (&thischar
));
897 supply_register (regno
, buf
);
904 e7000_fetch_registers (void)
909 puts_e7000debug ("R\r");
911 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
914 switch (TARGET_ARCHITECTURE
->mach
)
922 #ifdef GDB_TARGET_IS_H8300
923 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_h8300
)
926 wanted
= want_h8300s
;
928 wanted
= want_h8300h
;
932 fetch_regs_from_dump (gch
, wanted
);
934 /* And supply the extra ones the simulator uses */
935 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
939 supply_register (regno
, (char *) (&buf
));
943 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
947 e7000_fetch_register (int regno
)
949 e7000_fetch_registers ();
952 /* Store the remote registers from the contents of the block REGS. */
955 e7000_store_registers (void)
959 for (regno
= 0; regno
< NUM_REALREGS
; regno
++)
960 e7000_store_register (regno
);
962 registers_changed ();
965 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
968 e7000_store_register (int regno
)
974 e7000_store_registers ();
978 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_h8300
)
982 sprintf (buf
, ".ER%d %lx\r", regno
, read_register (regno
));
983 puts_e7000debug (buf
);
985 else if (regno
== PC_REGNUM
)
987 sprintf (buf
, ".PC %lx\r", read_register (regno
));
988 puts_e7000debug (buf
);
991 else if (regno
== CCR_REGNUM
)
993 sprintf (buf
, ".CCR %lx\r", read_register (regno
));
994 puts_e7000debug (buf
);
999 else if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
1001 if (regno
== PC_REGNUM
)
1003 sprintf (buf
, ".PC %lx\r", read_register (regno
));
1004 puts_e7000debug (buf
);
1007 else if (regno
== SR_REGNUM
)
1009 sprintf (buf
, ".SR %lx\r", read_register (regno
));
1010 puts_e7000debug (buf
);
1013 else if (regno
== PR_REGNUM
)
1015 sprintf (buf
, ".PR %lx\r", read_register (regno
));
1016 puts_e7000debug (buf
);
1019 else if (regno
== GBR_REGNUM
)
1021 sprintf (buf
, ".GBR %lx\r", read_register (regno
));
1022 puts_e7000debug (buf
);
1025 else if (regno
== VBR_REGNUM
)
1027 sprintf (buf
, ".VBR %lx\r", read_register (regno
));
1028 puts_e7000debug (buf
);
1031 else if (regno
== MACH_REGNUM
)
1033 sprintf (buf
, ".MACH %lx\r", read_register (regno
));
1034 puts_e7000debug (buf
);
1037 else if (regno
== MACL_REGNUM
)
1039 sprintf (buf
, ".MACL %lx\r", read_register (regno
));
1040 puts_e7000debug (buf
);
1044 sprintf (buf
, ".R%d %lx\r", regno
, read_register (regno
));
1045 puts_e7000debug (buf
);
1052 /* Get ready to modify the registers array. On machines which store
1053 individual registers, this doesn't need to do anything. On machines
1054 which store all the registers in one fell swoop, this makes sure
1055 that registers contains all the registers from the program being
1059 e7000_prepare_to_store (void)
1061 /* Do nothing, since we can store individual regs */
1065 e7000_files_info (struct target_ops
*ops
)
1067 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baudrate
);
1071 stickbyte (char *where
, unsigned int what
)
1073 static CONST
char digs
[] = "0123456789ABCDEF";
1075 where
[0] = digs
[(what
>> 4) & 0xf];
1076 where
[1] = digs
[(what
& 0xf) & 0xf];
1081 /* Write a small ammount of memory. */
1084 write_small (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1089 for (i
= 0; i
< len
; i
++)
1091 if (((memaddr
+ i
) & 3) == 0 && (i
+ 3 < len
))
1093 /* Can be done with a long word */
1094 sprintf (buf
, "m %lx %x%02x%02x%02x;l\r",
1096 myaddr
[i
], myaddr
[i
+ 1], myaddr
[i
+ 2], myaddr
[i
+ 3]);
1097 puts_e7000debug (buf
);
1102 sprintf (buf
, "m %lx %x\r", memaddr
+ i
, myaddr
[i
]);
1103 puts_e7000debug (buf
);
1112 /* Write a large ammount of memory, this only works with the serial
1113 mode enabled. Command is sent as
1128 write_large (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1131 #define maxstride 128
1134 puts_e7000debug ("IL ;S:FK\r");
1136 putchar_e7000 (ACK
);
1139 for (i
= 0; i
< len
; i
+= stride
)
1141 char compose
[maxstride
* 2 + 50];
1142 int address
= i
+ memaddr
;
1149 if (stride
> maxstride
)
1152 compose
[where
++] = 'S';
1154 if (address
>= 0xffffff)
1156 else if (address
>= 0xffff)
1161 compose
[where
++] = alen
- 1 + '0';
1162 /* Insert length. */
1163 check_sum
+= stickbyte (compose
+ where
, alen
+ stride
+ 1);
1168 check_sum
+= stickbyte (compose
+ where
, address
>> (8 * (alen
)));
1172 for (j
= 0; j
< stride
; j
++)
1174 check_sum
+= stickbyte (compose
+ where
, myaddr
[i
+ j
]);
1177 stickbyte (compose
+ where
, ~check_sum
);
1179 compose
[where
++] = '\r';
1180 compose
[where
++] = '\n';
1181 compose
[where
++] = 0;
1183 SERIAL_WRITE (e7000_desc
, compose
, where
);
1187 /* This is ok - nothing there */
1191 /* Hmm, it's trying to tell us something */
1193 error ("Error writing memory");
1197 printf_unfiltered ("@%d}@", j
);
1198 while ((j
= readchar (0)) > 0)
1200 printf_unfiltered ("@{%d}@", j
);
1205 /* Send the trailer record */
1206 write_e7000 ("S70500000000FA\r");
1207 putchar_e7000 (CTRLZ
);
1209 putchar_e7000 (ACK
);
1215 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1216 memory at MEMADDR. Returns length moved.
1218 Can't use the Srecord load over ethernet, so don't use fast method
1222 e7000_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1224 if (len
< 16 || using_tcp
|| using_pc
)
1225 return write_small (memaddr
, myaddr
, len
);
1227 return write_large (memaddr
, myaddr
, len
);
1230 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1231 at debugger address MYADDR. Returns length moved.
1233 Small transactions we send
1240 e7000_read_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
1246 /* Starting address of this pass. */
1248 /* printf("READ INF %x %x %d\n", memaddr, myaddr, len); */
1249 if (((memaddr
- 1) + len
) < memaddr
)
1255 sprintf (buf
, "m %lx;l\r", memaddr
);
1256 puts_e7000debug (buf
);
1258 for (count
= 0; count
< len
; count
+= 4)
1260 /* Suck away the address */
1266 { /* Some kind of error */
1267 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
1268 expect_full_prompt ();
1274 /* Now read in the data */
1275 for (i
= 0; i
< 4; i
++)
1278 if (count
+ i
< len
)
1280 myaddr
[count
+ i
] = b
;
1284 /* Skip the trailing ? and send a . to end and a cr for more */
1287 if (count
+ 4 >= len
)
1288 puts_e7000debug (".\r");
1290 puts_e7000debug ("\r");
1300 For large transfers we used to send
1303 d <addr> <endaddr>\r
1306 <ADDRESS> < D A T A > < ASCII CODE >
1307 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1308 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1309 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1311 A cost in chars for each transaction of 80 + 5*n-bytes.
1313 Large transactions could be done with the srecord load code, but
1314 there is a pause for a second before dumping starts, which slows the
1319 e7000_read_inferior_memory_large (CORE_ADDR memaddr
, unsigned char *myaddr
,
1326 /* Starting address of this pass. */
1328 if (((memaddr
- 1) + len
) < memaddr
)
1334 sprintf (buf
, "d %lx %lx\r", memaddr
, memaddr
+ len
- 1);
1335 puts_e7000debug (buf
);
1340 /* skip down to the first ">" */
1343 /* now skip to the end of that line */
1350 /* get rid of any white space before the address */
1354 /* Skip the address */
1357 /* read in the bytes on the line */
1358 while (c
!= '"' && count
< len
)
1364 myaddr
[count
++] = get_hex (&c
);
1367 /* throw out the rest of the line */
1372 /* wait for the ":" prompt */
1382 fast_but_for_the_pause_e7000_read_inferior_memory (CORE_ADDR memaddr
,
1383 char *myaddr
, int len
)
1389 if (((memaddr
- 1) + len
) < memaddr
)
1395 sprintf (buf
, "is %x@%x:s\r", memaddr
, len
);
1396 puts_e7000debug (buf
);
1402 error ("Memory read error");
1404 putchar_e7000 (ACK
);
1417 case ENQ
: /* ENQ, at the end */
1421 /* Start of an Srecord */
1426 case '7': /* Termination record, ignore */
1430 /* Header record - ignore it */
1442 alen
= type
- '0' + 1;
1446 addr
= (addr
<< 8) + gbyte ();
1450 for (i
= 0; i
< length
- 1; i
++)
1451 myaddr
[i
+ addr
- memaddr
] = gbyte ();
1453 gbyte (); /* Ignore checksum */
1459 putchar_e7000 (ACK
);
1460 expect ("TOP ADDRESS =");
1461 expect ("END ADDRESS =");
1469 /* Transfer LEN bytes between GDB address MYADDR and target address
1470 MEMADDR. If WRITE is non-zero, transfer them to the target,
1471 otherwise transfer them from the target. TARGET is unused.
1473 Returns the number of bytes transferred. */
1476 e7000_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
,
1478 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
1479 struct target_ops
*target ATTRIBUTE_UNUSED
)
1482 return e7000_write_inferior_memory (memaddr
, myaddr
, len
);
1484 return e7000_read_inferior_memory (memaddr
, myaddr
, len
);
1486 return e7000_read_inferior_memory_large (memaddr
, myaddr
, len
);
1495 e7000_load (char *args
, int from_tty
)
1497 struct cleanup
*old_chain
;
1501 #define WRITESIZE 0x1000
1502 char buf
[2 + 4 + 4 + WRITESIZE
]; /* `DT' + <addr> + <len> + <data> */
1506 time_t start_time
, end_time
; /* Start and end times of download */
1507 unsigned long data_count
; /* Number of bytes transferred to memory */
1508 int oldtimeout
= timeout
;
1510 timeout
= remote_timeout
;
1513 /* FIXME! change test to test for type of download */
1516 generic_load (args
, from_tty
);
1520 /* for direct tcp connections, we can do a fast binary download */
1527 while (*args
!= '\000')
1531 while (isspace (*args
))
1536 while ((*args
!= '\000') && !isspace (*args
))
1539 if (*args
!= '\000')
1544 else if (strncmp (arg
, "-quiet", strlen (arg
)) == 0)
1546 else if (strncmp (arg
, "-nostart", strlen (arg
)) == 0)
1549 error ("unknown option `%s'", arg
);
1553 filename
= get_exec_file (1);
1555 pbfd
= bfd_openr (filename
, gnutarget
);
1558 perror_with_name (filename
);
1561 old_chain
= make_cleanup_bfd_close (pbfd
);
1563 if (!bfd_check_format (pbfd
, bfd_object
))
1564 error ("\"%s\" is not an object file: %s", filename
,
1565 bfd_errmsg (bfd_get_error ()));
1567 start_time
= time (NULL
);
1570 puts_e7000debug ("mw\r");
1574 for (section
= pbfd
->sections
; section
; section
= section
->next
)
1576 if (bfd_get_section_flags (pbfd
, section
) & SEC_LOAD
)
1578 bfd_vma section_address
;
1579 bfd_size_type section_size
;
1582 section_address
= bfd_get_section_vma (pbfd
, section
);
1583 section_size
= bfd_get_section_size_before_reloc (section
);
1586 printf_filtered ("[Loading section %s at 0x%x (%ud bytes)]\n",
1587 bfd_get_section_name (pbfd
, section
),
1593 data_count
+= section_size
;
1595 while (section_size
> 0)
1598 static char inds
[] = "|/-\\";
1603 count
= min (section_size
, WRITESIZE
);
1605 buf
[2] = section_address
>> 24;
1606 buf
[3] = section_address
>> 16;
1607 buf
[4] = section_address
>> 8;
1608 buf
[5] = section_address
;
1610 buf
[6] = count
>> 24;
1611 buf
[7] = count
>> 16;
1612 buf
[8] = count
>> 8;
1615 bfd_get_section_contents (pbfd
, section
, buf
+ 10, fptr
, count
);
1617 if (SERIAL_WRITE (e7000_desc
, buf
, count
+ 10))
1618 fprintf_unfiltered (gdb_stderr
,
1619 "e7000_load: SERIAL_WRITE failed: %s\n",
1620 safe_strerror (errno
));
1626 printf_unfiltered ("\r%c", inds
[k
++ % 4]);
1627 gdb_flush (gdb_stdout
);
1630 section_address
+= count
;
1632 section_size
-= count
;
1641 end_time
= time (NULL
);
1643 /* Finally, make the PC point at the start address */
1646 write_pc (bfd_get_start_address (exec_bfd
));
1648 inferior_pid
= 0; /* No process now */
1650 /* This is necessary because many things were based on the PC at the time that
1651 we attached to the monitor, which is no longer valid now that we have loaded
1652 new code (and just changed the PC). Another way to do this might be to call
1653 normal_stop, except that the stack may not be valid, and things would get
1654 horribly confused... */
1656 clear_symtab_users ();
1660 entry
= bfd_get_start_address (pbfd
);
1663 printf_unfiltered ("[Starting %s at 0x%x]\n", filename
, entry
);
1665 /* start_routine (entry); */
1668 report_transfer_performance (data_count
, start_time
, end_time
);
1670 do_cleanups (old_chain
);
1671 timeout
= oldtimeout
;
1674 /* Clean up when a program exits.
1676 The program actually lives on in the remote processor's RAM, and may be
1677 run again without a download. Don't leave it full of breakpoint
1681 e7000_mourn_inferior (void)
1683 remove_breakpoints ();
1684 unpush_target (&e7000_ops
);
1685 generic_mourn_inferior (); /* Do all the proper things now */
1688 #define MAX_BREAKPOINTS 200
1689 #ifdef HARD_BREAKPOINTS
1690 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
1692 #define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
1695 /* Since we can change to soft breakpoints dynamically, we must define
1696 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
1697 static CORE_ADDR breakaddr
[MAX_BREAKPOINTS
] =
1701 e7000_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
1706 static char nop
[2] = NOP
;
1709 for (i
= 0; i
<= MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1710 if (breakaddr
[i
] == 0)
1712 breakaddr
[i
] = addr
;
1713 /* Save old contents, and insert a nop in the space */
1714 #ifdef HARD_BREAKPOINTS
1717 sprintf (buf
, "BC%d A=%lx\r", i
+ 1, addr
);
1718 puts_e7000debug (buf
);
1722 sprintf (buf
, "B %lx\r", addr
);
1723 puts_e7000debug (buf
);
1727 e7000_read_inferior_memory (addr
, shadow
, 2);
1728 e7000_write_inferior_memory (addr
, nop
, 2);
1731 sprintf (buf
, "B %x\r", addr
);
1732 puts_e7000debug (buf
);
1738 error ("Too many breakpoints ( > %d) for the E7000\n",
1739 MAX_E7000DEBUG_BREAKPOINTS
);
1744 e7000_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
1749 for (i
= 0; i
< MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1750 if (breakaddr
[i
] == addr
)
1753 #ifdef HARD_BREAKPOINTS
1756 sprintf (buf
, "BC%d - \r", i
+ 1);
1757 puts_e7000debug (buf
);
1761 sprintf (buf
, "B - %lx\r", addr
);
1762 puts_e7000debug (buf
);
1766 sprintf (buf
, "B - %lx\r", addr
);
1767 puts_e7000debug (buf
);
1771 /* Replace the insn under the break */
1772 e7000_write_inferior_memory (addr
, shadow
, 2);
1779 warning ("Can't find breakpoint associated with 0x%lx\n", addr
);
1783 /* Put a command string, in args, out to STDBUG. Output from STDBUG
1784 is placed on the users terminal until the prompt is seen. */
1787 e7000_command (char *args
, int fromtty
)
1789 /* FIXME: arbitrary limit on length of args. */
1795 error ("e7000 target not open.");
1798 puts_e7000debug ("\r");
1802 sprintf (buf
, "%s\r", args
);
1803 puts_e7000debug (buf
);
1808 expect_full_prompt ();
1811 printf_unfiltered ("\n");
1813 /* Who knows what the command did... */
1814 registers_changed ();
1819 e7000_drain_command (char *args
, int fromtty
)
1823 puts_e7000debug ("end\r");
1824 putchar_e7000 (CTRLC
);
1826 while ((c
= readchar (1) != -1))
1830 putchar_e7000 (CTRLC
);
1833 if (c
> ' ' && c
< 127)
1834 printf_unfiltered ("%c", c
& 0xff);
1836 printf_unfiltered ("<%x>", c
& 0xff);
1845 static char *strings
[NITEMS
] =
1852 "ILLEGAL INSTRUCTION",
1859 for (i
= 0; i
< NITEMS
; ++i
)
1865 for (i
= 0; i
< NITEMS
; i
++)
1872 /* found one of the choices */
1884 /* Suck characters, if a string match, then return the strings index
1885 otherwise echo them. */
1888 expect_n (char **strings
)
1894 char *buffer
= saveaway
;
1895 /* Count number of expect strings */
1897 for (n
= 0; strings
[n
]; n
++)
1899 ptr
[n
] = strings
[n
];
1910 printf_unfiltered ("[waiting for e7000...]\n");
1923 putchar_e7000 (CTRLC
); /* interrupt the running program */
1927 for (i
= 0; i
< n
; i
++)
1934 /* Gone all the way */
1941 ptr
[i
] = strings
[i
];
1947 /* Save it up incase we find that there was no match */
1952 if (buffer
!= saveaway
)
1955 printf_unfiltered ("%s", buffer
);
1960 putchar_unfiltered (c
);
1961 gdb_flush (gdb_stdout
);
1967 /* We subtract two from the pc here rather than use
1968 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1969 pc, and the simulators never do. */
1977 store_signed_integer (buf
,
1978 REGISTER_RAW_SIZE (PC_REGNUM
),
1979 read_register (PC_REGNUM
) - 2);
1980 supply_register (PC_REGNUM
, buf
);
1981 sprintf (buf2
, ".PC %lx\r", read_register (PC_REGNUM
));
1982 puts_e7000debug (buf2
);
1987 #define WAS_RUNNING 2
1990 static char *estrings
[] =
1999 /* Wait until the remote machine stops, then return, storing status in
2000 STATUS just as `wait' would. */
2003 e7000_wait (int pid
, struct target_waitstatus
*status
)
2007 int running_count
= 0;
2012 /* Then echo chars until PC= string seen */
2013 gch (); /* Drop cr */
2014 gch (); /* and space */
2018 switch (expect_n (estrings
))
2021 /* how did this happen ? */
2026 putchar_e7000 (CTRLC
);
2034 if (running_count
== 20)
2036 printf_unfiltered ("[running...]\n");
2046 /* Skip till the PC= */
2049 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
2051 wanted_nopc
= want_nopc_sh
;
2052 switch (TARGET_ARCHITECTURE
->mach
)
2057 wanted_nopc
= want_nopc_sh3
;
2060 #ifdef GDB_TARGET_IS_H8300
2061 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_h8300
)
2064 wanted_nopc
= want_nopc_h8300s
;
2066 wanted_nopc
= want_nopc_h8300h
;
2069 fetch_regs_from_dump (gch
, wanted_nopc
);
2071 /* And supply the extra ones the simulator uses */
2072 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
2075 supply_register (regno
, (char *) &buf
);
2078 stop_reason
= why_stop ();
2079 expect_full_prompt ();
2081 status
->kind
= TARGET_WAITKIND_STOPPED
;
2082 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2084 switch (stop_reason
)
2086 case 1: /* Breakpoint */
2087 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
2088 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2090 case 0: /* Single step */
2091 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2093 case 2: /* Interrupt */
2096 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2101 status
->value
.sig
= TARGET_SIGNAL_INT
;
2107 printf_unfiltered ("a cycle address error?\n");
2108 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2111 status
->value
.sig
= TARGET_SIGNAL_ILL
;
2114 status
->value
.sig
= TARGET_SIGNAL_SEGV
;
2116 case 7: /* Anything else (NITEMS + 1) */
2117 printf_unfiltered ("a write protect error?\n");
2118 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2121 /* Get the user's attention - this should never happen. */
2122 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2128 /* Stop the running program. */
2133 /* Sending a ^C is supposed to stop the running program. */
2134 putchar_e7000 (CTRLC
);
2137 /* Define the target subroutine names. */
2139 struct target_ops e7000_ops
;
2142 init_e7000_ops (void)
2144 e7000_ops
.to_shortname
= "e7000";
2145 e7000_ops
.to_longname
= "Remote Hitachi e7000 target";
2146 e7000_ops
.to_doc
= "Use a remote Hitachi e7000 ICE connected by a serial line;\n\
2147 or a network connection.\n\
2148 Arguments are the name of the device for the serial line,\n\
2149 the speed to connect at in bits per second.\n\
2151 target e7000 /dev/ttya 9600\n\
2152 target e7000 foobar";
2153 e7000_ops
.to_open
= e7000_open
;
2154 e7000_ops
.to_close
= e7000_close
;
2155 e7000_ops
.to_attach
= 0;
2156 e7000_ops
.to_post_attach
= NULL
;
2157 e7000_ops
.to_require_attach
= NULL
;
2158 e7000_ops
.to_detach
= e7000_detach
;
2159 e7000_ops
.to_require_detach
= NULL
;
2160 e7000_ops
.to_resume
= e7000_resume
;
2161 e7000_ops
.to_wait
= e7000_wait
;
2162 e7000_ops
.to_post_wait
= NULL
;
2163 e7000_ops
.to_fetch_registers
= e7000_fetch_register
;
2164 e7000_ops
.to_store_registers
= e7000_store_register
;
2165 e7000_ops
.to_prepare_to_store
= e7000_prepare_to_store
;
2166 e7000_ops
.to_xfer_memory
= e7000_xfer_inferior_memory
;
2167 e7000_ops
.to_files_info
= e7000_files_info
;
2168 e7000_ops
.to_insert_breakpoint
= e7000_insert_breakpoint
;
2169 e7000_ops
.to_remove_breakpoint
= e7000_remove_breakpoint
;
2170 e7000_ops
.to_terminal_init
= 0;
2171 e7000_ops
.to_terminal_inferior
= 0;
2172 e7000_ops
.to_terminal_ours_for_output
= 0;
2173 e7000_ops
.to_terminal_ours
= 0;
2174 e7000_ops
.to_terminal_info
= 0;
2175 e7000_ops
.to_kill
= e7000_kill
;
2176 e7000_ops
.to_load
= e7000_load
;
2177 e7000_ops
.to_lookup_symbol
= 0;
2178 e7000_ops
.to_create_inferior
= e7000_create_inferior
;
2179 e7000_ops
.to_post_startup_inferior
= NULL
;
2180 e7000_ops
.to_acknowledge_created_inferior
= NULL
;
2181 e7000_ops
.to_clone_and_follow_inferior
= NULL
;
2182 e7000_ops
.to_post_follow_inferior_by_clone
= NULL
;
2183 e7000_ops
.to_insert_fork_catchpoint
= NULL
;
2184 e7000_ops
.to_remove_fork_catchpoint
= NULL
;
2185 e7000_ops
.to_insert_vfork_catchpoint
= NULL
;
2186 e7000_ops
.to_remove_vfork_catchpoint
= NULL
;
2187 e7000_ops
.to_has_forked
= NULL
;
2188 e7000_ops
.to_has_vforked
= NULL
;
2189 e7000_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2190 e7000_ops
.to_post_follow_vfork
= NULL
;
2191 e7000_ops
.to_insert_exec_catchpoint
= NULL
;
2192 e7000_ops
.to_remove_exec_catchpoint
= NULL
;
2193 e7000_ops
.to_has_execd
= NULL
;
2194 e7000_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2195 e7000_ops
.to_has_exited
= NULL
;
2196 e7000_ops
.to_mourn_inferior
= e7000_mourn_inferior
;
2197 e7000_ops
.to_can_run
= 0;
2198 e7000_ops
.to_notice_signals
= 0;
2199 e7000_ops
.to_thread_alive
= 0;
2200 e7000_ops
.to_stop
= e7000_stop
;
2201 e7000_ops
.to_pid_to_exec_file
= NULL
;
2202 e7000_ops
.to_core_file_to_sym_file
= NULL
;
2203 e7000_ops
.to_stratum
= process_stratum
;
2204 e7000_ops
.DONT_USE
= 0;
2205 e7000_ops
.to_has_all_memory
= 1;
2206 e7000_ops
.to_has_memory
= 1;
2207 e7000_ops
.to_has_stack
= 1;
2208 e7000_ops
.to_has_registers
= 1;
2209 e7000_ops
.to_has_execution
= 1;
2210 e7000_ops
.to_sections
= 0;
2211 e7000_ops
.to_sections_end
= 0;
2212 e7000_ops
.to_magic
= OPS_MAGIC
;
2216 _initialize_remote_e7000 (void)
2219 add_target (&e7000_ops
);
2221 add_com ("e7000", class_obscure
, e7000_command
,
2222 "Send a command to the e7000 monitor.");
2224 add_com ("ftplogin", class_obscure
, e7000_login_command
,
2225 "Login to machine and change to directory.");
2227 add_com ("ftpload", class_obscure
, e7000_ftp_command
,
2228 "Fetch and load a file from previously described place.");
2230 add_com ("drain", class_obscure
, e7000_drain_command
,
2231 "Drain pending e7000 text buffers.");
2233 add_show_from_set (add_set_cmd ("usehardbreakpoints", no_class
,
2234 var_integer
, (char *) &use_hard_breakpoints
,
2235 "Set use of hardware breakpoints for all breakpoints.\n", &setlist
),