1 /* Remote debugging interface for Hitachi E7000 ICE, for GDB
2 Copyright 1993, 1994, 1996, 1997, 1998 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 Written by Steve Chamberlain for Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and
24 Hitachi-SH processor. It has serial port and a lan port.
26 The monitor command set makes it difficult to load large ammounts of
27 data over the lan without using ftp - so try not to issue load
28 commands when communicating over ethernet; use the ftpload command.
30 The monitor pauses for a second when dumping srecords to the serial
31 line too, so we use a slower per byte mechanism but without the
32 startup overhead. Even so, it's pretty slow... */
43 #include "gdb_string.h"
45 #include <sys/types.h>
47 #include "remote-utils.h"
54 #define HARD_BREAKPOINTS /* Now handled by set option. */
55 #define BC_BREAKPOINTS use_hard_breakpoints
63 extern void notice_quit
PARAMS ((void));
65 extern void report_transfer_performance
PARAMS ((unsigned long,
68 extern char *sh_processor_type
;
70 /* Local function declarations. */
72 static void e7000_close
PARAMS ((int));
74 static void e7000_fetch_register
PARAMS ((int));
76 static void e7000_store_register
PARAMS ((int));
78 static void e7000_command
PARAMS ((char *, int));
80 static void e7000_login_command
PARAMS ((char *, int));
82 static void e7000_ftp_command
PARAMS ((char *, int));
84 static void e7000_drain_command
PARAMS ((char *, int));
86 static void expect
PARAMS ((char *));
88 static void expect_full_prompt
PARAMS ((void));
90 static void expect_prompt
PARAMS ((void));
92 static int e7000_parse_device
PARAMS ((char *args
, char *dev_name
,
96 static serial_t e7000_desc
;
98 /* Allow user to chose between using hardware breakpoints or memory. */
99 static int use_hard_breakpoints
= 0; /* use sw breakpoints by default */
101 /* Nonzero if using the tcp serial driver. */
103 static int using_tcp
; /* direct tcp connection to target */
104 static int using_tcp_remote
; /* indirect connection to target
105 via tcp to controller */
107 /* Nonzero if using the pc isa card. */
111 extern struct target_ops e7000_ops
; /* Forward declaration */
113 char *ENQSTRING
= "\005";
115 /* Nonzero if some routine (as opposed to the user) wants echoing.
116 FIXME: Do this reentrantly with an extra parameter. */
122 static int timeout
= 20;
124 /* Send data to e7000debug. */
127 puts_e7000debug (buf
)
131 error ("Use \"target e7000 ...\" first.");
134 printf_unfiltered ("Sending %s\n", buf
);
136 if (SERIAL_WRITE (e7000_desc
, buf
, strlen (buf
)))
137 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
139 /* And expect to see it echoed, unless using the pc interface */
153 SERIAL_WRITE (e7000_desc
, b
, 1);
160 SERIAL_WRITE (e7000_desc
, s
, strlen (s
));
172 /* Read a character from the remote system, doing all the fancy timeout
173 stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars,
174 returns -1, else returns next char. Discards chars > 127. */
184 c
= SERIAL_READCHAR (e7000_desc
, timeout
);
188 if (c
== SERIAL_TIMEOUT
)
193 error ("Timeout reading from remote system.");
196 error ("Serial communication error");
200 putchar_unfiltered (c
);
201 gdb_flush (gdb_stdout
);
211 static char b
[8][10];
223 sprintf(b
[p
], "<%d>", x
);
230 /* Scan input from the remote system, until STRING is found. If
231 DISCARD is non-zero, then discard non-matching input, else print it
232 out. Let the user break out immediately. */
244 c
= readchar (timeout
);
251 putchar_e7000(CTRLC
);
263 if (c
== '\r' || c
== '\n')
266 putchar_unfiltered ('\n');
272 putchar_unfiltered (c
);
274 gdb_flush (gdb_stdout
);
276 if (normal (c
) == normal (*p
++))
285 if (normal (c
) == normal (string
[0]))
291 /* Keep discarding input until we see the e7000 prompt.
293 The convention for dealing with the prompt is that you
295 o *then* wait for the prompt.
297 Thus the last thing that a procedure does with the serial line will
298 be an expect_prompt(). Exception: e7000_resume does not wait for
299 the prompt, because the terminal is being handed over to the
300 inferior. However, the next thing which happens after that is a
301 e7000_wait which does wait for the prompt. Note that this includes
302 abnormal exit, e.g. error(). This is necessary to prevent getting
303 into states from which we can't recover. */
312 expect_full_prompt ()
318 convert_hex_digit (ch
)
321 if (ch
>= '0' && ch
<= '9')
323 else if (ch
>= 'A' && ch
<= 'F')
324 return ch
- 'A' + 10;
325 else if (ch
>= 'a' && ch
<= 'f')
326 return ch
- 'a' + 10;
334 int value
= convert_hex_digit (*start
);
337 *start
= readchar (timeout
);
338 while ((try = convert_hex_digit (*start
)) >= 0)
342 *start
= readchar (timeout
);
348 /* Get N 32-bit words from remote, each preceded by a space, and put
349 them in registers starting at REGNO. */
352 get_hex_regs (n
, 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 supply_register (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 (execfile
, args
, env
)
383 error ("Can't pass arguments to remote E7000DEBUG process");
385 if (execfile
== 0 || exec_bfd
== 0)
386 error ("No executable file specified");
388 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
390 #ifdef CREATE_INFERIOR_HOOK
391 CREATE_INFERIOR_HOOK (0); /* No process-ID */
394 /* The "process" (board) is already stopped awaiting our commands, and
395 the program is already downloaded. We just set its PC and go. */
397 clear_proceed_status ();
399 /* Tell wait_for_inferior that we've started a new process. */
400 init_wait_for_inferior ();
402 /* Set up the "saved terminal modes" of the inferior
403 based on what modes we are starting it with. */
404 target_terminal_init ();
406 /* Install inferior's terminal modes. */
407 target_terminal_inferior ();
409 /* insert_step_breakpoint (); FIXME, do we need this? */
410 proceed ((CORE_ADDR
) entry_pt
, -1, 0); /* Let 'er rip... */
413 /* Open a connection to a remote debugger. NAME is the filename used
414 for communication. */
416 static int baudrate
= 9600;
417 static char dev_name
[100];
419 static char *machine
= "";
420 static char *user
= "";
421 static char *passwd
= "";
422 static char *dir
= "";
424 /* Grab the next token and buy some space for it */
435 while (*p
&& *p
== ' ')
438 while (*p
&& (*p
!= ' ' && *p
!= '\t'))
451 e7000_login_command (args
, from_tty
)
457 machine
= next (&args
);
459 passwd
= next (&args
);
463 printf_unfiltered ("Set info to %s %s %s %s\n", machine
, user
, passwd
, dir
);
468 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
472 /* Start an ftp transfer from the E7000 to a host */
475 e7000_ftp_command (args
, from_tty
)
479 /* FIXME: arbitrary limit on machine names and such. */
482 int oldtimeout
= timeout
;
483 timeout
= remote_timeout
;
485 sprintf (buf
, "ftp %s\r", machine
);
486 puts_e7000debug (buf
);
487 expect (" Username : ");
488 sprintf (buf
, "%s\r", user
);
489 puts_e7000debug (buf
);
490 expect (" Password : ");
491 write_e7000 (passwd
);
493 expect ("success\r");
495 sprintf (buf
, "cd %s\r", dir
);
496 puts_e7000debug (buf
);
498 sprintf (buf
, "ll 0;s:%s\r", args
);
499 puts_e7000debug (buf
);
501 puts_e7000debug ("bye\r");
503 timeout
= oldtimeout
;
507 e7000_parse_device (args
, dev_name
, baudrate
)
514 if (args
&& strcasecmp (args
, "pc") == 0)
516 strcpy (dev_name
, args
);
521 /* FIXME! temp hack to allow use with port master -
522 target tcp_remote <device> */
523 if (args
&& strncmp (args
, "tcp", 10) == 0)
526 n
= sscanf (args
, " %s %s %d %s", com_type
, dev_name
, &baudrate
, junk
);
532 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
535 if (n
!= 1 && n
!= 2)
537 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
538 or \t\ttarget e7000 <host>[:<port>]\n\
539 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
540 or \t\ttarget e7000 pc\n");
543 #if !defined(__GO32__) && !defined(_WIN32)
544 /* FIXME! test for ':' is ambiguous */
545 if (n
== 1 && strchr (dev_name
, ':') == 0)
547 /* Default to normal telnet port */
548 /* serial_open will use this to determine tcp communication */
549 strcat (dev_name
, ":23");
552 if (!using_tcp_remote
&& strchr (dev_name
, ':'))
559 /* Stub for catch_errors. */
562 e7000_start_remote (dummy
)
570 immediate_quit
= 1; /* Allow user to interrupt it */
572 /* Hello? Are you there? */
577 putchar_e7000 (CTRLC
);
578 while (!sync
&& ++try <= quit_trying
)
582 printf_unfiltered ("[waiting for e7000...]\n");
587 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
588 * we get stuck in this loop ...
589 * We may never timeout, and never sync up :-(
591 while (!sync
&& c
!= -1)
596 putchar_unfiltered (c
);
597 gdb_flush (gdb_stdout
);
599 /* Shouldn't we either break here, or check for sync in inner loop? */
605 putchar_e7000 (CTRLC
);
613 putchar_e7000 (CTRLC
);
614 /* Was-> quit_flag = 0; */
616 quit_trying
= try+1; /* we don't want to try anymore */
627 fprintf_unfiltered (gdb_stderr
, "Giving up after %d tries...\n",try);
628 error ("Unable to syncronize with target.\n");
631 puts_e7000debug ("\r");
633 puts_e7000debug ("b -\r"); /* Clear breakpoints */
638 /* This is really the job of start_remote however, that makes an assumption
639 that the target is about to print out a status message of some sort. That
640 doesn't happen here. */
642 flush_cached_frames ();
643 registers_changed ();
644 stop_pc
= read_pc ();
645 set_current_frame (create_new_frame (read_fp (), stop_pc
));
646 select_frame (get_current_frame (), 0);
647 print_stack_frame (selected_frame
, -1, 1);
653 e7000_open (args
, 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 (quitting
)
695 SERIAL_CLOSE (e7000_desc
);
700 /* Terminate the open connection to the remote debugger. Use this
701 when you want to detach and do something else with your gdb. */
704 e7000_detach (from_tty
)
707 pop_target (); /* calls e7000_close to do the real work */
709 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
712 /* Tell the remote machine to resume. */
715 e7000_resume (pid
, step
, sig
)
719 puts_e7000debug ("S\r");
721 puts_e7000debug ("G\r");
724 /* Read the remote registers into the block REGS.
726 For the H8/300 a register dump looks like:
728 PC=00021A CCR=80:I*******
729 ER0 - ER3 0000000A 0000002E 0000002E 00000000
730 ER4 - ER7 00000000 00000000 00000000 00FFEFF6
736 #ifdef GDB_TARGET_IS_H8300
738 char *want_h8300h
= "PC=%p CCR=%c\n\
739 ER0 - ER3 %0 %1 %2 %3\n\
740 ER4 - ER7 %4 %5 %6 %7\n";
742 char *want_nopc_h8300h
= "%p CCR=%c\n\
743 ER0 - ER3 %0 %1 %2 %3\n\
744 ER4 - ER7 %4 %5 %6 %7";
746 char *want_h8300s
= "PC=%p CCR=%c\n\
748 ER0 - ER3 %0 %1 %2 %3\n\
749 ER4 - ER7 %4 %5 %6 %7\n";
751 char *want_nopc_h8300s
= "%p CCR=%c EXR=%9\n\
752 ER0 - ER3 %0 %1 %2 %3\n\
753 ER4 - ER7 %4 %5 %6 %7";
757 #ifdef GDB_TARGET_IS_SH
759 char *want
= "PC=%16 SR=%22\n\
760 PR=%17 GBR=%18 VBR=%19\n\
762 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
763 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
765 char *want_nopc
= "%16 SR=%22\n\
766 PR=%17 GBR=%18 VBR=%19\n\
768 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
769 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
771 char *want_sh3
= "PC=%16 SR=%22\n\
772 PR=%17 GBR=%18 VBR=%19\n\
773 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
774 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
775 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
776 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
777 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
778 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
779 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
781 char *want_sh3_nopc
= "%16 SR=%22\n\
782 PR=%17 GBR=%18 VBR=%19\n\
783 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\
784 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
785 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
786 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
787 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
788 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
789 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
796 return readchar (timeout
);
802 int high
= convert_hex_digit (gch ());
803 int low
= convert_hex_digit (gch ());
805 return (high
<< 4) + low
;
809 fetch_regs_from_dump (nextchar
, want
)
814 char buf
[MAX_REGISTER_RAW_SIZE
];
816 int thischar
= nextchar ();
823 /* Skip to end of line and then eat all new line type stuff */
824 while (thischar
!= '\n' && thischar
!= '\r')
825 thischar
= nextchar ();
826 while (thischar
== '\n' || thischar
== '\r')
827 thischar
= nextchar ();
832 while (thischar
== ' '
836 thischar
= nextchar ();
841 if (*want
== thischar
)
845 thischar
= nextchar ();
848 else if (thischar
== ' ' || thischar
== '\n' || thischar
== '\r')
850 thischar
= nextchar ();
853 error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
854 want
, thischar
, thischar
);
859 /* Got a register command */
889 if (isdigit (want
[0]))
891 if (isdigit (want
[1]))
893 regno
= (want
[0] - '0') * 10 + want
[1] - '0';
898 regno
= want
[0] - '0';
906 store_signed_integer (buf
,
907 REGISTER_RAW_SIZE(regno
),
908 (LONGEST
) get_hex (&thischar
, nextchar
));
909 supply_register (regno
, buf
);
916 e7000_fetch_registers ()
921 puts_e7000debug ("R\r");
923 #ifdef GDB_TARGET_IS_SH
925 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
926 switch (TARGET_ARCHITECTURE
->mach
)
935 wanted
= want_h8300s
;
937 wanted
= want_h8300h
;
939 fetch_regs_from_dump (gch
, wanted
);
941 /* And supply the extra ones the simulator uses */
942 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
946 supply_register (regno
, (char *) (&buf
));
950 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
954 e7000_fetch_register (regno
)
957 e7000_fetch_registers ();
960 /* Store the remote registers from the contents of the block REGS. */
963 e7000_store_registers ()
967 for (regno
= 0; regno
< NUM_REALREGS
; regno
++)
968 e7000_store_register (regno
);
970 registers_changed ();
973 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
976 e7000_store_register (regno
)
983 e7000_store_registers ();
987 #ifdef GDB_TARGET_IS_H8300
990 sprintf (buf
, ".ER%d %x\r", regno
, read_register (regno
));
991 puts_e7000debug (buf
);
993 else if (regno
== PC_REGNUM
)
995 sprintf (buf
, ".PC %x\r", read_register (regno
));
996 puts_e7000debug (buf
);
998 else if (regno
== CCR_REGNUM
)
1000 sprintf (buf
, ".CCR %x\r", read_register (regno
));
1001 puts_e7000debug (buf
);
1003 #endif /* GDB_TARGET_IS_H8300 */
1005 #ifdef GDB_TARGET_IS_SH
1009 sprintf (buf
, ".R%d %x\r", regno
, read_register (regno
));
1010 puts_e7000debug (buf
);
1014 sprintf (buf
, ".PC %x\r", read_register (regno
));
1015 puts_e7000debug (buf
);
1019 sprintf (buf
, ".SR %x\r", read_register (regno
));
1020 puts_e7000debug (buf
);
1024 sprintf (buf
, ".PR %x\r", read_register (regno
));
1025 puts_e7000debug (buf
);
1029 sprintf (buf
, ".GBR %x\r", read_register (regno
));
1030 puts_e7000debug (buf
);
1034 sprintf (buf
, ".VBR %x\r", read_register (regno
));
1035 puts_e7000debug (buf
);
1039 sprintf (buf
, ".MACH %x\r", read_register (regno
));
1040 puts_e7000debug (buf
);
1044 sprintf (buf
, ".MACL %x\r", read_register (regno
));
1045 puts_e7000debug (buf
);
1049 #endif /* GDB_TARGET_IS_SH */
1054 /* Get ready to modify the registers array. On machines which store
1055 individual registers, this doesn't need to do anything. On machines
1056 which store all the registers in one fell swoop, this makes sure
1057 that registers contains all the registers from the program being
1061 e7000_prepare_to_store ()
1063 /* Do nothing, since we can store individual regs */
1069 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baudrate
);
1073 stickbyte (where
, what
)
1077 static CONST
char digs
[] = "0123456789ABCDEF";
1079 where
[0] = digs
[(what
>> 4) & 0xf];
1080 where
[1] = digs
[(what
& 0xf) & 0xf];
1085 /* Write a small ammount of memory. */
1088 write_small (memaddr
, myaddr
, len
)
1090 unsigned char *myaddr
;
1096 for (i
= 0; i
< len
; i
++)
1098 if (((memaddr
+ i
) & 3) == 0 && (i
+ 3 < len
))
1100 /* Can be done with a long word */
1101 sprintf (buf
, "m %x %x%02x%02x%02x;l\r",
1103 myaddr
[i
], myaddr
[i
+ 1], myaddr
[i
+ 2], myaddr
[i
+ 3]);
1104 puts_e7000debug (buf
);
1109 sprintf (buf
, "m %x %x\r", memaddr
+ i
, myaddr
[i
]);
1110 puts_e7000debug (buf
);
1119 /* Write a large ammount of memory, this only works with the serial
1120 mode enabled. Command is sent as
1135 write_large (memaddr
, myaddr
, len
)
1137 unsigned char *myaddr
;
1141 #define maxstride 128
1144 puts_e7000debug ("IL ;S:FK\r");
1146 putchar_e7000 (ACK
);
1149 for (i
= 0; i
< len
; i
+= stride
)
1151 char compose
[maxstride
* 2 + 50];
1152 int address
= i
+ memaddr
;
1159 if (stride
> maxstride
)
1162 compose
[where
++] = 'S';
1164 if (address
>= 0xffffff)
1166 else if (address
>= 0xffff)
1171 compose
[where
++] = alen
- 1 + '0';
1172 /* Insert length. */
1173 check_sum
+= stickbyte (compose
+ where
, alen
+ stride
+ 1);
1178 check_sum
+= stickbyte (compose
+ where
, address
>> (8 * (alen
)));
1182 for (j
= 0; j
< stride
; j
++)
1184 check_sum
+= stickbyte (compose
+ where
, myaddr
[i
+ j
]);
1187 stickbyte (compose
+ where
, ~check_sum
);
1189 compose
[where
++] = '\r';
1190 compose
[where
++] = '\n';
1191 compose
[where
++] = 0;
1193 SERIAL_WRITE (e7000_desc
, compose
, where
);
1197 /* This is ok - nothing there */
1201 /* Hmm, it's trying to tell us something */
1203 error ("Error writing memory");
1207 printf_unfiltered ("@%d}@", j
);
1208 while ((j
= readchar (0)) > 0)
1210 printf_unfiltered ("@{%d}@",j
);
1215 /* Send the trailer record */
1216 write_e7000 ("S70500000000FA\r");
1217 putchar_e7000 (CTRLZ
);
1219 putchar_e7000 (ACK
);
1225 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1226 memory at MEMADDR. Returns length moved.
1228 Can't use the Srecord load over ethernet, so don't use fast method
1232 e7000_write_inferior_memory (memaddr
, myaddr
, len
)
1234 unsigned char *myaddr
;
1237 if (len
< 16 || using_tcp
|| using_pc
)
1238 return write_small (memaddr
, myaddr
, len
);
1240 return write_large (memaddr
, myaddr
, len
);
1243 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1244 at debugger address MYADDR. Returns length moved.
1246 Small transactions we send
1253 e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1255 unsigned char *myaddr
;
1262 /* Starting address of this pass. */
1264 /* printf("READ INF %x %x %d\n", memaddr, myaddr, len);*/
1265 if (((memaddr
- 1) + len
) < memaddr
)
1271 sprintf (buf
, "m %x;l\r", memaddr
);
1272 puts_e7000debug (buf
);
1274 for (count
= 0; count
< len
; count
+= 4)
1276 /* Suck away the address */
1282 { /* Some kind of error */
1283 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
1284 expect_full_prompt();
1290 /* Now read in the data */
1291 for (i
= 0; i
< 4; i
++)
1294 if (count
+ i
< len
) {
1295 myaddr
[count
+ i
] = b
;
1299 /* Skip the trailing ? and send a . to end and a cr for more */
1302 if (count
+ 4 >= len
)
1303 puts_e7000debug(".\r");
1305 puts_e7000debug("\r");
1315 For large transfers we used to send
1318 d <addr> <endaddr>\r
1321 <ADDRESS> < D A T A > < ASCII CODE >
1322 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1323 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1324 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1326 A cost in chars for each transaction of 80 + 5*n-bytes.
1328 Large transactions could be done with the srecord load code, but
1329 there is a pause for a second before dumping starts, which slows the
1334 e7000_read_inferior_memory_large (memaddr
, myaddr
, len
)
1336 unsigned char *myaddr
;
1343 /* Starting address of this pass. */
1345 if (((memaddr
- 1) + len
) < memaddr
)
1351 sprintf (buf
, "d %x %x\r", memaddr
, memaddr
+ len
- 1);
1352 puts_e7000debug (buf
);
1357 /* skip down to the first ">" */
1360 /* now skip to the end of that line */
1367 /* get rid of any white space before the address */
1371 /* Skip the address */
1374 /* read in the bytes on the line */
1375 while (c
!= '"' && count
< len
)
1381 myaddr
[count
++] = get_hex (&c
);
1384 /* throw out the rest of the line */
1389 /* wait for the ":" prompt */
1399 fast_but_for_the_pause_e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1408 if (((memaddr
- 1) + len
) < memaddr
)
1414 sprintf (buf
, "is %x@%x:s\r", memaddr
, len
);
1415 puts_e7000debug (buf
);
1421 error ("Memory read error");
1423 putchar_e7000 (ACK
);
1436 case ENQ
: /* ENQ, at the end */
1440 /* Start of an Srecord */
1445 case '7': /* Termination record, ignore */
1449 /* Header record - ignore it */
1461 alen
= type
- '0' + 1;
1465 addr
= (addr
<< 8) + gbyte ();
1469 for (i
= 0; i
< length
- 1; i
++)
1470 myaddr
[i
+ addr
- memaddr
] = gbyte ();
1472 gbyte (); /* Ignore checksum */
1478 putchar_e7000 (ACK
);
1479 expect ("TOP ADDRESS =");
1480 expect ("END ADDRESS =");
1489 e7000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1491 unsigned char *myaddr
;
1494 struct target_ops
*target
; /* ignored */
1497 return e7000_write_inferior_memory( memaddr
, myaddr
, len
);
1500 return e7000_read_inferior_memory( memaddr
, myaddr
, len
);
1502 return e7000_read_inferior_memory_large( memaddr
, myaddr
, len
);
1506 e7000_kill (args
, from_tty
)
1513 e7000_load (args
, from_tty
)
1517 struct cleanup
*old_chain
;
1521 #define WRITESIZE 0x1000
1522 char buf
[2 + 4 + 4 + WRITESIZE
]; /* `DT' + <addr> + <len> + <data> */
1526 time_t start_time
, end_time
; /* Start and end times of download */
1527 unsigned long data_count
; /* Number of bytes transferred to memory */
1528 int oldtimeout
= timeout
;
1530 timeout
= remote_timeout
;
1533 /* FIXME! change test to test for type of download */
1536 generic_load (args
, from_tty
);
1540 /* for direct tcp connections, we can do a fast binary download */
1547 while (*args
!= '\000')
1551 while (isspace (*args
)) args
++;
1555 while ((*args
!= '\000') && !isspace (*args
)) args
++;
1557 if (*args
!= '\000')
1562 else if (strncmp (arg
, "-quiet", strlen (arg
)) == 0)
1564 else if (strncmp (arg
, "-nostart", strlen (arg
)) == 0)
1567 error ("unknown option `%s'", arg
);
1571 filename
= get_exec_file (1);
1573 pbfd
= bfd_openr (filename
, gnutarget
);
1576 perror_with_name (filename
);
1579 old_chain
= make_cleanup ((make_cleanup_func
) bfd_close
, pbfd
);
1581 if (!bfd_check_format (pbfd
, bfd_object
))
1582 error ("\"%s\" is not an object file: %s", filename
,
1583 bfd_errmsg (bfd_get_error ()));
1585 start_time
= time (NULL
);
1588 puts_e7000debug ("mw\r");
1592 for (section
= pbfd
->sections
; section
; section
= section
->next
)
1594 if (bfd_get_section_flags (pbfd
, section
) & SEC_LOAD
)
1596 bfd_vma section_address
;
1597 bfd_size_type section_size
;
1600 section_address
= bfd_get_section_vma (pbfd
, section
);
1601 section_size
= bfd_get_section_size_before_reloc (section
);
1604 printf_filtered ("[Loading section %s at 0x%x (%d bytes)]\n",
1605 bfd_get_section_name (pbfd
, section
),
1611 data_count
+= section_size
;
1613 while (section_size
> 0)
1616 static char inds
[] = "|/-\\";
1621 count
= min (section_size
, WRITESIZE
);
1623 buf
[2] = section_address
>> 24;
1624 buf
[3] = section_address
>> 16;
1625 buf
[4] = section_address
>> 8;
1626 buf
[5] = section_address
;
1628 buf
[6] = count
>> 24;
1629 buf
[7] = count
>> 16;
1630 buf
[8] = count
>> 8;
1633 bfd_get_section_contents (pbfd
, section
, buf
+ 10, fptr
, count
);
1635 if (SERIAL_WRITE (e7000_desc
, buf
, count
+ 10))
1636 fprintf_unfiltered (gdb_stderr
,
1637 "e7000_load: SERIAL_WRITE failed: %s\n",
1638 safe_strerror(errno
));
1644 printf_unfiltered ("\r%c", inds
[k
++ % 4]);
1645 gdb_flush (gdb_stdout
);
1648 section_address
+= count
;
1650 section_size
-= count
;
1659 end_time
= time (NULL
);
1661 /* Finally, make the PC point at the start address */
1664 write_pc (bfd_get_start_address (exec_bfd
));
1666 inferior_pid
= 0; /* No process now */
1668 /* This is necessary because many things were based on the PC at the time that
1669 we attached to the monitor, which is no longer valid now that we have loaded
1670 new code (and just changed the PC). Another way to do this might be to call
1671 normal_stop, except that the stack may not be valid, and things would get
1672 horribly confused... */
1674 clear_symtab_users ();
1678 entry
= bfd_get_start_address (pbfd
);
1681 printf_unfiltered ("[Starting %s at 0x%x]\n", filename
, entry
);
1683 /* start_routine (entry);*/
1686 report_transfer_performance (data_count
, start_time
, end_time
);
1688 do_cleanups (old_chain
);
1689 timeout
= oldtimeout
;
1692 /* Clean up when a program exits.
1694 The program actually lives on in the remote processor's RAM, and may be
1695 run again without a download. Don't leave it full of breakpoint
1699 e7000_mourn_inferior ()
1701 remove_breakpoints ();
1702 unpush_target (&e7000_ops
);
1703 generic_mourn_inferior (); /* Do all the proper things now */
1706 #define MAX_BREAKPOINTS 200
1707 #ifdef HARD_BREAKPOINTS
1708 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
1710 #define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
1713 /* Since we can change to soft breakpoints dynamically, we must define
1714 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
1715 static CORE_ADDR breakaddr
[MAX_BREAKPOINTS
] = {0};
1718 e7000_insert_breakpoint (addr
, shadow
)
1720 unsigned char *shadow
;
1725 static char nop
[2] = NOP
;
1728 for (i
= 0; i
<= MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1729 if (breakaddr
[i
] == 0)
1731 breakaddr
[i
] = addr
;
1732 /* Save old contents, and insert a nop in the space */
1733 #ifdef HARD_BREAKPOINTS
1736 sprintf (buf
, "BC%d A=%x\r", i
+1, addr
);
1737 puts_e7000debug (buf
);
1741 sprintf (buf
, "B %x\r", addr
);
1742 puts_e7000debug (buf
);
1746 e7000_read_inferior_memory (addr
, shadow
, 2);
1747 e7000_write_inferior_memory (addr
, nop
, 2);
1750 sprintf (buf
, "B %x\r", addr
);
1751 puts_e7000debug (buf
);
1757 error ("Too many breakpoints ( > %d) for the E7000\n",
1758 MAX_E7000DEBUG_BREAKPOINTS
);
1763 e7000_remove_breakpoint (addr
, shadow
)
1765 unsigned char *shadow
;
1770 for (i
= 0; i
< MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1771 if (breakaddr
[i
] == addr
)
1774 #ifdef HARD_BREAKPOINTS
1777 sprintf (buf
, "BC%d - \r", i
+1);
1778 puts_e7000debug (buf
);
1782 sprintf (buf
, "B - %x\r", addr
);
1783 puts_e7000debug (buf
);
1787 sprintf (buf
, "B - %x\r", addr
);
1788 puts_e7000debug (buf
);
1792 /* Replace the insn under the break */
1793 e7000_write_inferior_memory (addr
, shadow
, 2);
1800 warning ("Can't find breakpoint associated with 0x%x\n", addr
);
1804 /* Put a command string, in args, out to STDBUG. Output from STDBUG
1805 is placed on the users terminal until the prompt is seen. */
1808 e7000_command (args
, fromtty
)
1812 /* FIXME: arbitrary limit on length of args. */
1818 error ("e7000 target not open.");
1821 puts_e7000debug ("\r");
1825 sprintf (buf
, "%s\r", args
);
1826 puts_e7000debug (buf
);
1831 expect_full_prompt ();
1834 printf_unfiltered ("\n");
1836 /* Who knows what the command did... */
1837 registers_changed ();
1842 e7000_drain_command (args
, fromtty
)
1849 puts_e7000debug("end\r");
1850 putchar_e7000 (CTRLC
);
1852 while ((c
= readchar (1) != -1))
1856 putchar_e7000(CTRLC
);
1859 if (c
> ' ' && c
< 127)
1860 printf_unfiltered ("%c", c
& 0xff);
1862 printf_unfiltered ("<%x>", c
& 0xff);
1871 static char *strings
[NITEMS
] = {
1877 "ILLEGAL INSTRUCTION",
1884 for (i
= 0; i
< NITEMS
; ++i
)
1890 for (i
= 0; i
< NITEMS
; i
++)
1897 /* found one of the choices */
1909 /* Suck characters, if a string match, then return the strings index
1910 otherwise echo them. */
1920 char *buffer
= saveaway
;
1921 /* Count number of expect strings */
1923 for (n
= 0; strings
[n
]; n
++)
1925 ptr
[n
] = strings
[n
];
1936 printf_unfiltered ("[waiting for e7000...]\n");
1949 putchar_e7000 (CTRLC
); /* interrupt the running program */
1953 for (i
= 0; i
< n
; i
++)
1960 /* Gone all the way */
1967 ptr
[i
] = strings
[i
];
1973 /* Save it up incase we find that there was no match */
1978 if (buffer
!= saveaway
)
1981 printf_unfiltered ("%s", buffer
);
1986 putchar_unfiltered (c
);
1987 gdb_flush (gdb_stdout
);
1993 /* We subtract two from the pc here rather than use
1994 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1995 pc, and the simulators never do. */
2003 store_signed_integer (buf
,
2004 REGISTER_RAW_SIZE(PC_REGNUM
),
2005 read_register (PC_REGNUM
) -2);
2006 supply_register (PC_REGNUM
, buf
);
2007 sprintf (buf2
, ".PC %x\r", read_register (PC_REGNUM
));
2008 puts_e7000debug (buf2
);
2013 #define WAS_RUNNING 2
2016 static char *estrings
[] = {
2024 /* Wait until the remote machine stops, then return, storing status in
2025 STATUS just as `wait' would. */
2028 e7000_wait (pid
, status
)
2030 struct target_waitstatus
*status
;
2034 int running_count
= 0;
2039 /* Then echo chars until PC= string seen */
2040 gch (); /* Drop cr */
2041 gch (); /* and space */
2045 switch (expect_n (estrings
))
2048 /* how did this happen ? */
2053 putchar_e7000 (CTRLC
);
2061 if (running_count
== 20)
2063 printf_unfiltered ("[running...]\n");
2073 /* Skip till the PC= */
2076 #ifdef GDB_TARGET_IS_SH
2077 wanted_nopc
= want_nopc
;
2078 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
2079 switch (TARGET_ARCHITECTURE
->mach
)
2084 wanted_nopc
= want_sh3_nopc
;
2088 wanted_nopc
= want_nopc_h8300s
;
2090 wanted_nopc
= want_nopc_h8300h
;
2092 fetch_regs_from_dump (gch
, wanted_nopc
);
2094 /* And supply the extra ones the simulator uses */
2095 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
2098 supply_register (regno
, (char *) &buf
);
2101 stop_reason
= why_stop ();
2102 expect_full_prompt ();
2104 status
->kind
= TARGET_WAITKIND_STOPPED
;
2105 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2107 switch (stop_reason
)
2109 case 1: /* Breakpoint */
2110 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
2111 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2113 case 0: /* Single step */
2114 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2116 case 2: /* Interrupt */
2119 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2124 status
->value
.sig
= TARGET_SIGNAL_INT
;
2130 printf_unfiltered ("a cycle address error?\n");
2131 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2134 status
->value
.sig
= TARGET_SIGNAL_ILL
;
2137 status
->value
.sig
= TARGET_SIGNAL_SEGV
;
2139 case 7: /* Anything else (NITEMS + 1) */
2140 printf_unfiltered ("a write protect error?\n");
2141 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2144 /* Get the user's attention - this should never happen. */
2151 /* Stop the running program. */
2156 /* Sending a ^C is supposed to stop the running program. */
2157 putchar_e7000 (CTRLC
);
2160 /* Define the target subroutine names. */
2162 struct target_ops e7000_ops
;
2165 init_e7000_ops(void)
2167 e7000_ops
.to_shortname
= "e7000";
2168 e7000_ops
.to_longname
= "Remote Hitachi e7000 target";
2169 e7000_ops
.to_doc
= "Use a remote Hitachi e7000 ICE connected by a serial line;\n\
2170 or a network connection.\n\
2171 Arguments are the name of the device for the serial line,\n\
2172 the speed to connect at in bits per second.\n\
2174 target e7000 /dev/ttya 9600\n\
2175 target e7000 foobar" ;
2176 e7000_ops
.to_open
= e7000_open
;
2177 e7000_ops
.to_close
= e7000_close
;
2178 e7000_ops
.to_attach
= 0;
2179 e7000_ops
.to_post_attach
= NULL
;
2180 e7000_ops
.to_require_attach
= NULL
;
2181 e7000_ops
.to_detach
= e7000_detach
;
2182 e7000_ops
.to_require_detach
= NULL
;
2183 e7000_ops
.to_resume
= e7000_resume
;
2184 e7000_ops
.to_wait
= e7000_wait
;
2185 e7000_ops
.to_post_wait
= NULL
;
2186 e7000_ops
.to_fetch_registers
= e7000_fetch_register
;
2187 e7000_ops
.to_store_registers
= e7000_store_register
;
2188 e7000_ops
.to_prepare_to_store
= e7000_prepare_to_store
;
2189 e7000_ops
.to_xfer_memory
= e7000_xfer_inferior_memory
;
2190 e7000_ops
.to_files_info
= e7000_files_info
;
2191 e7000_ops
.to_insert_breakpoint
= e7000_insert_breakpoint
;
2192 e7000_ops
.to_remove_breakpoint
= e7000_remove_breakpoint
;
2193 e7000_ops
.to_terminal_init
= 0;
2194 e7000_ops
.to_terminal_inferior
= 0;
2195 e7000_ops
.to_terminal_ours_for_output
= 0;
2196 e7000_ops
.to_terminal_ours
= 0;
2197 e7000_ops
.to_terminal_info
= 0;
2198 e7000_ops
.to_kill
= e7000_kill
;
2199 e7000_ops
.to_load
= e7000_load
;
2200 e7000_ops
.to_lookup_symbol
= 0;
2201 e7000_ops
.to_create_inferior
= e7000_create_inferior
;
2202 e7000_ops
.to_post_startup_inferior
= NULL
;
2203 e7000_ops
.to_acknowledge_created_inferior
= NULL
;
2204 e7000_ops
.to_clone_and_follow_inferior
= NULL
;
2205 e7000_ops
.to_post_follow_inferior_by_clone
= NULL
;
2206 e7000_ops
.to_insert_fork_catchpoint
= NULL
;
2207 e7000_ops
.to_remove_fork_catchpoint
= NULL
;
2208 e7000_ops
.to_insert_vfork_catchpoint
= NULL
;
2209 e7000_ops
.to_remove_vfork_catchpoint
= NULL
;
2210 e7000_ops
.to_has_forked
= NULL
;
2211 e7000_ops
.to_has_vforked
= NULL
;
2212 e7000_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2213 e7000_ops
.to_post_follow_vfork
= NULL
;
2214 e7000_ops
.to_insert_exec_catchpoint
= NULL
;
2215 e7000_ops
.to_remove_exec_catchpoint
= NULL
;
2216 e7000_ops
.to_has_execd
= NULL
;
2217 e7000_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2218 e7000_ops
.to_has_exited
= NULL
;
2219 e7000_ops
.to_mourn_inferior
= e7000_mourn_inferior
;
2220 e7000_ops
.to_can_run
= 0;
2221 e7000_ops
.to_notice_signals
= 0;
2222 e7000_ops
.to_thread_alive
= 0;
2223 e7000_ops
.to_stop
= e7000_stop
;
2224 e7000_ops
.to_pid_to_exec_file
= NULL
;
2225 e7000_ops
.to_core_file_to_sym_file
= NULL
;
2226 e7000_ops
.to_stratum
= process_stratum
;
2227 e7000_ops
.DONT_USE
= 0;
2228 e7000_ops
.to_has_all_memory
= 1;
2229 e7000_ops
.to_has_memory
= 1;
2230 e7000_ops
.to_has_stack
= 1;
2231 e7000_ops
.to_has_registers
= 1;
2232 e7000_ops
.to_has_execution
= 1;
2233 e7000_ops
.to_sections
= 0;
2234 e7000_ops
.to_sections_end
= 0;
2235 e7000_ops
.to_magic
= OPS_MAGIC
;
2239 _initialize_remote_e7000 ()
2242 add_target (&e7000_ops
);
2244 add_com ("e7000", class_obscure
, e7000_command
,
2245 "Send a command to the e7000 monitor.");
2247 add_com ("ftplogin", class_obscure
, e7000_login_command
,
2248 "Login to machine and change to directory.");
2250 add_com ("ftpload", class_obscure
, e7000_ftp_command
,
2251 "Fetch and load a file from previously described place.");
2253 add_com ("drain", class_obscure
, e7000_drain_command
,
2254 "Drain pending e7000 text buffers.");
2256 add_show_from_set (add_set_cmd ("usehardbreakpoints", no_class
,
2257 var_integer
, (char *)&use_hard_breakpoints
,
2258 "Set use of hardware breakpoints for all breakpoints.\n", &setlist
),