1 /* Remote debugging interface for Motorola's MVME187BUG monitor, an embedded
4 Copyright 1992, 1993 Free Software Foundation, Inc.
5 Contributed by Cygnus Support. Written by K. Richard Pixley.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
38 #include "remote-utils.h"
42 /* External data declarations */
43 extern int stop_soon_quietly
; /* for wait_for_inferior */
45 /* Forward data declarations */
46 extern struct target_ops bug_ops
; /* Forward declaration */
48 /* Forward function declarations */
49 static int bug_clear_breakpoints
PARAMS((void));
51 static int bug_read_memory
PARAMS((CORE_ADDR memaddr
,
52 unsigned char *myaddr
,
55 static int bug_write_memory
PARAMS((CORE_ADDR memaddr
,
56 unsigned char *myaddr
,
59 /* This variable is somewhat arbitrary. It's here so that it can be
60 set from within a running gdb. */
62 static int srec_max_retries
= 3;
64 /* Each S-record download to the target consists of an S0 header
65 record, some number of S3 data records, and one S7 termination
66 record. I call this download a "frame". Srec_frame says how many
67 bytes will be represented in each frame. */
69 static int srec_frame
= 160;
71 /* This variable determines how many bytes will be represented in each
74 static int srec_bytes
= 40;
76 /* At one point it appeared to me as though the bug monitor could not
77 really be expected to receive two sequential characters at 9600
78 baud reliably. Echo-pacing is an attempt to force data across the
79 line even in this condition. Specifically, in echo-pace mode, each
80 character is sent one at a time and we look for the echo before
81 sending the next. This is excruciatingly slow. */
83 static int srec_echo_pace
= 0;
85 /* How long to wait after an srec for a possible error message.
86 Similar to the above, I tried sleeping after sending each S3 record
87 in hopes that I might actually see error messages from the bug
88 monitor. This might actually work if we were to use sleep
89 intervals smaller than 1 second. */
91 static int srec_sleep
= 0;
93 /* Every srec_noise records, flub the checksum. This is a debugging
94 feature. Set the variable to something other than 1 in order to
95 inject *deliberate* checksum errors. One might do this if one
96 wanted to test error handling and recovery. */
98 static int srec_noise
= 0;
100 /* Called when SIGALRM signal sent due to alarm() timeout. */
102 /* Number of SIGTRAPs we need to simulate. That is, the next
103 NEED_ARTIFICIAL_TRAP calls to bug_wait should just return
104 SIGTRAP without actually waiting for anything. */
106 static int need_artificial_trap
= 0;
109 * Download a file specified in 'args', to the bug.
113 bug_load (args
, fromtty
)
123 dcache_flush (gr_get_dcache());
125 abfd
= bfd_openr (args
, 0);
128 printf_filtered ("Unable to open file %s\n", args
);
132 if (bfd_check_format (abfd
, bfd_object
) == 0)
134 printf_filtered ("File is not an object file\n");
139 while (s
!= (asection
*) NULL
)
141 if (s
->flags
& SEC_LOAD
)
145 char *buffer
= xmalloc (srec_frame
);
147 printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s
->name
, s
->vma
, s
->vma
+ s
->_raw_size
);
149 for (i
= 0; i
< s
->_raw_size
; i
+= srec_frame
)
151 if (srec_frame
> s
->_raw_size
- i
)
152 srec_frame
= s
->_raw_size
- i
;
154 bfd_get_section_contents (abfd
, s
, buffer
, i
, srec_frame
);
155 bug_write_memory (s
->vma
+ i
, buffer
, srec_frame
);
156 printf_filtered ("*");
159 printf_filtered ("\n");
164 sprintf (buffer
, "rs ip %lx", (unsigned long) abfd
->start_address
);
165 sr_write_cr (buffer
);
186 while (*s
&& !isspace (*s
))
192 copy
= xmalloc (len
+ 1);
193 memcpy (copy
, word
, len
);
200 static struct gr_settings bug_settings
= {
204 bug_clear_breakpoints
, /* clear_all_breakpoints */
205 bug_read_memory
, /* readfunc */
206 bug_write_memory
, /* writefunc */
207 gr_generic_checkin
, /* checkin */
210 static char *cpu_check_strings
[] = {
216 bug_open (args
, from_tty
)
223 gr_open(args
, from_tty
, &bug_settings
);
224 /* decide *now* whether we are on an 88100 or an 88110 */
225 sr_write_cr("rs cr06");
226 sr_expect("rs cr06");
228 switch (gr_multi_scan(cpu_check_strings
, 0))
230 case 0: /* this is an m88100 */
231 target_is_m88110
= 0;
233 case 1: /* this is an m88110 */
234 target_is_m88110
= 1;
241 /* Tell the remote machine to resume. */
244 bug_resume (pid
, step
, sig
)
247 dcache_flush (gr_get_dcache());
253 /* Force the next bug_wait to return a trap. Not doing anything
254 about I/O from the target means that the user has to type
255 "continue" to see any. FIXME, this should be fixed. */
256 need_artificial_trap
= 1;
264 /* Wait until the remote machine stops, then return,
265 storing status in STATUS just as `wait' would. */
267 static char *wait_strings
[] = {
269 "Exception: Data Access Fault (Local Bus Timeout)",
279 int old_timeout
= sr_get_timeout();
280 int old_immediate_quit
= immediate_quit
;
282 WSETEXIT ((*status
), 0);
284 /* read off leftovers from resume so that the rest can be passed
285 back out as stdout. */
286 if (need_artificial_trap
== 0)
288 sr_expect("Effective address: ");
289 (void) sr_get_hex_word();
293 sr_set_timeout(-1); /* Don't time out -- user program is running. */
294 immediate_quit
= 1; /* Helps ability to QUIT */
296 switch (gr_multi_scan(wait_strings
, need_artificial_trap
== 0))
298 case 0: /* breakpoint case */
299 WSETSTOP ((*status
), SIGTRAP
);
300 /* user output from the target can be discarded here. (?) */
304 case 1: /* bus error */
305 WSETSTOP ((*status
), SIGBUS
);
306 /* user output from the target can be discarded here. (?) */
310 case 2: /* normal case */
312 if (need_artificial_trap
!= 0)
315 WSETSTOP ((*status
), SIGTRAP
);
316 need_artificial_trap
--;
322 WSETEXIT ((*status
), 0);
326 case -1: /* trouble */
328 fprintf_filtered (stderr
,
329 "Trouble reading target during wait\n");
333 sr_set_timeout(old_timeout
);
334 immediate_quit
= old_immediate_quit
;
338 /* Return the name of register number REGNO
339 in the form input and output by bug.
341 Returns a pointer to a static buffer containing the answer. */
346 static char *rn
[] = {
347 "r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",
348 "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",
349 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
350 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
352 /* these get confusing because we omit a few and switch some ordering around. */
354 "cr01", /* 32 = psr */
355 "fcr62", /* 33 = fpsr*/
356 "fcr63", /* 34 = fpcr */
357 "ip", /* this is something of a cheat. */
359 "cr05", /* 36 = snip */
360 "cr06", /* 37 = sfip */
362 "x00", "x01", "x02", "x03", "x04", "x05", "x06", "x07",
363 "x08", "x09", "x10", "x11", "x12", "x13", "x14", "x15",
364 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
365 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
371 #if 0 /* not currently used */
372 /* Read from remote while the input matches STRING. Return zero on
373 success, -1 on failure. */
387 printf("\nNext character is '%c' - %d and s is \"%s\".\n", c
, c
, --s
);
397 bug_srec_write_cr (s
)
405 if (sr_get_debug() > 0)
409 SERIAL_WRITE(sr_get_desc(), p
, 1);
410 while (sr_pollchar() != *p
);
415 /* return(bug_scan (s) || bug_scan ("\n")); */
421 /* Store register REGNO, or all if REGNO == -1. */
424 bug_fetch_register(regno
)
427 REGISTER_TYPE regval
;
435 for (i
= 0; i
< NUM_REGS
; ++i
)
436 bug_fetch_register(i
);
438 else if (target_is_m88110
&& regno
== SFIP_REGNUM
)
440 /* m88110 has no sfip. */
442 supply_register(regno
, (char *) &l
);
444 else if (regno
< XFP_REGNUM
)
447 sr_write_cr(get_reg_name(regno
));
449 regval
= sr_get_hex_word();
451 supply_register(regno
, (char *) ®val
);
455 /* Float register so we need to parse a strange data format. */
457 unsigned char value
[10];
460 sr_write(get_reg_name(regno
), strlen(get_reg_name(regno
)));
463 sr_expect(get_reg_name(regno
));
468 p
= sr_get_hex_digit(1);
473 p
= sr_get_hex_digit(1);
474 value
[0] += (p
<< 4);
475 value
[0] += sr_get_hex_digit(1);
477 value
[1] = sr_get_hex_digit(1) << 4;
481 value
[1] += sr_get_hex_digit(1);
483 value
[2] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
484 value
[3] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
485 value
[4] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
486 value
[5] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
487 value
[6] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
488 value
[7] = (sr_get_hex_digit(1) << 4) + sr_get_hex_digit(1);
493 supply_register(regno
, value
);
499 /* Store register REGNO, or all if REGNO == -1. */
502 bug_store_register (regno
)
512 for (i
= 0; i
< NUM_REGS
; ++i
)
513 bug_store_register(i
);
519 regname
= get_reg_name(regno
);
521 if (target_is_m88110
&& regno
== SFIP_REGNUM
)
523 else if (regno
< XFP_REGNUM
)
524 sprintf(buffer
, "rs %s %08x",
526 read_register(regno
));
529 unsigned char *value
= ®isters
[REGISTER_BYTE(regno
)];
531 sprintf(buffer
, "rs %s %1x_%02x%1x_%1x%02x%02x%02x%02x%02x%02x;d",
534 (value
[0] >> 7) & 0xf,
537 (value
[1] >> 8) & 0xf,
556 bug_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
561 struct target_ops
*target
; /* ignored */
565 /* Round starting address down to longword boundary. */
566 register CORE_ADDR addr
;
568 /* Round ending address up; get number of longwords that makes. */
571 /* Allocate buffer of that many longwords. */
572 register int *buffer
;
574 addr
= memaddr
& -sizeof (int);
575 count
= (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
577 buffer
= (int *) alloca (count
* sizeof (int));
581 /* Fill start and end extra bytes of buffer with existing memory data. */
583 if (addr
!= memaddr
|| len
< (int) sizeof (int))
585 /* Need part of initial word -- fetch it. */
586 buffer
[0] = gr_fetch_word (addr
);
589 if (count
> 1) /* FIXME, avoid if even boundary */
592 = gr_fetch_word (addr
+ (count
- 1) * sizeof (int));
595 /* Copy data to be written over corresponding part of buffer */
597 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
599 /* Write the entire buffer. */
601 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
604 gr_store_word (addr
, buffer
[i
]);
615 /* Read all the longwords */
616 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
619 buffer
[i
] = gr_fetch_word (addr
);
627 /* Copy appropriate bytes out of the buffer. */
628 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
639 command
= (srec_echo_pace
? "lo 0 ;x" : "lo 0");
641 sr_write_cr (command
);
644 bug_srec_write_cr ("S0030000FC");
648 /* This is an extremely vulnerable and fragile function. I've made
649 considerable attempts to make this deterministic, but I've
650 certainly forgotten something. The trouble is that S-records are
651 only a partial file format, not a protocol. Worse, apparently the
652 m88k bug monitor does not run in real time while receiving
653 S-records. Hence, we must pay excruciating attention to when and
654 where error messages are returned, and what has actually been sent.
656 Each call represents a chunk of memory to be sent to the target.
657 We break that chunk into an S0 header record, some number of S3
658 data records each containing srec_bytes, and an S7 termination
661 static char *srecord_strings
[] = {
668 bug_write_memory (memaddr
, myaddr
, len
)
670 unsigned char *myaddr
;
677 char buffer
[(srec_bytes
+ 8) << 1];
685 if (retries
> srec_max_retries
)
690 if (sr_get_debug() > 0)
691 printf("\n<retrying...>\n");
693 /* This gr_expect_prompt call is extremely important. Without
694 it, we will tend to resend our packet so fast that it
695 will arrive before the bug monitor is ready to receive
696 it. This would lead to a very ugly resend loop. */
712 if (thisgo
> srec_bytes
)
715 address
= memaddr
+ done
;
716 sprintf (buf
, "S3%02X%08X", thisgo
+ 4 + 1, address
);
719 checksum
+= (thisgo
+ 4 + 1
721 + ((address
>> 8) & 0xff)
722 + ((address
>> 16) & 0xff)
723 + ((address
>> 24) & 0xff));
725 for (idx
= 0; idx
< thisgo
; idx
++)
727 sprintf (buf
, "%02X", myaddr
[idx
+ done
]);
728 checksum
+= myaddr
[idx
+ done
];
734 /* FIXME-NOW: insert a deliberate error every now and then.
735 This is intended for testing/debugging the error handling
737 static int counter
= 0;
738 if (++counter
> srec_noise
)
745 sprintf(buf
, "%02X", ~checksum
& 0xff);
746 bug_srec_write_cr (buffer
);
751 /* This pollchar is probably redundant to the gr_multi_scan
752 below. Trouble is, we can't be sure when or where an
753 error message will appear. Apparently, when running at
754 full speed from a typical sun4, error messages tend to
755 appear to arrive only *after* the s7 record. */
757 if ((x
= sr_pollchar()) != 0)
759 if (sr_get_debug() > 0)
760 printf("\n<retrying...>\n");
764 /* flush any remaining input and verify that we are back
765 at the prompt level. */
767 /* start all over again. */
776 bug_srec_write_cr("S7060000000000F9");
779 /* Having finished the load, we need to figure out whether we
781 } while (gr_multi_scan(srecord_strings
, 0) == 0);;
786 /* Copy LEN bytes of data from debugger memory at MYADDR
787 to inferior's memory at MEMADDR. Returns errno value.
788 * sb/sh instructions don't work on unaligned addresses, when TU=1.
791 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
792 at debugger address MYADDR. Returns errno value. */
794 bug_read_memory (memaddr
, myaddr
, len
)
796 unsigned char *myaddr
;
806 unsigned int checksum
;
808 sprintf(request
, "du 0 %x:&%d", memaddr
, len
);
809 sr_write_cr(request
);
811 p
= buffer
= alloca(len
);
813 /* scan up through the header */
814 sr_expect("S0030000FC");
816 while (p
< buffer
+ len
)
818 /* scan off any white space. */
819 while (sr_readchar() != 'S') ;;
821 /* what kind of s-rec? */
822 type
= sr_readchar();
824 /* scan record size */
825 sr_get_hex_byte(&size
);
839 inaddr
= (inaddr
<< 8) + c
;
842 /* intentional fall through */
845 inaddr
= (inaddr
<< 8) + c
;
848 /* intentional fall through */
851 inaddr
= (inaddr
<< 8) + c
;
855 inaddr
= (inaddr
<< 8) + c
;
862 error("reading s-records.");
866 || (memaddr
+ len
) < (inaddr
+ size
))
867 error("srec out of memory range.");
869 if (p
!= buffer
+ inaddr
- memaddr
)
870 error("srec out of sequence.");
872 for (; size
; --size
, ++p
)
879 if (c
!= (~checksum
& 0xff))
880 error("bad s-rec checksum");
885 if (p
!= buffer
+ len
)
888 memcpy(myaddr
, buffer
, len
);
892 #define MAX_BREAKS 16
893 static int num_brkpts
= 0;
895 bug_insert_breakpoint (addr
, save
)
897 char *save
; /* Throw away, let bug save instructions */
901 if (num_brkpts
< MAX_BREAKS
)
906 sprintf (buffer
, "br %x", addr
);
907 sr_write_cr (buffer
);
913 fprintf_filtered (stderr
,
914 "Too many break points, break point not installed\n");
920 bug_remove_breakpoint (addr
, save
)
922 char *save
; /* Throw away, let bug save instructions */
929 sprintf (buffer
, "nobr %x", addr
);
930 sr_write_cr (buffer
);
937 /* Clear the bugs notion of what the break points are */
939 bug_clear_breakpoints ()
944 sr_write_cr ("nobr");
952 struct target_ops bug_ops
=
954 "bug", "Remote BUG monitor",
955 "Use the mvme187 board running the BUG monitor connected\n\
959 0, gr_detach
, bug_resume
, bug_wait
, /* attach */
960 bug_fetch_register
, bug_store_register
,
964 bug_insert_breakpoint
, bug_remove_breakpoint
, /* Breakpoints */
965 0, 0, 0, 0, 0, /* Terminal handling */
966 gr_kill
, /* FIXME, kill */
968 0, /* lookup_symbol */
969 gr_create_inferior
, /* create_inferior */
970 gr_mourn
, /* mourn_inferior FIXME */
972 0, /* notice_signals */
973 process_stratum
, 0, /* next */
974 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
975 0, 0, /* Section pointers */
976 OPS_MAGIC
, /* Always the last thing */
980 _initialize_remote_bug ()
982 add_target (&bug_ops
);
985 (add_set_cmd ("srec-bytes", class_support
, var_uinteger
,
986 (char *) &srec_bytes
,
988 Set the number of bytes represented in each S-record.\n\
989 This affects the communication protocol with the remote target.",
994 (add_set_cmd ("srec-max-retries", class_support
, var_uinteger
,
995 (char *) &srec_max_retries
,
997 Set the number of retries for shipping S-records.\n\
998 This affects the communication protocol with the remote target.",
1003 (add_set_cmd ("srec-frame", class_support
, var_uinteger
,
1004 (char *) &srec_frame
,
1006 Set the number of bytes in an S-record frame.\n\
1007 This affects the communication protocol with the remote target.",
1012 (add_set_cmd ("srec-noise", class_support
, var_zinteger
,
1013 (char *) &srec_noise
,
1015 Set number of S-record to send before deliberately flubbing a checksum.\n\
1016 Zero means flub none at all. This affects the communication protocol\n\
1017 with the remote target.",
1022 (add_set_cmd ("srec-sleep", class_support
, var_zinteger
,
1023 (char *) &srec_sleep
,
1025 Set number of seconds to sleep after an S-record for a possible error message to arrive.\n\
1026 This affects the communication protocol with the remote target.",
1031 (add_set_cmd ("srec-echo-pace", class_support
, var_boolean
,
1032 (char *) &srec_echo_pace
,
1034 Set echo-verification.\n\
1035 When on, use verification by echo when downloading S-records. This is\n\
1036 much slower, but generally more reliable.",
This page took 0.086598 seconds and 4 git commands to generate.