1 /* Remote debugging interface for Renesas E7000 ICE, for GDB
2
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
4 2002, 2003, 2004 Free Software Foundation, Inc.
5
6 Contributed by Cygnus Support.
7
8 Written by Steve Chamberlain for Cygnus Support.
9
10 This file is part of GDB.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place - Suite 330,
25 Boston, MA 02111-1307, USA. */
26
27 /* The E7000 is an in-circuit emulator for the Renesas H8/300-H and
28 Renesas-SH processor. It has serial port and a lan port.
29
30 The monitor command set makes it difficult to load large ammounts of
31 data over the lan without using ftp - so try not to issue load
32 commands when communicating over ethernet; use the ftpload command.
33
34 The monitor pauses for a second when dumping srecords to the serial
35 line too, so we use a slower per byte mechanism but without the
36 startup overhead. Even so, it's pretty slow... */
37
38 #include "defs.h"
39 #include "gdbcore.h"
40 #include "gdbarch.h"
41 #include "inferior.h"
42 #include "target.h"
43 #include "value.h"
44 #include "command.h"
45 #include "gdb_string.h"
46 #include "gdbcmd.h"
47 #include <sys/types.h>
48 #include "serial.h"
49 #include "remote-utils.h"
50 #include "symfile.h"
51 #include "regcache.h"
52 #include <time.h>
53 #include <ctype.h>
54
55
56 #if 1
57 #define HARD_BREAKPOINTS /* Now handled by set option. */
58 #define BC_BREAKPOINTS use_hard_breakpoints
59 #endif
60
61 #define CTRLC 0x03
62 #define ENQ 0x05
63 #define ACK 0x06
64 #define CTRLZ 0x1a
65
66 /* This file is used by 2 different targets, sh-elf and h8300. The
67 h8300 is not multiarched and doesn't use the registers defined in
68 tm-sh.h. To avoid using a macro GDB_TARGET_IS_SH, we do runtime check
69 of the target, which requires that these namse below are always
70 defined also in the h8300 case. */
71
72 #if !defined (PR_REGNUM)
73 #define PR_REGNUM -1
74 #endif
75 #if !defined (GBR_REGNUM)
76 #define GBR_REGNUM -1
77 #endif
78 #if !defined (VBR_REGNUM)
79 #define VBR_REGNUM -1
80 #endif
81 #if !defined (MACH_REGNUM)
82 #define MACH_REGNUM -1
83 #endif
84 #if !defined (MACL_REGNUM)
85 #define MACL_REGNUM -1
86 #endif
87 #if !defined (SR_REGNUM)
88 #define SR_REGNUM -1
89 #endif
90
91 extern void report_transfer_performance (unsigned long, time_t, time_t);
92
93 extern char *sh_processor_type;
94
95 /* Local function declarations. */
96
97 static void e7000_close (int);
98
99 static void e7000_fetch_register (int);
100
101 static void e7000_store_register (int);
102
103 static void e7000_command (char *, int);
104
105 static void e7000_login_command (char *, int);
106
107 static void e7000_ftp_command (char *, int);
108
109 static void e7000_drain_command (char *, int);
110
111 static void expect (char *);
112
113 static void expect_full_prompt (void);
114
115 static void expect_prompt (void);
116
117 static int e7000_parse_device (char *args, char *dev_name, int baudrate);
118 /* Variables. */
119
120 static struct serial *e7000_desc;
121
122 /* Allow user to chose between using hardware breakpoints or memory. */
123 static int use_hard_breakpoints = 0; /* use sw breakpoints by default */
124
125 /* Nonzero if using the tcp serial driver. */
126
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 */
130
131 /* Nonzero if using the pc isa card. */
132
133 static int using_pc;
134
135 extern struct target_ops e7000_ops; /* Forward declaration */
136
137 char *ENQSTRING = "\005";
138
139 /* Nonzero if some routine (as opposed to the user) wants echoing.
140 FIXME: Do this reentrantly with an extra parameter. */
141
142 static int echo;
143
144 static int ctrl_c;
145
146 static int timeout = 20;
147
148 /* Send data to e7000debug. */
149
150 static void
puts_e7000debug(char * buf)151 puts_e7000debug (char *buf)
152 {
153 if (!e7000_desc)
154 error ("Use \"target e7000 ...\" first.");
155
156 if (remote_debug)
157 printf_unfiltered ("Sending %s\n", buf);
158
159 if (serial_write (e7000_desc, buf, strlen (buf)))
160 fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", safe_strerror (errno));
161
162 /* And expect to see it echoed, unless using the pc interface */
163 #if 0
164 if (!using_pc)
165 #endif
166 expect (buf);
167 }
168
169 static void
putchar_e7000(int x)170 putchar_e7000 (int x)
171 {
172 char b[1];
173
174 b[0] = x;
175 serial_write (e7000_desc, b, 1);
176 }
177
178 static void
write_e7000(char * s)179 write_e7000 (char *s)
180 {
181 serial_write (e7000_desc, s, strlen (s));
182 }
183
184 static int
normal(int x)185 normal (int x)
186 {
187 if (x == '\n')
188 return '\r';
189 return x;
190 }
191
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. */
195
196 static int
readchar(int timeout)197 readchar (int timeout)
198 {
199 int c;
200
201 do
202 {
203 c = serial_readchar (e7000_desc, timeout);
204 }
205 while (c > 127);
206
207 if (c == SERIAL_TIMEOUT)
208 {
209 if (timeout == 0)
210 return -1;
211 echo = 0;
212 error ("Timeout reading from remote system.");
213 }
214 else if (c < 0)
215 error ("Serial communication error");
216
217 if (remote_debug)
218 {
219 putchar_unfiltered (c);
220 gdb_flush (gdb_stdout);
221 }
222
223 return normal (c);
224 }
225
226 #if 0
227 char *
228 tl (int x)
229 {
230 static char b[8][10];
231 static int p;
232
233 p++;
234 p &= 7;
235 if (x >= ' ')
236 {
237 b[p][0] = x;
238 b[p][1] = 0;
239 }
240 else
241 {
242 sprintf (b[p], "<%d>", x);
243 }
244
245 return b[p];
246 }
247 #endif
248
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. */
252
253 static void
expect(char * string)254 expect (char *string)
255 {
256 char *p = string;
257 int c;
258 int nl = 0;
259
260 while (1)
261 {
262 c = readchar (timeout);
263
264 if (echo)
265 {
266 if (c == '\r' || c == '\n')
267 {
268 if (!nl)
269 putchar_unfiltered ('\n');
270 nl = 1;
271 }
272 else
273 {
274 nl = 0;
275 putchar_unfiltered (c);
276 }
277 gdb_flush (gdb_stdout);
278 }
279 if (normal (c) == normal (*p++))
280 {
281 if (*p == '\0')
282 return;
283 }
284 else
285 {
286 p = string;
287
288 if (normal (c) == normal (string[0]))
289 p++;
290 }
291 }
292 }
293
294 /* Keep discarding input until we see the e7000 prompt.
295
296 The convention for dealing with the prompt is that you
297 o give your command
298 o *then* wait for the prompt.
299
300 Thus the last thing that a procedure does with the serial line will
301 be an expect_prompt(). Exception: e7000_resume does not wait for
302 the prompt, because the terminal is being handed over to the
303 inferior. However, the next thing which happens after that is a
304 e7000_wait which does wait for the prompt. Note that this includes
305 abnormal exit, e.g. error(). This is necessary to prevent getting
306 into states from which we can't recover. */
307
308 static void
expect_prompt(void)309 expect_prompt (void)
310 {
311 expect (":");
312 }
313
314 static void
expect_full_prompt(void)315 expect_full_prompt (void)
316 {
317 expect ("\r:");
318 }
319
320 static int
convert_hex_digit(int ch)321 convert_hex_digit (int ch)
322 {
323 if (ch >= '0' && ch <= '9')
324 return ch - '0';
325 else if (ch >= 'A' && ch <= 'F')
326 return ch - 'A' + 10;
327 else if (ch >= 'a' && ch <= 'f')
328 return ch - 'a' + 10;
329 return -1;
330 }
331
332 static int
get_hex(int * start)333 get_hex (int *start)
334 {
335 int value = convert_hex_digit (*start);
336 int try;
337
338 *start = readchar (timeout);
339 while ((try = convert_hex_digit (*start)) >= 0)
340 {
341 value <<= 4;
342 value += try;
343 *start = readchar (timeout);
344 }
345 return value;
346 }
347
348 #if 0
349 /* Get N 32-bit words from remote, each preceded by a space, and put
350 them in registers starting at REGNO. */
351
352 static void
353 get_hex_regs (int n, int regno)
354 {
355 long val;
356 int i;
357
358 for (i = 0; i < n; i++)
359 {
360 int j;
361
362 val = 0;
363 for (j = 0; j < 8; j++)
364 val = (val << 4) + get_hex_digit (j == 0);
365 regcache_raw_supply (current_regcache, regno++, (char *) &val);
366 }
367 }
368 #endif
369
370 /* This is called not only when we first attach, but also when the
371 user types "run" after having attached. */
372
373 static void
e7000_create_inferior(char * execfile,char * args,char ** env,int from_tty)374 e7000_create_inferior (char *execfile, char *args, char **env,
375 int from_tty)
376 {
377 int entry_pt;
378
379 if (args && *args)
380 error ("Can't pass arguments to remote E7000DEBUG process");
381
382 if (execfile == 0 || exec_bfd == 0)
383 error ("No executable file specified");
384
385 entry_pt = (int) bfd_get_start_address (exec_bfd);
386
387 #ifdef CREATE_INFERIOR_HOOK
388 CREATE_INFERIOR_HOOK (0); /* No process-ID */
389 #endif
390
391 /* The "process" (board) is already stopped awaiting our commands, and
392 the program is already downloaded. We just set its PC and go. */
393
394 clear_proceed_status ();
395
396 /* Tell wait_for_inferior that we've started a new process. */
397 init_wait_for_inferior ();
398
399 /* Set up the "saved terminal modes" of the inferior
400 based on what modes we are starting it with. */
401 target_terminal_init ();
402
403 /* Install inferior's terminal modes. */
404 target_terminal_inferior ();
405
406 /* insert_step_breakpoint (); FIXME, do we need this? */
407 proceed ((CORE_ADDR) entry_pt, -1, 0); /* Let 'er rip... */
408 }
409
410 /* Open a connection to a remote debugger. NAME is the filename used
411 for communication. */
412
413 static int baudrate = 9600;
414 static char dev_name[100];
415
416 static char *machine = "";
417 static char *user = "";
418 static char *passwd = "";
419 static char *dir = "";
420
421 /* Grab the next token and buy some space for it */
422
423 static char *
next(char ** ptr)424 next (char **ptr)
425 {
426 char *p = *ptr;
427 char *s;
428 char *r;
429 int l = 0;
430
431 while (*p && *p == ' ')
432 p++;
433 s = p;
434 while (*p && (*p != ' ' && *p != '\t'))
435 {
436 l++;
437 p++;
438 }
439 r = xmalloc (l + 1);
440 memcpy (r, s, l);
441 r[l] = 0;
442 *ptr = p;
443 return r;
444 }
445
446 static void
e7000_login_command(char * args,int from_tty)447 e7000_login_command (char *args, int from_tty)
448 {
449 if (args)
450 {
451 machine = next (&args);
452 user = next (&args);
453 passwd = next (&args);
454 dir = next (&args);
455 if (from_tty)
456 {
457 printf_unfiltered ("Set info to %s %s %s %s\n", machine, user, passwd, dir);
458 }
459 }
460 else
461 {
462 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
463 }
464 }
465
466 /* Start an ftp transfer from the E7000 to a host */
467
468 static void
e7000_ftp_command(char * args,int from_tty)469 e7000_ftp_command (char *args, int from_tty)
470 {
471 /* FIXME: arbitrary limit on machine names and such. */
472 char buf[200];
473
474 int oldtimeout = timeout;
475 timeout = remote_timeout;
476
477 sprintf (buf, "ftp %s\r", machine);
478 puts_e7000debug (buf);
479 expect (" Username : ");
480 sprintf (buf, "%s\r", user);
481 puts_e7000debug (buf);
482 expect (" Password : ");
483 write_e7000 (passwd);
484 write_e7000 ("\r");
485 expect ("success\r");
486 expect ("FTP>");
487 sprintf (buf, "cd %s\r", dir);
488 puts_e7000debug (buf);
489 expect ("FTP>");
490 sprintf (buf, "ll 0;s:%s\r", args);
491 puts_e7000debug (buf);
492 expect ("FTP>");
493 puts_e7000debug ("bye\r");
494 expect (":");
495 timeout = oldtimeout;
496 }
497
498 static int
e7000_parse_device(char * args,char * dev_name,int baudrate)499 e7000_parse_device (char *args, char *dev_name, int baudrate)
500 {
501 char junk[128];
502 int n = 0;
503 if (args && strcasecmp (args, "pc") == 0)
504 {
505 strcpy (dev_name, args);
506 using_pc = 1;
507 }
508 else
509 {
510 /* FIXME! temp hack to allow use with port master -
511 target tcp_remote <device> */
512 if (args && strncmp (args, "tcp", 10) == 0)
513 {
514 char com_type[128];
515 n = sscanf (args, " %s %s %d %s", com_type, dev_name, &baudrate, junk);
516 using_tcp_remote = 1;
517 n--;
518 }
519 else if (args)
520 {
521 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
522 }
523
524 if (n != 1 && n != 2)
525 {
526 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
527 or \t\ttarget e7000 <host>[:<port>]\n\
528 or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
529 or \t\ttarget e7000 pc\n");
530 }
531
532 #if !defined(__GO32__) && !defined(_WIN32) && !defined(__CYGWIN__)
533 /* FIXME! test for ':' is ambiguous */
534 if (n == 1 && strchr (dev_name, ':') == 0)
535 {
536 /* Default to normal telnet port */
537 /* serial_open will use this to determine tcp communication */
538 strcat (dev_name, ":23");
539 }
540 #endif
541 if (!using_tcp_remote && strchr (dev_name, ':'))
542 using_tcp = 1;
543 }
544
545 return n;
546 }
547
548 /* Stub for catch_errors. */
549
550 static int
e7000_start_remote(void * dummy)551 e7000_start_remote (void *dummy)
552 {
553 int loop;
554 int sync;
555 int try;
556 int quit_trying;
557
558 immediate_quit++; /* Allow user to interrupt it */
559
560 /* Hello? Are you there? */
561 sync = 0;
562 loop = 0;
563 try = 0;
564 quit_trying = 20;
565 putchar_e7000 (CTRLC);
566 while (!sync && ++try <= quit_trying)
567 {
568 int c;
569
570 printf_unfiltered ("[waiting for e7000...]\n");
571
572 write_e7000 ("\r");
573 c = readchar (1);
574
575 /* FIXME! this didn't seem right-> while (c != SERIAL_TIMEOUT)
576 * we get stuck in this loop ...
577 * We may never timeout, and never sync up :-(
578 */
579 while (!sync && c != -1)
580 {
581 /* Dont echo cr's */
582 if (c != '\r')
583 {
584 putchar_unfiltered (c);
585 gdb_flush (gdb_stdout);
586 }
587 /* Shouldn't we either break here, or check for sync in inner loop? */
588 if (c == ':')
589 sync = 1;
590
591 if (loop++ == 20)
592 {
593 putchar_e7000 (CTRLC);
594 loop = 0;
595 }
596
597 QUIT;
598
599 if (quit_flag)
600 {
601 putchar_e7000 (CTRLC);
602 /* Was-> quit_flag = 0; */
603 c = -1;
604 quit_trying = try + 1; /* we don't want to try anymore */
605 }
606 else
607 {
608 c = readchar (1);
609 }
610 }
611 }
612
613 if (!sync)
614 {
615 fprintf_unfiltered (gdb_stderr, "Giving up after %d tries...\n", try);
616 error ("Unable to synchronize with target.\n");
617 }
618
619 puts_e7000debug ("\r");
620 expect_prompt ();
621 puts_e7000debug ("b -\r"); /* Clear breakpoints */
622 expect_prompt ();
623
624 immediate_quit--;
625
626 /* This is really the job of start_remote however, that makes an assumption
627 that the target is about to print out a status message of some sort. That
628 doesn't happen here. */
629
630 flush_cached_frames ();
631 registers_changed ();
632 stop_pc = read_pc ();
633 print_stack_frame (get_selected_frame (), 0, SRC_AND_LOC);
634
635 return 1;
636 }
637
638 static void
e7000_open(char * args,int from_tty)639 e7000_open (char *args, int from_tty)
640 {
641 int n;
642
643 target_preopen (from_tty);
644
645 n = e7000_parse_device (args, dev_name, baudrate);
646
647 push_target (&e7000_ops);
648
649 e7000_desc = serial_open (dev_name);
650
651 if (!e7000_desc)
652 perror_with_name (dev_name);
653
654 if (serial_setbaudrate (e7000_desc, baudrate))
655 {
656 serial_close (e7000_desc);
657 perror_with_name (dev_name);
658 }
659 serial_raw (e7000_desc);
660
661 /* Start the remote connection; if error (0), discard this target.
662 In particular, if the user quits, be sure to discard it
663 (we'd be in an inconsistent state otherwise). */
664 if (!catch_errors (e7000_start_remote, (char *) 0,
665 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
666 if (from_tty)
667 printf_filtered ("Remote target %s connected to %s\n", target_shortname,
668 dev_name);
669 }
670
671 /* Close out all files and local state before this target loses control. */
672
673 static void
e7000_close(int quitting)674 e7000_close (int quitting)
675 {
676 if (e7000_desc)
677 {
678 serial_close (e7000_desc);
679 e7000_desc = 0;
680 }
681 }
682
683 /* Terminate the open connection to the remote debugger. Use this
684 when you want to detach and do something else with your gdb. */
685
686 static void
e7000_detach(char * arg,int from_tty)687 e7000_detach (char *arg, int from_tty)
688 {
689 pop_target (); /* calls e7000_close to do the real work */
690 if (from_tty)
691 printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
692 }
693
694 /* Tell the remote machine to resume. */
695
696 static void
e7000_resume(ptid_t ptid,int step,enum target_signal sigal)697 e7000_resume (ptid_t ptid, int step, enum target_signal sigal)
698 {
699 if (step)
700 puts_e7000debug ("S\r");
701 else
702 puts_e7000debug ("G\r");
703 }
704
705 /* Read the remote registers into the block REGS.
706
707 For the H8/300 a register dump looks like:
708
709 PC=00021A CCR=80:I*******
710 ER0 - ER3 0000000A 0000002E 0000002E 00000000
711 ER4 - ER7 00000000 00000000 00000000 00FFEFF6
712 000218 MOV.B R1L,R2L
713 STEP NORMAL END or
714 BREAK POINT
715 */
716
717 char *want_h8300h = "PC=%p CCR=%c\n\
718 ER0 - ER3 %0 %1 %2 %3\n\
719 ER4 - ER7 %4 %5 %6 %7\n";
720
721 char *want_nopc_h8300h = "%p CCR=%c\n\
722 ER0 - ER3 %0 %1 %2 %3\n\
723 ER4 - ER7 %4 %5 %6 %7";
724
725 char *want_h8300s = "PC=%p CCR=%c\n\
726 MACH=\n\
727 ER0 - ER3 %0 %1 %2 %3\n\
728 ER4 - ER7 %4 %5 %6 %7\n";
729
730 char *want_nopc_h8300s = "%p CCR=%c EXR=%9\n\
731 ER0 - ER3 %0 %1 %2 %3\n\
732 ER4 - ER7 %4 %5 %6 %7";
733
734 char *want_sh = "PC=%16 SR=%22\n\
735 PR=%17 GBR=%18 VBR=%19\n\
736 MACH=%20 MACL=%21\n\
737 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
738 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n";
739
740 char *want_nopc_sh = "%16 SR=%22\n\
741 PR=%17 GBR=%18 VBR=%19\n\
742 MACH=%20 MACL=%21\n\
743 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
744 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
745
746 char *want_sh3 = "PC=%16 SR=%22\n\
747 PR=%17 GBR=%18 VBR=%19\n\
748 MACH=%20 MACL=%21 SSR=%23 SPC=%24\n\
749 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
750 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
751 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
752 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
753 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
754 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
755
756 char *want_nopc_sh3 = "%16 SR=%22\n\
757 PR=%17 GBR=%18 VBR=%19\n\
758 MACH=%20 MACL=%21 SSR=%22 SPC=%23\n\
759 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
760 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
761 R0_BANK0-R3_BANK0 %25 %26 %27 %28\n\
762 R4_BANK0-R7_BANK0 %29 %30 %31 %32\n\
763 R0_BANK1-R3_BANK1 %33 %34 %35 %36\n\
764 R4_BANK1-R7_BANK1 %37 %38 %39 %40";
765
766 static int
gch(void)767 gch (void)
768 {
769 return readchar (timeout);
770 }
771
772 static unsigned int
gbyte(void)773 gbyte (void)
774 {
775 int high = convert_hex_digit (gch ());
776 int low = convert_hex_digit (gch ());
777
778 return (high << 4) + low;
779 }
780
781 static void
fetch_regs_from_dump(int (* nextchar)(),char * want)782 fetch_regs_from_dump (int (*nextchar) (), char *want)
783 {
784 int regno;
785 char buf[MAX_REGISTER_SIZE];
786
787 int thischar = nextchar ();
788
789 if (want == NULL)
790 internal_error (__FILE__, __LINE__, "Register set not selected.");
791
792 while (*want)
793 {
794 switch (*want)
795 {
796 case '\n':
797 /* Skip to end of line and then eat all new line type stuff */
798 while (thischar != '\n' && thischar != '\r')
799 thischar = nextchar ();
800 while (thischar == '\n' || thischar == '\r')
801 thischar = nextchar ();
802 want++;
803 break;
804
805 case ' ':
806 while (thischar == ' '
807 || thischar == '\t'
808 || thischar == '\r'
809 || thischar == '\n')
810 thischar = nextchar ();
811 want++;
812 break;
813
814 default:
815 if (*want == thischar)
816 {
817 want++;
818 if (*want)
819 thischar = nextchar ();
820
821 }
822 else if (thischar == ' ' || thischar == '\n' || thischar == '\r')
823 {
824 thischar = nextchar ();
825 }
826 else
827 {
828 error ("out of sync in fetch registers wanted <%s>, got <%c 0x%x>",
829 want, thischar, thischar);
830 }
831
832 break;
833 case '%':
834 /* Got a register command */
835 want++;
836 switch (*want)
837 {
838 #ifdef PC_REGNUM
839 case 'p':
840 regno = PC_REGNUM;
841 want++;
842 break;
843 #endif
844 #ifdef CCR_REGNUM
845 case 'c':
846 regno = CCR_REGNUM;
847 want++;
848 break;
849 #endif
850 #ifdef SP_REGNUM
851 case 's':
852 regno = SP_REGNUM;
853 want++;
854 break;
855 #endif
856 #ifdef DEPRECATED_FP_REGNUM
857 case 'f':
858 regno = DEPRECATED_FP_REGNUM;
859 want++;
860 break;
861 #endif
862
863 default:
864 if (isdigit (want[0]))
865 {
866 if (isdigit (want[1]))
867 {
868 regno = (want[0] - '0') * 10 + want[1] - '0';
869 want += 2;
870 }
871 else
872 {
873 regno = want[0] - '0';
874 want++;
875 }
876 }
877
878 else
879 internal_error (__FILE__, __LINE__, "failed internal consistency check");
880 }
881 store_signed_integer (buf,
882 register_size (current_gdbarch, regno),
883 (LONGEST) get_hex (&thischar));
884 regcache_raw_supply (current_regcache, regno, buf);
885 break;
886 }
887 }
888 }
889
890 static void
e7000_fetch_registers(void)891 e7000_fetch_registers (void)
892 {
893 int regno;
894 char *wanted = NULL;
895
896 puts_e7000debug ("R\r");
897
898 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
899 {
900 wanted = want_sh;
901 switch (TARGET_ARCHITECTURE->mach)
902 {
903 case bfd_mach_sh3:
904 case bfd_mach_sh3e:
905 case bfd_mach_sh4:
906 wanted = want_sh3;
907 }
908 }
909 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
910 {
911 wanted = want_h8300h;
912 switch (TARGET_ARCHITECTURE->mach)
913 {
914 case bfd_mach_h8300s:
915 case bfd_mach_h8300sn:
916 case bfd_mach_h8300sx:
917 case bfd_mach_h8300sxn:
918 wanted = want_h8300s;
919 }
920 }
921
922 fetch_regs_from_dump (gch, wanted);
923
924 /* And supply the extra ones the simulator uses */
925 for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
926 {
927 int buf = 0;
928
929 regcache_raw_supply (current_regcache, regno, (char *) (&buf));
930 }
931 }
932
933 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
934 errno value. */
935
936 static void
e7000_fetch_register(int regno)937 e7000_fetch_register (int regno)
938 {
939 e7000_fetch_registers ();
940 }
941
942 /* Store the remote registers from the contents of the block REGS. */
943
944 static void
e7000_store_registers(void)945 e7000_store_registers (void)
946 {
947 int regno;
948
949 for (regno = 0; regno < NUM_REALREGS; regno++)
950 e7000_store_register (regno);
951
952 registers_changed ();
953 }
954
955 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
956
957 static void
e7000_store_register(int regno)958 e7000_store_register (int regno)
959 {
960 char buf[200];
961
962 if (regno == -1)
963 {
964 e7000_store_registers ();
965 return;
966 }
967
968 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
969 {
970 if (regno <= 7)
971 {
972 sprintf (buf, ".ER%d %s\r", regno, phex_nz (read_register (regno), 0));
973 puts_e7000debug (buf);
974 }
975 else if (regno == PC_REGNUM)
976 {
977 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0));
978 puts_e7000debug (buf);
979 }
980 #ifdef CCR_REGNUM
981 else if (regno == CCR_REGNUM)
982 {
983 sprintf (buf, ".CCR %s\r", phex_nz (read_register (regno), 0));
984 puts_e7000debug (buf);
985 }
986 #endif
987 }
988
989 else if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
990 {
991 if (regno == PC_REGNUM)
992 {
993 sprintf (buf, ".PC %s\r", phex_nz (read_register (regno), 0));
994 puts_e7000debug (buf);
995 }
996
997 else if (regno == SR_REGNUM)
998 {
999 sprintf (buf, ".SR %s\r", phex_nz (read_register (regno), 0));
1000 puts_e7000debug (buf);
1001 }
1002
1003 else if (regno == PR_REGNUM)
1004 {
1005 sprintf (buf, ".PR %s\r", phex_nz (read_register (regno), 0));
1006 puts_e7000debug (buf);
1007 }
1008
1009 else if (regno == GBR_REGNUM)
1010 {
1011 sprintf (buf, ".GBR %s\r", phex_nz (read_register (regno), 0));
1012 puts_e7000debug (buf);
1013 }
1014
1015 else if (regno == VBR_REGNUM)
1016 {
1017 sprintf (buf, ".VBR %s\r", phex_nz (read_register (regno), 0));
1018 puts_e7000debug (buf);
1019 }
1020
1021 else if (regno == MACH_REGNUM)
1022 {
1023 sprintf (buf, ".MACH %s\r", phex_nz (read_register (regno), 0));
1024 puts_e7000debug (buf);
1025 }
1026
1027 else if (regno == MACL_REGNUM)
1028 {
1029 sprintf (buf, ".MACL %s\r", phex_nz (read_register (regno), 0));
1030 puts_e7000debug (buf);
1031 }
1032 else
1033 {
1034 sprintf (buf, ".R%d %s\r", regno, phex_nz (read_register (regno), 0));
1035 puts_e7000debug (buf);
1036 }
1037 }
1038
1039 expect_prompt ();
1040 }
1041
1042 /* Get ready to modify the registers array. On machines which store
1043 individual registers, this doesn't need to do anything. On machines
1044 which store all the registers in one fell swoop, this makes sure
1045 that registers contains all the registers from the program being
1046 debugged. */
1047
1048 static void
e7000_prepare_to_store(void)1049 e7000_prepare_to_store (void)
1050 {
1051 /* Do nothing, since we can store individual regs */
1052 }
1053
1054 static void
e7000_files_info(struct target_ops * ops)1055 e7000_files_info (struct target_ops *ops)
1056 {
1057 printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baudrate);
1058 }
1059
1060 static int
stickbyte(char * where,unsigned int what)1061 stickbyte (char *where, unsigned int what)
1062 {
1063 static CONST char digs[] = "0123456789ABCDEF";
1064
1065 where[0] = digs[(what >> 4) & 0xf];
1066 where[1] = digs[(what & 0xf) & 0xf];
1067
1068 return what;
1069 }
1070
1071 /* Write a small ammount of memory. */
1072
1073 static int
write_small(CORE_ADDR memaddr,unsigned char * myaddr,int len)1074 write_small (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1075 {
1076 int i;
1077 char buf[200];
1078
1079 for (i = 0; i < len; i++)
1080 {
1081 if (((memaddr + i) & 3) == 0 && (i + 3 < len))
1082 {
1083 /* Can be done with a long word */
1084 sprintf (buf, "m %s %x%02x%02x%02x;l\r",
1085 paddr_nz (memaddr + i),
1086 myaddr[i], myaddr[i + 1], myaddr[i + 2], myaddr[i + 3]);
1087 puts_e7000debug (buf);
1088 i += 3;
1089 }
1090 else
1091 {
1092 sprintf (buf, "m %s %x\r", paddr_nz (memaddr + i), myaddr[i]);
1093 puts_e7000debug (buf);
1094 }
1095 }
1096
1097 expect_prompt ();
1098
1099 return len;
1100 }
1101
1102 /* Write a large ammount of memory, this only works with the serial
1103 mode enabled. Command is sent as
1104
1105 il ;s:s\r ->
1106 <- il ;s:s\r
1107 <- ENQ
1108 ACK ->
1109 <- LO s\r
1110 Srecords...
1111 ^Z ->
1112 <- ENQ
1113 ACK ->
1114 <- :
1115 */
1116
1117 static int
write_large(CORE_ADDR memaddr,unsigned char * myaddr,int len)1118 write_large (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1119 {
1120 int i;
1121 #define maxstride 128
1122 int stride;
1123
1124 puts_e7000debug ("IL ;S:FK\r");
1125 expect (ENQSTRING);
1126 putchar_e7000 (ACK);
1127 expect ("LO FK\r");
1128
1129 for (i = 0; i < len; i += stride)
1130 {
1131 char compose[maxstride * 2 + 50];
1132 int address = i + memaddr;
1133 int j;
1134 int check_sum;
1135 int where = 0;
1136 int alen;
1137
1138 stride = len - i;
1139 if (stride > maxstride)
1140 stride = maxstride;
1141
1142 compose[where++] = 'S';
1143 check_sum = 0;
1144 if (address >= 0xffffff)
1145 alen = 4;
1146 else if (address >= 0xffff)
1147 alen = 3;
1148 else
1149 alen = 2;
1150 /* Insert type. */
1151 compose[where++] = alen - 1 + '0';
1152 /* Insert length. */
1153 check_sum += stickbyte (compose + where, alen + stride + 1);
1154 where += 2;
1155 while (alen > 0)
1156 {
1157 alen--;
1158 check_sum += stickbyte (compose + where, address >> (8 * (alen)));
1159 where += 2;
1160 }
1161
1162 for (j = 0; j < stride; j++)
1163 {
1164 check_sum += stickbyte (compose + where, myaddr[i + j]);
1165 where += 2;
1166 }
1167 stickbyte (compose + where, ~check_sum);
1168 where += 2;
1169 compose[where++] = '\r';
1170 compose[where++] = '\n';
1171 compose[where++] = 0;
1172
1173 serial_write (e7000_desc, compose, where);
1174 j = readchar (0);
1175 if (j == -1)
1176 {
1177 /* This is ok - nothing there */
1178 }
1179 else if (j == ENQ)
1180 {
1181 /* Hmm, it's trying to tell us something */
1182 expect (":");
1183 error ("Error writing memory");
1184 }
1185 else
1186 {
1187 printf_unfiltered ("@%d}@", j);
1188 while ((j = readchar (0)) > 0)
1189 {
1190 printf_unfiltered ("@{%d}@", j);
1191 }
1192 }
1193 }
1194
1195 /* Send the trailer record */
1196 write_e7000 ("S70500000000FA\r");
1197 putchar_e7000 (CTRLZ);
1198 expect (ENQSTRING);
1199 putchar_e7000 (ACK);
1200 expect (":");
1201
1202 return len;
1203 }
1204
1205 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1206 memory at MEMADDR. Returns length moved.
1207
1208 Can't use the Srecord load over ethernet, so don't use fast method
1209 then. */
1210
1211 static int
e7000_write_inferior_memory(CORE_ADDR memaddr,unsigned char * myaddr,int len)1212 e7000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1213 {
1214 if (len < 16 || using_tcp || using_pc)
1215 return write_small (memaddr, myaddr, len);
1216 else
1217 return write_large (memaddr, myaddr, len);
1218 }
1219
1220 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1221 at debugger address MYADDR. Returns length moved.
1222
1223 Small transactions we send
1224 m <addr>;l
1225 and receive
1226 00000000 12345678 ?
1227 */
1228
1229 static int
e7000_read_inferior_memory(CORE_ADDR memaddr,unsigned char * myaddr,int len)1230 e7000_read_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
1231 {
1232 int count;
1233 int c;
1234 int i;
1235 char buf[200];
1236 /* Starting address of this pass. */
1237
1238 /* printf("READ INF %x %x %d\n", memaddr, myaddr, len); */
1239 if (((memaddr - 1) + len) < memaddr)
1240 {
1241 errno = EIO;
1242 return 0;
1243 }
1244
1245 sprintf (buf, "m %s;l\r", paddr_nz (memaddr));
1246 puts_e7000debug (buf);
1247
1248 for (count = 0; count < len; count += 4)
1249 {
1250 /* Suck away the address */
1251 c = gch ();
1252 while (c != ' ')
1253 c = gch ();
1254 c = gch ();
1255 if (c == '*')
1256 { /* Some kind of error */
1257 puts_e7000debug (".\r"); /* Some errors leave us in memory input mode */
1258 expect_full_prompt ();
1259 return -1;
1260 }
1261 while (c != ' ')
1262 c = gch ();
1263
1264 /* Now read in the data */
1265 for (i = 0; i < 4; i++)
1266 {
1267 int b = gbyte ();
1268 if (count + i < len)
1269 {
1270 myaddr[count + i] = b;
1271 }
1272 }
1273
1274 /* Skip the trailing ? and send a . to end and a cr for more */
1275 gch ();
1276 gch ();
1277 if (count + 4 >= len)
1278 puts_e7000debug (".\r");
1279 else
1280 puts_e7000debug ("\r");
1281
1282 }
1283 expect_prompt ();
1284 return len;
1285 }
1286
1287
1288
1289 /*
1290 For large transfers we used to send
1291
1292
1293 d <addr> <endaddr>\r
1294
1295 and receive
1296 <ADDRESS> < D A T A > < ASCII CODE >
1297 00000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1298 00000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1299 00000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1300
1301 A cost in chars for each transaction of 80 + 5*n-bytes.
1302
1303 Large transactions could be done with the srecord load code, but
1304 there is a pause for a second before dumping starts, which slows the
1305 average rate down!
1306 */
1307
1308 static int
e7000_read_inferior_memory_large(CORE_ADDR memaddr,unsigned char * myaddr,int len)1309 e7000_read_inferior_memory_large (CORE_ADDR memaddr, unsigned char *myaddr,
1310 int len)
1311 {
1312 int count;
1313 int c;
1314 char buf[200];
1315
1316 /* Starting address of this pass. */
1317
1318 if (((memaddr - 1) + len) < memaddr)
1319 {
1320 errno = EIO;
1321 return 0;
1322 }
1323
1324 sprintf (buf, "d %s %s\r", paddr_nz (memaddr), paddr_nz (memaddr + len - 1));
1325 puts_e7000debug (buf);
1326
1327 count = 0;
1328 c = gch ();
1329
1330 /* skip down to the first ">" */
1331 while (c != '>')
1332 c = gch ();
1333 /* now skip to the end of that line */
1334 while (c != '\r')
1335 c = gch ();
1336 c = gch ();
1337
1338 while (count < len)
1339 {
1340 /* get rid of any white space before the address */
1341 while (c <= ' ')
1342 c = gch ();
1343
1344 /* Skip the address */
1345 get_hex (&c);
1346
1347 /* read in the bytes on the line */
1348 while (c != '"' && count < len)
1349 {
1350 if (c == ' ')
1351 c = gch ();
1352 else
1353 {
1354 myaddr[count++] = get_hex (&c);
1355 }
1356 }
1357 /* throw out the rest of the line */
1358 while (c != '\r')
1359 c = gch ();
1360 }
1361
1362 /* wait for the ":" prompt */
1363 while (c != ':')
1364 c = gch ();
1365
1366 return len;
1367 }
1368
1369 #if 0
1370
1371 static int
1372 fast_but_for_the_pause_e7000_read_inferior_memory (CORE_ADDR memaddr,
1373 char *myaddr, int len)
1374 {
1375 int loop;
1376 int c;
1377 char buf[200];
1378
1379 if (((memaddr - 1) + len) < memaddr)
1380 {
1381 errno = EIO;
1382 return 0;
1383 }
1384
1385 sprintf (buf, "is %x@%x:s\r", memaddr, len);
1386 puts_e7000debug (buf);
1387 gch ();
1388 c = gch ();
1389 if (c != ENQ)
1390 {
1391 /* Got an error */
1392 error ("Memory read error");
1393 }
1394 putchar_e7000 (ACK);
1395 expect ("SV s");
1396 loop = 1;
1397 while (loop)
1398 {
1399 int type;
1400 int length;
1401 int addr;
1402 int i;
1403
1404 c = gch ();
1405 switch (c)
1406 {
1407 case ENQ: /* ENQ, at the end */
1408 loop = 0;
1409 break;
1410 case 'S':
1411 /* Start of an Srecord */
1412 type = gch ();
1413 length = gbyte ();
1414 switch (type)
1415 {
1416 case '7': /* Termination record, ignore */
1417 case '0':
1418 case '8':
1419 case '9':
1420 /* Header record - ignore it */
1421 while (length--)
1422 {
1423 gbyte ();
1424 }
1425 break;
1426 case '1':
1427 case '2':
1428 case '3':
1429 {
1430 int alen;
1431
1432 alen = type - '0' + 1;
1433 addr = 0;
1434 while (alen--)
1435 {
1436 addr = (addr << 8) + gbyte ();
1437 length--;
1438 }
1439
1440 for (i = 0; i < length - 1; i++)
1441 myaddr[i + addr - memaddr] = gbyte ();
1442
1443 gbyte (); /* Ignore checksum */
1444 }
1445 }
1446 }
1447 }
1448
1449 putchar_e7000 (ACK);
1450 expect ("TOP ADDRESS =");
1451 expect ("END ADDRESS =");
1452 expect (":");
1453
1454 return len;
1455 }
1456
1457 #endif
1458
1459 /* Transfer LEN bytes between GDB address MYADDR and target address
1460 MEMADDR. If WRITE is non-zero, transfer them to the target,
1461 otherwise transfer them from the target. TARGET is unused.
1462
1463 Returns the number of bytes transferred. */
1464
1465 static int
e7000_xfer_inferior_memory(CORE_ADDR memaddr,char * myaddr,int len,int write,struct mem_attrib * attrib,struct target_ops * target)1466 e7000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
1467 int write, struct mem_attrib *attrib,
1468 struct target_ops *target)
1469 {
1470 if (write)
1471 return e7000_write_inferior_memory (memaddr, myaddr, len);
1472 else if (len < 16)
1473 return e7000_read_inferior_memory (memaddr, myaddr, len);
1474 else
1475 return e7000_read_inferior_memory_large (memaddr, myaddr, len);
1476 }
1477
1478 static void
e7000_kill(void)1479 e7000_kill (void)
1480 {
1481 }
1482
1483 static void
e7000_load(char * args,int from_tty)1484 e7000_load (char *args, int from_tty)
1485 {
1486 struct cleanup *old_chain;
1487 asection *section;
1488 bfd *pbfd;
1489 bfd_vma entry;
1490 #define WRITESIZE 0x1000
1491 char buf[2 + 4 + 4 + WRITESIZE]; /* `DT' + <addr> + <len> + <data> */
1492 char *filename;
1493 int quiet;
1494 int nostart;
1495 time_t start_time, end_time; /* Start and end times of download */
1496 unsigned long data_count; /* Number of bytes transferred to memory */
1497 int oldtimeout = timeout;
1498
1499 timeout = remote_timeout;
1500
1501
1502 /* FIXME! change test to test for type of download */
1503 if (!using_tcp)
1504 {
1505 generic_load (args, from_tty);
1506 return;
1507 }
1508
1509 /* for direct tcp connections, we can do a fast binary download */
1510 buf[0] = 'D';
1511 buf[1] = 'T';
1512 quiet = 0;
1513 nostart = 0;
1514 filename = NULL;
1515
1516 while (*args != '\000')
1517 {
1518 char *arg;
1519
1520 while (isspace (*args))
1521 args++;
1522
1523 arg = args;
1524
1525 while ((*args != '\000') && !isspace (*args))
1526 args++;
1527
1528 if (*args != '\000')
1529 *args++ = '\000';
1530
1531 if (*arg != '-')
1532 filename = arg;
1533 else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1534 quiet = 1;
1535 else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1536 nostart = 1;
1537 else
1538 error ("unknown option `%s'", arg);
1539 }
1540
1541 if (!filename)
1542 filename = get_exec_file (1);
1543
1544 pbfd = bfd_openr (filename, gnutarget);
1545 if (pbfd == NULL)
1546 {
1547 perror_with_name (filename);
1548 return;
1549 }
1550 old_chain = make_cleanup_bfd_close (pbfd);
1551
1552 if (!bfd_check_format (pbfd, bfd_object))
1553 error ("\"%s\" is not an object file: %s", filename,
1554 bfd_errmsg (bfd_get_error ()));
1555
1556 start_time = time (NULL);
1557 data_count = 0;
1558
1559 puts_e7000debug ("mw\r");
1560
1561 expect ("\nOK");
1562
1563 for (section = pbfd->sections; section; section = section->next)
1564 {
1565 if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1566 {
1567 bfd_vma section_address;
1568 bfd_size_type section_size;
1569 file_ptr fptr;
1570
1571 section_address = bfd_get_section_vma (pbfd, section);
1572 section_size = bfd_get_section_size (section);
1573
1574 if (!quiet)
1575 printf_filtered ("[Loading section %s at 0x%s (%s bytes)]\n",
1576 bfd_get_section_name (pbfd, section),
1577 paddr_nz (section_address),
1578 paddr_u (section_size));
1579
1580 fptr = 0;
1581
1582 data_count += section_size;
1583
1584 while (section_size > 0)
1585 {
1586 int count;
1587 static char inds[] = "|/-\\";
1588 static int k = 0;
1589
1590 QUIT;
1591
1592 count = min (section_size, WRITESIZE);
1593
1594 buf[2] = section_address >> 24;
1595 buf[3] = section_address >> 16;
1596 buf[4] = section_address >> 8;
1597 buf[5] = section_address;
1598
1599 buf[6] = count >> 24;
1600 buf[7] = count >> 16;
1601 buf[8] = count >> 8;
1602 buf[9] = count;
1603
1604 bfd_get_section_contents (pbfd, section, buf + 10, fptr, count);
1605
1606 if (serial_write (e7000_desc, buf, count + 10))
1607 fprintf_unfiltered (gdb_stderr,
1608 "e7000_load: serial_write failed: %s\n",
1609 safe_strerror (errno));
1610
1611 expect ("OK");
1612
1613 if (!quiet)
1614 {
1615 printf_unfiltered ("\r%c", inds[k++ % 4]);
1616 gdb_flush (gdb_stdout);
1617 }
1618
1619 section_address += count;
1620 fptr += count;
1621 section_size -= count;
1622 }
1623 }
1624 }
1625
1626 write_e7000 ("ED");
1627
1628 expect_prompt ();
1629
1630 end_time = time (NULL);
1631
1632 /* Finally, make the PC point at the start address */
1633
1634 if (exec_bfd)
1635 write_pc (bfd_get_start_address (exec_bfd));
1636
1637 inferior_ptid = null_ptid; /* No process now */
1638
1639 /* This is necessary because many things were based on the PC at the time that
1640 we attached to the monitor, which is no longer valid now that we have loaded
1641 new code (and just changed the PC). Another way to do this might be to call
1642 normal_stop, except that the stack may not be valid, and things would get
1643 horribly confused... */
1644
1645 clear_symtab_users ();
1646
1647 if (!nostart)
1648 {
1649 entry = bfd_get_start_address (pbfd);
1650
1651 if (!quiet)
1652 printf_unfiltered ("[Starting %s at 0x%s]\n", filename, paddr_nz (entry));
1653
1654 /* start_routine (entry); */
1655 }
1656
1657 report_transfer_performance (data_count, start_time, end_time);
1658
1659 do_cleanups (old_chain);
1660 timeout = oldtimeout;
1661 }
1662
1663 /* Clean up when a program exits.
1664
1665 The program actually lives on in the remote processor's RAM, and may be
1666 run again without a download. Don't leave it full of breakpoint
1667 instructions. */
1668
1669 static void
e7000_mourn_inferior(void)1670 e7000_mourn_inferior (void)
1671 {
1672 remove_breakpoints ();
1673 unpush_target (&e7000_ops);
1674 generic_mourn_inferior (); /* Do all the proper things now */
1675 }
1676
1677 #define MAX_BREAKPOINTS 200
1678 #ifdef HARD_BREAKPOINTS
1679 #define MAX_E7000DEBUG_BREAKPOINTS (BC_BREAKPOINTS ? 5 : MAX_BREAKPOINTS)
1680 #else
1681 #define MAX_E7000DEBUG_BREAKPOINTS MAX_BREAKPOINTS
1682 #endif
1683
1684 /* Since we can change to soft breakpoints dynamically, we must define
1685 more than enough. Was breakaddr[MAX_E7000DEBUG_BREAKPOINTS]. */
1686 static CORE_ADDR breakaddr[MAX_BREAKPOINTS] =
1687 {0};
1688
1689 static int
e7000_insert_breakpoint(CORE_ADDR addr,char * shadow)1690 e7000_insert_breakpoint (CORE_ADDR addr, char *shadow)
1691 {
1692 int i;
1693 char buf[200];
1694 #if 0
1695 static char nop[2] = NOP;
1696 #endif
1697
1698 for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++)
1699 if (breakaddr[i] == 0)
1700 {
1701 breakaddr[i] = addr;
1702 /* Save old contents, and insert a nop in the space */
1703 #ifdef HARD_BREAKPOINTS
1704 if (BC_BREAKPOINTS)
1705 {
1706 sprintf (buf, "BC%d A=%s\r", i + 1, paddr_nz (addr));
1707 puts_e7000debug (buf);
1708 }
1709 else
1710 {
1711 sprintf (buf, "B %s\r", paddr_nz (addr));
1712 puts_e7000debug (buf);
1713 }
1714 #else
1715 #if 0
1716 e7000_read_inferior_memory (addr, shadow, 2);
1717 e7000_write_inferior_memory (addr, nop, 2);
1718 #endif
1719
1720 sprintf (buf, "B %x\r", addr);
1721 puts_e7000debug (buf);
1722 #endif
1723 expect_prompt ();
1724 return 0;
1725 }
1726
1727 error ("Too many breakpoints ( > %d) for the E7000\n",
1728 MAX_E7000DEBUG_BREAKPOINTS);
1729 return 1;
1730 }
1731
1732 static int
e7000_remove_breakpoint(CORE_ADDR addr,char * shadow)1733 e7000_remove_breakpoint (CORE_ADDR addr, char *shadow)
1734 {
1735 int i;
1736 char buf[200];
1737
1738 for (i = 0; i < MAX_E7000DEBUG_BREAKPOINTS; i++)
1739 if (breakaddr[i] == addr)
1740 {
1741 breakaddr[i] = 0;
1742 #ifdef HARD_BREAKPOINTS
1743 if (BC_BREAKPOINTS)
1744 {
1745 sprintf (buf, "BC%d - \r", i + 1);
1746 puts_e7000debug (buf);
1747 }
1748 else
1749 {
1750 sprintf (buf, "B - %s\r", paddr_nz (addr));
1751 puts_e7000debug (buf);
1752 }
1753 expect_prompt ();
1754 #else
1755 sprintf (buf, "B - %s\r", paddr_nz (addr));
1756 puts_e7000debug (buf);
1757 expect_prompt ();
1758
1759 #if 0
1760 /* Replace the insn under the break */
1761 e7000_write_inferior_memory (addr, shadow, 2);
1762 #endif
1763 #endif
1764
1765 return 0;
1766 }
1767
1768 warning ("Can't find breakpoint associated with 0x%s\n", paddr_nz (addr));
1769 return 1;
1770 }
1771
1772 /* Put a command string, in args, out to STDBUG. Output from STDBUG
1773 is placed on the users terminal until the prompt is seen. */
1774
1775 static void
e7000_command(char * args,int fromtty)1776 e7000_command (char *args, int fromtty)
1777 {
1778 /* FIXME: arbitrary limit on length of args. */
1779 char buf[200];
1780
1781 echo = 0;
1782
1783 if (!e7000_desc)
1784 error ("e7000 target not open.");
1785 if (!args)
1786 {
1787 puts_e7000debug ("\r");
1788 }
1789 else
1790 {
1791 sprintf (buf, "%s\r", args);
1792 puts_e7000debug (buf);
1793 }
1794
1795 echo++;
1796 ctrl_c = 2;
1797 expect_full_prompt ();
1798 echo--;
1799 ctrl_c = 0;
1800 printf_unfiltered ("\n");
1801
1802 /* Who knows what the command did... */
1803 registers_changed ();
1804 }
1805
1806
1807 static void
e7000_drain_command(char * args,int fromtty)1808 e7000_drain_command (char *args, int fromtty)
1809 {
1810 int c;
1811
1812 puts_e7000debug ("end\r");
1813 putchar_e7000 (CTRLC);
1814
1815 while ((c = readchar (1)) != -1)
1816 {
1817 if (quit_flag)
1818 {
1819 putchar_e7000 (CTRLC);
1820 quit_flag = 0;
1821 }
1822 if (c > ' ' && c < 127)
1823 printf_unfiltered ("%c", c & 0xff);
1824 else
1825 printf_unfiltered ("<%x>", c & 0xff);
1826 }
1827 }
1828
1829 #define NITEMS 7
1830
1831 static int
why_stop(void)1832 why_stop (void)
1833 {
1834 static char *strings[NITEMS] =
1835 {
1836 "STEP NORMAL",
1837 "BREAK POINT",
1838 "BREAK KEY",
1839 "BREAK CONDI",
1840 "CYCLE ACCESS",
1841 "ILLEGAL INSTRUCTION",
1842 "WRITE PROTECT",
1843 };
1844 char *p[NITEMS];
1845 int c;
1846 int i;
1847
1848 for (i = 0; i < NITEMS; ++i)
1849 p[i] = strings[i];
1850
1851 c = gch ();
1852 while (1)
1853 {
1854 for (i = 0; i < NITEMS; i++)
1855 {
1856 if (c == *(p[i]))
1857 {
1858 p[i]++;
1859 if (*(p[i]) == 0)
1860 {
1861 /* found one of the choices */
1862 return i;
1863 }
1864 }
1865 else
1866 p[i] = strings[i];
1867 }
1868
1869 c = gch ();
1870 }
1871 }
1872
1873 /* Suck characters, if a string match, then return the strings index
1874 otherwise echo them. */
1875
1876 static int
expect_n(char ** strings)1877 expect_n (char **strings)
1878 {
1879 char *(ptr[10]);
1880 int n;
1881 int c;
1882 char saveaway[100];
1883 char *buffer = saveaway;
1884 /* Count number of expect strings */
1885
1886 for (n = 0; strings[n]; n++)
1887 {
1888 ptr[n] = strings[n];
1889 }
1890
1891 while (1)
1892 {
1893 int i;
1894 int gotone = 0;
1895
1896 c = readchar (1);
1897 if (c == -1)
1898 {
1899 printf_unfiltered ("[waiting for e7000...]\n");
1900 }
1901 #ifdef __GO32__
1902 if (kbhit ())
1903 {
1904 int k = getkey ();
1905
1906 if (k == 1)
1907 quit_flag = 1;
1908 }
1909 #endif
1910 if (quit_flag)
1911 {
1912 putchar_e7000 (CTRLC); /* interrupt the running program */
1913 quit_flag = 0;
1914 }
1915
1916 for (i = 0; i < n; i++)
1917 {
1918 if (c == ptr[i][0])
1919 {
1920 ptr[i]++;
1921 if (ptr[i][0] == 0)
1922 {
1923 /* Gone all the way */
1924 return i;
1925 }
1926 gotone = 1;
1927 }
1928 else
1929 {
1930 ptr[i] = strings[i];
1931 }
1932 }
1933
1934 if (gotone)
1935 {
1936 /* Save it up incase we find that there was no match */
1937 *buffer++ = c;
1938 }
1939 else
1940 {
1941 if (buffer != saveaway)
1942 {
1943 *buffer++ = 0;
1944 printf_unfiltered ("%s", buffer);
1945 buffer = saveaway;
1946 }
1947 if (c != -1)
1948 {
1949 putchar_unfiltered (c);
1950 gdb_flush (gdb_stdout);
1951 }
1952 }
1953 }
1954 }
1955
1956 /* We subtract two from the pc here rather than use
1957 DECR_PC_AFTER_BREAK since the e7000 doesn't always add two to the
1958 pc, and the simulators never do. */
1959
1960 static void
sub2_from_pc(void)1961 sub2_from_pc (void)
1962 {
1963 char buf[4];
1964 char buf2[200];
1965
1966 store_signed_integer (buf,
1967 register_size (current_gdbarch, PC_REGNUM),
1968 read_register (PC_REGNUM) - 2);
1969 regcache_raw_supply (current_regcache, PC_REGNUM, buf);
1970 sprintf (buf2, ".PC %s\r", phex_nz (read_register (PC_REGNUM), 0));
1971 puts_e7000debug (buf2);
1972 }
1973
1974 #define WAS_SLEEP 0
1975 #define WAS_INT 1
1976 #define WAS_RUNNING 2
1977 #define WAS_OTHER 3
1978
1979 static char *estrings[] =
1980 {
1981 "** SLEEP",
1982 "BREAK !",
1983 "** PC",
1984 "PC",
1985 NULL
1986 };
1987
1988 /* Wait until the remote machine stops, then return, storing status in
1989 STATUS just as `wait' would. */
1990
1991 static ptid_t
e7000_wait(ptid_t ptid,struct target_waitstatus * status)1992 e7000_wait (ptid_t ptid, struct target_waitstatus *status)
1993 {
1994 int stop_reason;
1995 int regno;
1996 int running_count = 0;
1997 int had_sleep = 0;
1998 int loop = 1;
1999 char *wanted_nopc = NULL;
2000
2001 /* Then echo chars until PC= string seen */
2002 gch (); /* Drop cr */
2003 gch (); /* and space */
2004
2005 while (loop)
2006 {
2007 switch (expect_n (estrings))
2008 {
2009 case WAS_OTHER:
2010 /* how did this happen ? */
2011 loop = 0;
2012 break;
2013 case WAS_SLEEP:
2014 had_sleep = 1;
2015 putchar_e7000 (CTRLC);
2016 loop = 0;
2017 break;
2018 case WAS_INT:
2019 loop = 0;
2020 break;
2021 case WAS_RUNNING:
2022 running_count++;
2023 if (running_count == 20)
2024 {
2025 printf_unfiltered ("[running...]\n");
2026 running_count = 0;
2027 }
2028 break;
2029 default:
2030 /* error? */
2031 break;
2032 }
2033 }
2034
2035 /* Skip till the PC= */
2036 expect ("=");
2037
2038 if (TARGET_ARCHITECTURE->arch == bfd_arch_sh)
2039 {
2040 wanted_nopc = want_nopc_sh;
2041 switch (TARGET_ARCHITECTURE->mach)
2042 {
2043 case bfd_mach_sh3:
2044 case bfd_mach_sh3e:
2045 case bfd_mach_sh4:
2046 wanted_nopc = want_nopc_sh3;
2047 }
2048 }
2049 if (TARGET_ARCHITECTURE->arch == bfd_arch_h8300)
2050 {
2051 wanted_nopc = want_nopc_h8300h;
2052 switch (TARGET_ARCHITECTURE->mach)
2053 {
2054 case bfd_mach_h8300s:
2055 case bfd_mach_h8300sn:
2056 case bfd_mach_h8300sx:
2057 case bfd_mach_h8300sxn:
2058 wanted_nopc = want_nopc_h8300s;
2059 }
2060 }
2061 fetch_regs_from_dump (gch, wanted_nopc);
2062
2063 /* And supply the extra ones the simulator uses */
2064 for (regno = NUM_REALREGS; regno < NUM_REGS; regno++)
2065 {
2066 int buf = 0;
2067 regcache_raw_supply (current_regcache, regno, (char *) &buf);
2068 }
2069
2070 stop_reason = why_stop ();
2071 expect_full_prompt ();
2072
2073 status->kind = TARGET_WAITKIND_STOPPED;
2074 status->value.sig = TARGET_SIGNAL_TRAP;
2075
2076 switch (stop_reason)
2077 {
2078 case 1: /* Breakpoint */
2079 write_pc (read_pc ()); /* PC is always off by 2 for breakpoints */
2080 status->value.sig = TARGET_SIGNAL_TRAP;
2081 break;
2082 case 0: /* Single step */
2083 status->value.sig = TARGET_SIGNAL_TRAP;
2084 break;
2085 case 2: /* Interrupt */
2086 if (had_sleep)
2087 {
2088 status->value.sig = TARGET_SIGNAL_TRAP;
2089 sub2_from_pc ();
2090 }
2091 else
2092 {
2093 status->value.sig = TARGET_SIGNAL_INT;
2094 }
2095 break;
2096 case 3:
2097 break;
2098 case 4:
2099 printf_unfiltered ("a cycle address error?\n");
2100 status->value.sig = TARGET_SIGNAL_UNKNOWN;
2101 break;
2102 case 5:
2103 status->value.sig = TARGET_SIGNAL_ILL;
2104 break;
2105 case 6:
2106 status->value.sig = TARGET_SIGNAL_SEGV;
2107 break;
2108 case 7: /* Anything else (NITEMS + 1) */
2109 printf_unfiltered ("a write protect error?\n");
2110 status->value.sig = TARGET_SIGNAL_UNKNOWN;
2111 break;
2112 default:
2113 /* Get the user's attention - this should never happen. */
2114 internal_error (__FILE__, __LINE__, "failed internal consistency check");
2115 }
2116
2117 return inferior_ptid;
2118 }
2119
2120 /* Stop the running program. */
2121
2122 static void
e7000_stop(void)2123 e7000_stop (void)
2124 {
2125 /* Sending a ^C is supposed to stop the running program. */
2126 putchar_e7000 (CTRLC);
2127 }
2128
2129 /* Define the target subroutine names. */
2130
2131 struct target_ops e7000_ops;
2132
2133 static void
init_e7000_ops(void)2134 init_e7000_ops (void)
2135 {
2136 e7000_ops.to_shortname = "e7000";
2137 e7000_ops.to_longname = "Remote Renesas e7000 target";
2138 e7000_ops.to_doc = "Use a remote Renesas e7000 ICE connected by a serial line;\n\
2139 or a network connection.\n\
2140 Arguments are the name of the device for the serial line,\n\
2141 the speed to connect at in bits per second.\n\
2142 eg\n\
2143 target e7000 /dev/ttya 9600\n\
2144 target e7000 foobar";
2145 e7000_ops.to_open = e7000_open;
2146 e7000_ops.to_close = e7000_close;
2147 e7000_ops.to_detach = e7000_detach;
2148 e7000_ops.to_resume = e7000_resume;
2149 e7000_ops.to_wait = e7000_wait;
2150 e7000_ops.to_fetch_registers = e7000_fetch_register;
2151 e7000_ops.to_store_registers = e7000_store_register;
2152 e7000_ops.to_prepare_to_store = e7000_prepare_to_store;
2153 e7000_ops.deprecated_xfer_memory = e7000_xfer_inferior_memory;
2154 e7000_ops.to_files_info = e7000_files_info;
2155 e7000_ops.to_insert_breakpoint = e7000_insert_breakpoint;
2156 e7000_ops.to_remove_breakpoint = e7000_remove_breakpoint;
2157 e7000_ops.to_kill = e7000_kill;
2158 e7000_ops.to_load = e7000_load;
2159 e7000_ops.to_create_inferior = e7000_create_inferior;
2160 e7000_ops.to_mourn_inferior = e7000_mourn_inferior;
2161 e7000_ops.to_stop = e7000_stop;
2162 e7000_ops.to_stratum = process_stratum;
2163 e7000_ops.to_has_all_memory = 1;
2164 e7000_ops.to_has_memory = 1;
2165 e7000_ops.to_has_stack = 1;
2166 e7000_ops.to_has_registers = 1;
2167 e7000_ops.to_has_execution = 1;
2168 e7000_ops.to_magic = OPS_MAGIC;
2169 };
2170
2171 extern initialize_file_ftype _initialize_remote_e7000; /* -Wmissing-prototypes */
2172
2173 void
_initialize_remote_e7000(void)2174 _initialize_remote_e7000 (void)
2175 {
2176 init_e7000_ops ();
2177 add_target (&e7000_ops);
2178
2179 add_com ("e7000", class_obscure, e7000_command,
2180 "Send a command to the e7000 monitor.");
2181
2182 add_com ("ftplogin", class_obscure, e7000_login_command,
2183 "Login to machine and change to directory.");
2184
2185 add_com ("ftpload", class_obscure, e7000_ftp_command,
2186 "Fetch and load a file from previously described place.");
2187
2188 add_com ("drain", class_obscure, e7000_drain_command,
2189 "Drain pending e7000 text buffers.");
2190
2191 deprecated_add_show_from_set
2192 (add_set_cmd ("usehardbreakpoints", no_class,
2193 var_integer, (char *) &use_hard_breakpoints, "\
2194 Set use of hardware breakpoints for all breakpoints.\n", &setlist),
2195 &showlist);
2196 }
2197