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... */
42 #include "gdb_string.h"
44 #include <sys/types.h>
46 #include "remote-utils.h"
53 #define HARD_BREAKPOINTS /* Now handled by set option. */
54 #define BC_BREAKPOINTS use_hard_breakpoints
62 extern void notice_quit
PARAMS ((void));
64 extern void report_transfer_performance
PARAMS ((unsigned long,
67 extern char *sh_processor_type
;
69 /* Local function declarations. */
71 static void e7000_close
PARAMS ((int));
73 static void e7000_fetch_register
PARAMS ((int));
75 static void e7000_store_register
PARAMS ((int));
77 static void e7000_command
PARAMS ((char *, int));
79 static void e7000_login_command
PARAMS ((char *, int));
81 static void e7000_ftp_command
PARAMS ((char *, int));
83 static void e7000_drain_command
PARAMS ((char *, int));
85 static void expect
PARAMS ((char *));
87 static void expect_full_prompt
PARAMS ((void));
89 static void expect_prompt
PARAMS ((void));
91 static int e7000_parse_device
PARAMS ((char *args
, char *dev_name
,
95 static serial_t e7000_desc
;
97 /* Allow user to chose between using hardware breakpoints or memory. */
98 static int use_hard_breakpoints
= 0; /* use sw breakpoints by default */
100 /* Nonzero if using the tcp serial driver. */
102 static int using_tcp
; /* direct tcp connection to target */
103 static int using_tcp_remote
; /* indirect connection to target
104 via tcp to controller */
106 /* Nonzero if using the pc isa card. */
110 extern struct target_ops e7000_ops
; /* Forward declaration */
112 char *ENQSTRING
= "\005";
114 /* Nonzero if some routine (as opposed to the user) wants echoing.
115 FIXME: Do this reentrantly with an extra parameter. */
121 static int timeout
= 20;
123 /* Send data to e7000debug. */
126 puts_e7000debug (buf
)
130 error ("Use \"target e7000 ...\" first.");
133 printf_unfiltered ("Sending %s\n", buf
);
135 if (SERIAL_WRITE (e7000_desc
, buf
, strlen (buf
)))
136 fprintf_unfiltered (gdb_stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
138 /* And expect to see it echoed, unless using the pc interface */
152 SERIAL_WRITE (e7000_desc
, b
, 1);
159 SERIAL_WRITE (e7000_desc
, s
, strlen (s
));
171 /* Read a character from the remote system, doing all the fancy timeout
172 stuff. Handles serial errors and EOF. If TIMEOUT == 0, and no chars,
173 returns -1, else returns next char. Discards chars > 127. */
183 c
= SERIAL_READCHAR (e7000_desc
, timeout
);
187 if (c
== SERIAL_TIMEOUT
)
192 error ("Timeout reading from remote system.");
195 error ("Serial communication error");
199 putchar_unfiltered (c
);
200 gdb_flush (gdb_stdout
);
210 static char b
[8][10];
222 sprintf(b
[p
], "<%d>", x
);
229 /* Scan input from the remote system, until STRING is found. If
230 DISCARD is non-zero, then discard non-matching input, else print it
231 out. Let the user break out immediately. */
243 c
= readchar (timeout
);
250 putchar_e7000(CTRLC
);
262 if (c
== '\r' || c
== '\n')
265 putchar_unfiltered ('\n');
271 putchar_unfiltered (c
);
273 gdb_flush (gdb_stdout
);
275 if (normal (c
) == normal (*p
++))
284 if (normal (c
) == normal (string
[0]))
290 /* Keep discarding input until we see the e7000 prompt.
292 The convention for dealing with the prompt is that you
294 o *then* wait for the prompt.
296 Thus the last thing that a procedure does with the serial line will
297 be an expect_prompt(). Exception: e7000_resume does not wait for
298 the prompt, because the terminal is being handed over to the
299 inferior. However, the next thing which happens after that is a
300 e7000_wait which does wait for the prompt. Note that this includes
301 abnormal exit, e.g. error(). This is necessary to prevent getting
302 into states from which we can't recover. */
311 expect_full_prompt ()
317 convert_hex_digit (ch
)
320 if (ch
>= '0' && ch
<= '9')
322 else if (ch
>= 'A' && ch
<= 'F')
323 return ch
- 'A' + 10;
324 else if (ch
>= 'a' && ch
<= 'f')
325 return ch
- 'a' + 10;
333 int value
= convert_hex_digit (*start
);
336 *start
= readchar (timeout
);
337 while ((try = convert_hex_digit (*start
)) >= 0)
341 *start
= readchar (timeout
);
347 /* Get N 32-bit words from remote, each preceded by a space, and put
348 them in registers starting at REGNO. */
351 get_hex_regs (n
, regno
)
358 for (i
= 0; i
< n
; i
++)
363 for (j
= 0; j
< 8; j
++)
364 val
= (val
<< 4) + get_hex_digit (j
== 0);
365 supply_register (regno
++, (char *) &val
);
370 /* This is called not only when we first attach, but also when the
371 user types "run" after having attached. */
374 e7000_create_inferior (execfile
, args
, env
)
382 error ("Can't pass arguments to remote E7000DEBUG process");
384 if (execfile
== 0 || exec_bfd
== 0)
385 error ("No executable file specified");
387 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
389 #ifdef CREATE_INFERIOR_HOOK
390 CREATE_INFERIOR_HOOK (0); /* No process-ID */
393 /* The "process" (board) is already stopped awaiting our commands, and
394 the program is already downloaded. We just set its PC and go. */
396 clear_proceed_status ();
398 /* Tell wait_for_inferior that we've started a new process. */
399 init_wait_for_inferior ();
401 /* Set up the "saved terminal modes" of the inferior
402 based on what modes we are starting it with. */
403 target_terminal_init ();
405 /* Install inferior's terminal modes. */
406 target_terminal_inferior ();
408 /* insert_step_breakpoint (); FIXME, do we need this? */
409 proceed ((CORE_ADDR
) entry_pt
, -1, 0); /* Let 'er rip... */
412 /* Open a connection to a remote debugger. NAME is the filename used
413 for communication. */
415 static int baudrate
= 9600;
416 static char dev_name
[100];
418 static char *machine
= "";
419 static char *user
= "";
420 static char *passwd
= "";
421 static char *dir
= "";
423 /* Grab the next token and buy some space for it */
434 while (*p
&& *p
== ' ')
437 while (*p
&& (*p
!= ' ' && *p
!= '\t'))
450 e7000_login_command (args
, from_tty
)
456 machine
= next (&args
);
458 passwd
= next (&args
);
462 printf_unfiltered ("Set info to %s %s %s %s\n", machine
, user
, passwd
, dir
);
467 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
471 /* Start an ftp transfer from the E7000 to a host */
474 e7000_ftp_command (args
, from_tty
)
478 /* FIXME: arbitrary limit on machine names and such. */
481 int oldtimeout
= timeout
;
482 timeout
= remote_timeout
;
484 sprintf (buf
, "ftp %s\r", machine
);
485 puts_e7000debug (buf
);
486 expect (" Username : ");
487 sprintf (buf
, "%s\r", user
);
488 puts_e7000debug (buf
);
489 expect (" Password : ");
490 write_e7000 (passwd
);
492 expect ("success\r");
494 sprintf (buf
, "cd %s\r", dir
);
495 puts_e7000debug (buf
);
497 sprintf (buf
, "ll 0;s:%s\r", args
);
498 puts_e7000debug (buf
);
500 puts_e7000debug ("bye\r");
502 timeout
= oldtimeout
;
506 e7000_parse_device (args
, dev_name
, baudrate
)
513 if (args
&& strcasecmp (args
, "pc") == 0)
515 strcpy (dev_name
, args
);
520 /* FIXME! temp hack to allow use with port master -
521 target tcp_remote <device> */
522 if (args
&& strncmp (args
, "tcp", 10) == 0)
525 n
= sscanf (args
, " %s %s %d %s", com_type
, dev_name
, &baudrate
, junk
);
531 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
534 if (n
!= 1 && n
!= 2)
536 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
537 or \t\ttarget e7000 <host>[:<port>]\n\
538 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
539 or \t\ttarget e7000 pc\n");
542 #if !defined(__GO32__) && !defined(_WIN32)
543 /* FIXME! test for ':' is ambiguous */
544 if (n
== 1 && strchr (dev_name
, ':') == 0)
546 /* Default to normal telnet port */
547 /* serial_open will use this to determine tcp communication */
548 strcat (dev_name
, ":23");
551 if (!using_tcp_remote
&& strchr (dev_name
, ':'))
558 /* Stub for catch_errors. */
561 e7000_start_remote (dummy
)
569 immediate_quit
= 1; /* Allow user to interrupt it */
571 /* Hello? Are you there? */
576 putchar_e7000 (CTRLC
);
577 while (!sync
&& ++try <= quit_trying
)
581 printf_unfiltered ("[waiting for e7000...]\n");
586 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
587 * we get stuck in this loop ...
588 * We may never timeout, and never sync up :-(
590 while (!sync
&& c
!= -1)
595 putchar_unfiltered (c
);
596 gdb_flush (gdb_stdout
);
598 /* Shouldn't we either break here, or check for sync in inner loop? */
604 putchar_e7000 (CTRLC
);
612 putchar_e7000 (CTRLC
);
613 /* Was-> quit_flag = 0; */
615 quit_trying
= try+1; /* we don't want to try anymore */
626 fprintf_unfiltered (gdb_stderr
, "Giving up after %d tries...\n",try);
627 error ("Unable to syncronize with target.\n");
630 puts_e7000debug ("\r");
632 puts_e7000debug ("b -\r"); /* Clear breakpoints */
637 /* This is really the job of start_remote however, that makes an assumption
638 that the target is about to print out a status message of some sort. That
639 doesn't happen here. */
641 flush_cached_frames ();
642 registers_changed ();
643 stop_pc
= read_pc ();
644 set_current_frame (create_new_frame (read_fp (), stop_pc
));
645 select_frame (get_current_frame (), 0);
646 print_stack_frame (selected_frame
, -1, 1);
652 e7000_open (args
, from_tty
)
658 target_preopen (from_tty
);
660 n
= e7000_parse_device (args
, dev_name
, baudrate
);
662 push_target (&e7000_ops
);
664 e7000_desc
= SERIAL_OPEN (dev_name
);
667 perror_with_name (dev_name
);
669 SERIAL_SETBAUDRATE (e7000_desc
, baudrate
);
670 SERIAL_RAW (e7000_desc
);
672 #ifdef GDB_TARGET_IS_H8300
676 /* Start the remote connection; if error (0), discard this target.
677 In particular, if the user quits, be sure to discard it
678 (we'd be in an inconsistent state otherwise). */
679 if (!catch_errors (e7000_start_remote
, (char *)0,
680 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL
))
682 printf_filtered ("Remote target %s connected to %s\n", target_shortname
,
686 /* Close out all files and local state before this target loses control. */
689 e7000_close (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 (from_tty
)
706 pop_target (); /* calls e7000_close to do the real work */
708 printf_unfiltered ("Ending remote %s debugging\n", target_shortname
);
711 /* Tell the remote machine to resume. */
714 e7000_resume (pid
, step
, sig
)
718 puts_e7000debug ("S\r");
720 puts_e7000debug ("G\r");
723 /* Read the remote registers into the block REGS.
725 For the H8/300 a register dump looks like:
727 PC=00021A CCR=80:I*******
728 ER0 - ER3 0000000A 0000002E 0000002E 00000000
729 ER4 - ER7 00000000 00000000 00000000 00FFEFF6
735 #ifdef GDB_TARGET_IS_H8300
737 char *want_h8300h
= "PC=%p CCR=%c\n\
738 ER0 - ER3 %0 %1 %2 %3\n\
739 ER4 - ER7 %4 %5 %6 %7\n";
741 char *want_nopc_h8300h
= "%p CCR=%c\n\
742 ER0 - ER3 %0 %1 %2 %3\n\
743 ER4 - ER7 %4 %5 %6 %7";
745 char *want_h8300s
= "PC=%p CCR=%c\n\
747 ER0 - ER3 %0 %1 %2 %3\n\
748 ER4 - ER7 %4 %5 %6 %7\n";
750 char *want_nopc_h8300s
= "%p CCR=%c EXR=%9\n\
751 ER0 - ER3 %0 %1 %2 %3\n\
752 ER4 - ER7 %4 %5 %6 %7";
756 #ifdef GDB_TARGET_IS_SH
758 char *want
= "PC=%16 SR=%22\n\
759 PR=%17 GBR=%18 VBR=%19\n\
761 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
762 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
764 char *want_nopc
= "%16 SR=%22\n\
765 PR=%17 GBR=%18 VBR=%19\n\
767 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
768 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
770 char *want_sh3
= "PC=%16 SR=%22\n\
771 PR=%17 GBR=%18 VBR=%19\n\
772 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
773 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
774 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
775 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
776 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
777 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
778 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
780 char *want_sh3_nopc
= "%16 SR=%22\n\
781 PR=%17 GBR=%18 VBR=%19\n\
782 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\
783 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
784 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
785 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
786 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
787 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
788 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
795 return readchar (timeout
);
801 int high
= convert_hex_digit (gch ());
802 int low
= convert_hex_digit (gch ());
804 return (high
<< 4) + low
;
808 fetch_regs_from_dump (nextchar
, want
)
813 char buf
[MAX_REGISTER_RAW_SIZE
];
815 int thischar
= nextchar ();
822 /* Skip to end of line and then eat all new line type stuff */
823 while (thischar
!= '\n' && thischar
!= '\r')
824 thischar
= nextchar ();
825 while (thischar
== '\n' || thischar
== '\r')
826 thischar
= nextchar ();
831 while (thischar
== ' '
835 thischar
= nextchar ();
840 if (*want
== thischar
)
844 thischar
= nextchar ();
847 else if (thischar
== ' ' || thischar
== '\n' || thischar
== '\r')
849 thischar
= nextchar ();
852 error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
853 want
, thischar
, thischar
);
858 /* Got a register command */
888 if (isdigit (want
[0]))
890 if (isdigit (want
[1]))
892 regno
= (want
[0] - '0') * 10 + want
[1] - '0';
897 regno
= want
[0] - '0';
905 store_signed_integer (buf
,
906 REGISTER_RAW_SIZE(regno
),
907 (LONGEST
) get_hex (&thischar
, nextchar
));
908 supply_register (regno
, buf
);
915 e7000_fetch_registers ()
920 puts_e7000debug ("R\r");
922 #ifdef GDB_TARGET_IS_SH
924 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
925 switch (TARGET_ARCHITECTURE
->mach
)
934 wanted
= want_h8300s
;
936 wanted
= want_h8300h
;
938 fetch_regs_from_dump (gch
, wanted
);
940 /* And supply the extra ones the simulator uses */
941 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
945 supply_register (regno
, (char *) (&buf
));
949 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
953 e7000_fetch_register (regno
)
956 e7000_fetch_registers ();
959 /* Store the remote registers from the contents of the block REGS. */
962 e7000_store_registers ()
966 for (regno
= 0; regno
< NUM_REALREGS
; regno
++)
967 e7000_store_register (regno
);
969 registers_changed ();
972 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
975 e7000_store_register (regno
)
982 e7000_store_registers ();
986 #ifdef GDB_TARGET_IS_H8300
989 sprintf (buf
, ".ER%d %x\r", regno
, read_register (regno
));
990 puts_e7000debug (buf
);
992 else if (regno
== PC_REGNUM
)
994 sprintf (buf
, ".PC %x\r", read_register (regno
));
995 puts_e7000debug (buf
);
997 else if (regno
== CCR_REGNUM
)
999 sprintf (buf
, ".CCR %x\r", read_register (regno
));
1000 puts_e7000debug (buf
);
1002 #endif /* GDB_TARGET_IS_H8300 */
1004 #ifdef GDB_TARGET_IS_SH
1008 sprintf (buf
, ".R%d %x\r", regno
, read_register (regno
));
1009 puts_e7000debug (buf
);
1013 sprintf (buf
, ".PC %x\r", read_register (regno
));
1014 puts_e7000debug (buf
);
1018 sprintf (buf
, ".SR %x\r", read_register (regno
));
1019 puts_e7000debug (buf
);
1023 sprintf (buf
, ".PR %x\r", read_register (regno
));
1024 puts_e7000debug (buf
);
1028 sprintf (buf
, ".GBR %x\r", read_register (regno
));
1029 puts_e7000debug (buf
);
1033 sprintf (buf
, ".VBR %x\r", read_register (regno
));
1034 puts_e7000debug (buf
);
1038 sprintf (buf
, ".MACH %x\r", read_register (regno
));
1039 puts_e7000debug (buf
);
1043 sprintf (buf
, ".MACL %x\r", read_register (regno
));
1044 puts_e7000debug (buf
);
1048 #endif /* GDB_TARGET_IS_SH */
1053 /* Get ready to modify the registers array. On machines which store
1054 individual registers, this doesn't need to do anything. On machines
1055 which store all the registers in one fell swoop, this makes sure
1056 that registers contains all the registers from the program being
1060 e7000_prepare_to_store ()
1062 /* Do nothing, since we can store individual regs */
1068 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name
, baudrate
);
1072 stickbyte (where
, what
)
1076 static CONST
char digs
[] = "0123456789ABCDEF";
1078 where
[0] = digs
[(what
>> 4) & 0xf];
1079 where
[1] = digs
[(what
& 0xf) & 0xf];
1084 /* Write a small ammount of memory. */
1087 write_small (memaddr
, myaddr
, len
)
1089 unsigned char *myaddr
;
1095 for (i
= 0; i
< len
; i
++)
1097 if (((memaddr
+ i
) & 3) == 0 && (i
+ 3 < len
))
1099 /* Can be done with a long word */
1100 sprintf (buf
, "m %x %x%02x%02x%02x;l\r",
1102 myaddr
[i
], myaddr
[i
+ 1], myaddr
[i
+ 2], myaddr
[i
+ 3]);
1103 puts_e7000debug (buf
);
1108 sprintf (buf
, "m %x %x\r", memaddr
+ i
, myaddr
[i
]);
1109 puts_e7000debug (buf
);
1118 /* Write a large ammount of memory, this only works with the serial
1119 mode enabled. Command is sent as
1134 write_large (memaddr
, myaddr
, len
)
1136 unsigned char *myaddr
;
1140 #define maxstride 128
1143 puts_e7000debug ("IL ;S:FK\r");
1145 putchar_e7000 (ACK
);
1148 for (i
= 0; i
< len
; i
+= stride
)
1150 char compose
[maxstride
* 2 + 50];
1151 int address
= i
+ memaddr
;
1158 if (stride
> maxstride
)
1161 compose
[where
++] = 'S';
1163 if (address
>= 0xffffff)
1165 else if (address
>= 0xffff)
1170 compose
[where
++] = alen
- 1 + '0';
1171 /* Insert length. */
1172 check_sum
+= stickbyte (compose
+ where
, alen
+ stride
+ 1);
1177 check_sum
+= stickbyte (compose
+ where
, address
>> (8 * (alen
)));
1181 for (j
= 0; j
< stride
; j
++)
1183 check_sum
+= stickbyte (compose
+ where
, myaddr
[i
+ j
]);
1186 stickbyte (compose
+ where
, ~check_sum
);
1188 compose
[where
++] = '\r';
1189 compose
[where
++] = '\n';
1190 compose
[where
++] = 0;
1192 SERIAL_WRITE (e7000_desc
, compose
, where
);
1196 /* This is ok - nothing there */
1200 /* Hmm, it's trying to tell us something */
1202 error ("Error writing memory");
1206 printf_unfiltered ("@%d}@", j
);
1207 while ((j
= readchar (0)) > 0)
1209 printf_unfiltered ("@{%d}@",j
);
1214 /* Send the trailer record */
1215 write_e7000 ("S70500000000FA\r");
1216 putchar_e7000 (CTRLZ
);
1218 putchar_e7000 (ACK
);
1224 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1225 memory at MEMADDR. Returns length moved.
1227 Can't use the Srecord load over ethernet, so don't use fast method
1231 e7000_write_inferior_memory (memaddr
, myaddr
, len
)
1233 unsigned char *myaddr
;
1236 if (len
< 16 || using_tcp
|| using_pc
)
1237 return write_small (memaddr
, myaddr
, len
);
1239 return write_large (memaddr
, myaddr
, len
);
1242 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1243 at debugger address MYADDR. Returns length moved.
1245 Small transactions we send
1252 e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1254 unsigned char *myaddr
;
1261 /* Starting address of this pass. */
1263 /* printf("READ INF %x %x %d\n", memaddr, myaddr, len);*/
1264 if (((memaddr
- 1) + len
) < memaddr
)
1270 sprintf (buf
, "m %x;l\r", memaddr
);
1271 puts_e7000debug (buf
);
1273 for (count
= 0; count
< len
; count
+= 4)
1275 /* Suck away the address */
1281 { /* Some kind of error */
1282 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
1283 expect_full_prompt();
1289 /* Now read in the data */
1290 for (i
= 0; i
< 4; i
++)
1293 if (count
+ i
< len
) {
1294 myaddr
[count
+ i
] = b
;
1298 /* Skip the trailing ? and send a . to end and a cr for more */
1301 if (count
+ 4 >= len
)
1302 puts_e7000debug(".\r");
1304 puts_e7000debug("\r");
1314 For large transfers we used to send
1317 d <addr> <endaddr>\r
1320 <ADDRESS> < D A T A > < ASCII CODE >
1321 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1322 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1323 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1325 A cost in chars for each transaction of 80 + 5*n-bytes.
1327 Large transactions could be done with the srecord load code, but
1328 there is a pause for a second before dumping starts, which slows the
1333 e7000_read_inferior_memory_large (memaddr
, myaddr
, len
)
1335 unsigned char *myaddr
;
1342 /* Starting address of this pass. */
1344 if (((memaddr
- 1) + len
) < memaddr
)
1350 sprintf (buf
, "d %x %x\r", memaddr
, memaddr
+ len
- 1);
1351 puts_e7000debug (buf
);
1356 /* skip down to the first ">" */
1359 /* now skip to the end of that line */
1366 /* get rid of any white space before the address */
1370 /* Skip the address */
1373 /* read in the bytes on the line */
1374 while (c
!= '"' && count
< len
)
1380 myaddr
[count
++] = get_hex (&c
);
1383 /* throw out the rest of the line */
1388 /* wait for the ":" prompt */
1398 fast_but_for_the_pause_e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1407 if (((memaddr
- 1) + len
) < memaddr
)
1413 sprintf (buf
, "is %x@%x:s\r", memaddr
, len
);
1414 puts_e7000debug (buf
);
1420 error ("Memory read error");
1422 putchar_e7000 (ACK
);
1435 case ENQ
: /* ENQ, at the end */
1439 /* Start of an Srecord */
1444 case '7': /* Termination record, ignore */
1448 /* Header record - ignore it */
1460 alen
= type
- '0' + 1;
1464 addr
= (addr
<< 8) + gbyte ();
1468 for (i
= 0; i
< length
- 1; i
++)
1469 myaddr
[i
+ addr
- memaddr
] = gbyte ();
1471 gbyte (); /* Ignore checksum */
1477 putchar_e7000 (ACK
);
1478 expect ("TOP ADDRESS =");
1479 expect ("END ADDRESS =");
1488 e7000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1490 unsigned char *myaddr
;
1493 struct target_ops
*target
; /* ignored */
1496 return e7000_write_inferior_memory( memaddr
, myaddr
, len
);
1499 return e7000_read_inferior_memory( memaddr
, myaddr
, len
);
1501 return e7000_read_inferior_memory_large( memaddr
, myaddr
, len
);
1505 e7000_kill (args
, from_tty
)
1512 e7000_load (args
, from_tty
)
1516 struct cleanup
*old_chain
;
1520 #define WRITESIZE 0x1000
1521 char buf
[2 + 4 + 4 + WRITESIZE
]; /* `DT' + <addr> + <len> + <data> */
1525 time_t start_time
, end_time
; /* Start and end times of download */
1526 unsigned long data_count
; /* Number of bytes transferred to memory */
1527 int oldtimeout
= timeout
;
1529 timeout
= remote_timeout
;
1532 /* FIXME! change test to test for type of download */
1535 generic_load (args
, from_tty
);
1539 /* for direct tcp connections, we can do a fast binary download */
1546 while (*args
!= '\000')
1550 while (isspace (*args
)) args
++;
1554 while ((*args
!= '\000') && !isspace (*args
)) args
++;
1556 if (*args
!= '\000')
1561 else if (strncmp (arg
, "-quiet", strlen (arg
)) == 0)
1563 else if (strncmp (arg
, "-nostart", strlen (arg
)) == 0)
1566 error ("unknown option `%s'", arg
);
1570 filename
= get_exec_file (1);
1572 pbfd
= bfd_openr (filename
, gnutarget
);
1575 perror_with_name (filename
);
1578 old_chain
= make_cleanup ((make_cleanup_func
) bfd_close
, pbfd
);
1580 if (!bfd_check_format (pbfd
, bfd_object
))
1581 error ("\"%s\" is not an object file: %s", filename
,
1582 bfd_errmsg (bfd_get_error ()));
1584 start_time
= time (NULL
);
1587 puts_e7000debug ("mw\r");
1591 for (section
= pbfd
->sections
; section
; section
= section
->next
)
1593 if (bfd_get_section_flags (pbfd
, section
) & SEC_LOAD
)
1595 bfd_vma section_address
;
1596 bfd_size_type section_size
;
1599 section_address
= bfd_get_section_vma (pbfd
, section
);
1600 section_size
= bfd_get_section_size_before_reloc (section
);
1603 printf_filtered ("[Loading section %s at 0x%x (%d bytes)]\n",
1604 bfd_get_section_name (pbfd
, section
),
1610 data_count
+= section_size
;
1612 while (section_size
> 0)
1615 static char inds
[] = "|/-\\";
1620 count
= min (section_size
, WRITESIZE
);
1622 buf
[2] = section_address
>> 24;
1623 buf
[3] = section_address
>> 16;
1624 buf
[4] = section_address
>> 8;
1625 buf
[5] = section_address
;
1627 buf
[6] = count
>> 24;
1628 buf
[7] = count
>> 16;
1629 buf
[8] = count
>> 8;
1632 bfd_get_section_contents (pbfd
, section
, buf
+ 10, fptr
, count
);
1634 if (SERIAL_WRITE (e7000_desc
, buf
, count
+ 10))
1635 fprintf_unfiltered (gdb_stderr
,
1636 "e7000_load: SERIAL_WRITE failed: %s\n",
1637 safe_strerror(errno
));
1643 printf_unfiltered ("\r%c", inds
[k
++ % 4]);
1644 gdb_flush (gdb_stdout
);
1647 section_address
+= count
;
1649 section_size
-= count
;
1658 end_time
= time (NULL
);
1660 /* Finally, make the PC point at the start address */
1663 write_pc (bfd_get_start_address (exec_bfd
));
1665 inferior_pid
= 0; /* No process now */
1667 /* This is necessary because many things were based on the PC at the time that
1668 we attached to the monitor, which is no longer valid now that we have loaded
1669 new code (and just changed the PC). Another way to do this might be to call
1670 normal_stop, except that the stack may not be valid, and things would get
1671 horribly confused... */
1673 clear_symtab_users ();
1677 entry
= bfd_get_start_address (pbfd
);
1680 printf_unfiltered ("[Starting %s at 0x%x]\n", filename
, entry
);
1682 /* start_routine (entry);*/
1685 report_transfer_performance (data_count
, start_time
, end_time
);
1687 do_cleanups (old_chain
);
1688 timeout
= oldtimeout
;
1691 /* Clean up when a program exits.
1693 The program actually lives on in the remote processor's RAM, and may be
1694 run again without a download. Don't leave it full of breakpoint
1698 e7000_mourn_inferior ()
1700 remove_breakpoints ();
1701 unpush_target (&e7000_ops
);
1702 generic_mourn_inferior (); /* Do all the proper things now */
1705 #define MAX_BREAKPOINTS 200
1706 #ifdef HARD_BREAKPOINTS
1707 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
1709 #define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
1712 /* Since we can change to soft breakpoints dynamically, we must define
1713 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
1714 static CORE_ADDR breakaddr
[MAX_BREAKPOINTS
] = {0};
1717 e7000_insert_breakpoint (addr
, shadow
)
1719 unsigned char *shadow
;
1724 static char nop
[2] = NOP
;
1727 for (i
= 0; i
<= MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1728 if (breakaddr
[i
] == 0)
1730 breakaddr
[i
] = addr
;
1731 /* Save old contents, and insert a nop in the space */
1732 #ifdef HARD_BREAKPOINTS
1735 sprintf (buf
, "BC%d A=%x\r", i
+1, addr
);
1736 puts_e7000debug (buf
);
1740 sprintf (buf
, "B %x\r", addr
);
1741 puts_e7000debug (buf
);
1745 e7000_read_inferior_memory (addr
, shadow
, 2);
1746 e7000_write_inferior_memory (addr
, nop
, 2);
1749 sprintf (buf
, "B %x\r", addr
);
1750 puts_e7000debug (buf
);
1756 error ("Too many breakpoints ( > %d) for the E7000\n",
1757 MAX_E7000DEBUG_BREAKPOINTS
);
1762 e7000_remove_breakpoint (addr
, shadow
)
1764 unsigned char *shadow
;
1769 for (i
= 0; i
< MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1770 if (breakaddr
[i
] == addr
)
1773 #ifdef HARD_BREAKPOINTS
1776 sprintf (buf
, "BC%d - \r", i
+1);
1777 puts_e7000debug (buf
);
1781 sprintf (buf
, "B - %x\r", addr
);
1782 puts_e7000debug (buf
);
1786 sprintf (buf
, "B - %x\r", addr
);
1787 puts_e7000debug (buf
);
1791 /* Replace the insn under the break */
1792 e7000_write_inferior_memory (addr
, shadow
, 2);
1799 warning ("Can't find breakpoint associated with 0x%x\n", addr
);
1803 /* Put a command string, in args, out to STDBUG. Output from STDBUG
1804 is placed on the users terminal until the prompt is seen. */
1807 e7000_command (args
, fromtty
)
1811 /* FIXME: arbitrary limit on length of args. */
1817 error ("e7000 target not open.");
1820 puts_e7000debug ("\r");
1824 sprintf (buf
, "%s\r", args
);
1825 puts_e7000debug (buf
);
1830 expect_full_prompt ();
1833 printf_unfiltered ("\n");
1835 /* Who knows what the command did... */
1836 registers_changed ();
1841 e7000_drain_command (args
, fromtty
)
1848 puts_e7000debug("end\r");
1849 putchar_e7000 (CTRLC
);
1851 while ((c
= readchar (1) != -1))
1855 putchar_e7000(CTRLC
);
1858 if (c
> ' ' && c
< 127)
1859 printf_unfiltered ("%c", c
& 0xff);
1861 printf_unfiltered ("<%x>", c
& 0xff);
1870 static char *strings
[NITEMS
] = {
1876 "ILLEGAL INSTRUCTION",
1883 for (i
= 0; i
< NITEMS
; ++i
)
1889 for (i
= 0; i
< NITEMS
; i
++)
1896 /* found one of the choices */
1908 /* Suck characters, if a string match, then return the strings index
1909 otherwise echo them. */
1919 char *buffer
= saveaway
;
1920 /* Count number of expect strings */
1922 for (n
= 0; strings
[n
]; n
++)
1924 ptr
[n
] = strings
[n
];
1935 printf_unfiltered ("[waiting for e7000...]\n");
1948 putchar_e7000 (CTRLC
); /* interrupt the running program */
1952 for (i
= 0; i
< n
; i
++)
1959 /* Gone all the way */
1966 ptr
[i
] = strings
[i
];
1972 /* Save it up incase we find that there was no match */
1977 if (buffer
!= saveaway
)
1980 printf_unfiltered ("%s", buffer
);
1985 putchar_unfiltered (c
);
1986 gdb_flush (gdb_stdout
);
1992 /* We subtract two from the pc here rather than use
1993 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1994 pc, and the simulators never do. */
2002 store_signed_integer (buf
,
2003 REGISTER_RAW_SIZE(PC_REGNUM
),
2004 read_register (PC_REGNUM
) -2);
2005 supply_register (PC_REGNUM
, buf
);
2006 sprintf (buf2
, ".PC %x\r", read_register (PC_REGNUM
));
2007 puts_e7000debug (buf2
);
2012 #define WAS_RUNNING 2
2015 static char *estrings
[] = {
2023 /* Wait until the remote machine stops, then return, storing status in
2024 STATUS just as `wait' would. */
2027 e7000_wait (pid
, status
)
2029 struct target_waitstatus
*status
;
2033 int running_count
= 0;
2038 /* Then echo chars until PC= string seen */
2039 gch (); /* Drop cr */
2040 gch (); /* and space */
2044 switch (expect_n (estrings
))
2047 /* how did this happen ? */
2052 putchar_e7000 (CTRLC
);
2060 if (running_count
== 20)
2062 printf_unfiltered ("[running...]\n");
2072 /* Skip till the PC= */
2075 #ifdef GDB_TARGET_IS_SH
2076 wanted_nopc
= want_nopc
;
2077 if (TARGET_ARCHITECTURE
->arch
== bfd_arch_sh
)
2078 switch (TARGET_ARCHITECTURE
->mach
)
2083 wanted_nopc
= want_sh3_nopc
;
2087 wanted_nopc
= want_nopc_h8300s
;
2089 wanted_nopc
= want_nopc_h8300h
;
2091 fetch_regs_from_dump (gch
, wanted_nopc
);
2093 /* And supply the extra ones the simulator uses */
2094 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
2097 supply_register (regno
, (char *) &buf
);
2100 stop_reason
= why_stop ();
2101 expect_full_prompt ();
2103 status
->kind
= TARGET_WAITKIND_STOPPED
;
2104 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2106 switch (stop_reason
)
2108 case 1: /* Breakpoint */
2109 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
2110 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2112 case 0: /* Single step */
2113 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2115 case 2: /* Interrupt */
2118 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
2123 status
->value
.sig
= TARGET_SIGNAL_INT
;
2129 printf_unfiltered ("a cycle address error?\n");
2130 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2133 status
->value
.sig
= TARGET_SIGNAL_ILL
;
2136 status
->value
.sig
= TARGET_SIGNAL_SEGV
;
2138 case 7: /* Anything else (NITEMS + 1) */
2139 printf_unfiltered ("a write protect error?\n");
2140 status
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
2143 /* Get the user's attention - this should never happen. */
2150 /* Stop the running program. */
2155 /* Sending a ^C is supposed to stop the running program. */
2156 putchar_e7000 (CTRLC
);
2159 /* Define the target subroutine names. */
2161 struct target_ops e7000_ops
;
2162 static void init_e7000_ops(void)
2164 e7000_ops
.to_shortname
= "e7000";
2165 e7000_ops
.to_longname
= "Remote Hitachi e7000 target";
2166 e7000_ops
.to_doc
= "Use a remote Hitachi e7000 ICE connected by a serial line;\n\
2167 or a network connection.\n\
2168 Arguments are the name of the device for the serial line,\n\
2169 the speed to connect at in bits per second.\n\
2171 target e7000 /dev/ttya 9600\n\
2172 target e7000 foobar" ;
2173 e7000_ops
.to_open
= e7000_open
;
2174 e7000_ops
.to_close
= e7000_close
;
2175 e7000_ops
.to_attach
= 0;
2176 e7000_ops
.to_detach
= e7000_detach
;
2177 e7000_ops
.to_resume
= e7000_resume
;
2178 e7000_ops
.to_wait
= e7000_wait
;
2179 e7000_ops
.to_fetch_registers
= e7000_fetch_register
;
2180 e7000_ops
.to_store_registers
= e7000_store_register
;
2181 e7000_ops
.to_prepare_to_store
= e7000_prepare_to_store
;
2182 e7000_ops
.to_xfer_memory
= e7000_xfer_inferior_memory
;
2183 e7000_ops
.to_files_info
= e7000_files_info
;
2184 e7000_ops
.to_insert_breakpoint
= e7000_insert_breakpoint
;
2185 e7000_ops
.to_remove_breakpoint
= e7000_remove_breakpoint
;
2186 e7000_ops
.to_terminal_init
= 0;
2187 e7000_ops
.to_terminal_inferior
= 0;
2188 e7000_ops
.to_terminal_ours_for_output
= 0;
2189 e7000_ops
.to_terminal_ours
= 0;
2190 e7000_ops
.to_terminal_info
= 0;
2191 e7000_ops
.to_kill
= e7000_kill
;
2192 e7000_ops
.to_load
= e7000_load
;
2193 e7000_ops
.to_lookup_symbol
= 0;
2194 e7000_ops
.to_create_inferior
= e7000_create_inferior
;
2195 e7000_ops
.to_mourn_inferior
= e7000_mourn_inferior
;
2196 e7000_ops
.to_can_run
= 0;
2197 e7000_ops
.to_notice_signals
= 0;
2198 e7000_ops
.to_thread_alive
= 0;
2199 e7000_ops
.to_stop
= e7000_stop
;
2200 e7000_ops
.to_stratum
= process_stratum
;
2201 e7000_ops
.DONT_USE
= 0;
2202 e7000_ops
.to_has_all_memory
= 1;
2203 e7000_ops
.to_has_memory
= 1;
2204 e7000_ops
.to_has_stack
= 1;
2205 e7000_ops
.to_has_registers
= 1;
2206 e7000_ops
.to_has_execution
= 1;
2207 e7000_ops
.to_sections
= 0;
2208 e7000_ops
.to_sections_end
= 0;
2209 e7000_ops
.to_magic
= OPS_MAGIC
;
2213 _initialize_remote_e7000 ()
2216 add_target (&e7000_ops
);
2218 add_com ("e7000", class_obscure
, e7000_command
,
2219 "Send a command to the e7000 monitor.");
2221 add_com ("ftplogin", class_obscure
, e7000_login_command
,
2222 "Login to machine and change to directory.");
2224 add_com ("ftpload", class_obscure
, e7000_ftp_command
,
2225 "Fetch and load a file from previously described place.");
2227 add_com ("drain", class_obscure
, e7000_drain_command
,
2228 "Drain pending e7000 text buffers.");
2230 add_show_from_set (add_set_cmd ("usehardbreakpoints", no_class
,
2231 var_integer
, (char *)&use_hard_breakpoints
,
2232 "Set use of hardware breakpoints for all breakpoints.\n", &setlist
),