1 /* Remote debugging interface for Array Tech RAID controller..
2 Copyright 90, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
5 This module talks to a debug monitor called 'MONITOR', which
6 We communicate with MONITOR via either a direct serial line, or a TCP
7 (or possibly TELNET) stream to a terminal multiplexor,
8 which in turn talks to the target board.
10 This file is part of GDB.
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.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <sys/types.h>
38 #include "remote-utils.h"
42 static const char hexchars
[]="0123456789abcdef";
43 static char *hex2mem();
47 #define SWAP_TARGET_AND_HOST(buffer,len) \
50 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
53 char *p = (char *)(buffer); \
54 char *q = ((char *)(buffer)) + len - 1; \
55 for (; p < q; p++, q--) \
65 static void debuglogs();
66 static void array_open();
67 static void array_close();
68 static void array_detach();
69 static void array_attach();
70 static void array_resume();
71 static void array_fetch_register();
72 static void array_store_register();
73 static void array_fetch_registers();
74 static void array_store_registers();
75 static void array_prepare_to_store();
76 static void array_files_info();
77 static void array_kill();
78 static void array_create_inferior();
79 static void array_mourn_inferior();
80 static void make_gdb_packet();
81 static int array_xfer_memory();
82 static int array_wait();
83 static int array_insert_breakpoint();
84 static int array_remove_breakpoint();
87 static int from_hex();
88 static int array_send_packet();
89 static int array_get_packet();
90 static unsigned long ascii2hexword();
91 static char *hexword2ascii();
95 #define LOG_FILE "monitor.log"
96 #if defined (LOG_FILE)
100 static int timeout
= 30;
101 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
102 and i386-stub.c. Normally, no one would notice because it only matters
103 for writing large chunks of memory (e.g. in downloads). Also, this needs
104 to be more than 400 if required to hold the registers (see below, where
105 we round it up based on REGISTER_BYTES). */
109 * Descriptor for I/O to remote machine. Initialize it to NULL so that
110 * array_open knows that we don't have a file open when the program starts.
112 serial_t array_desc
= NULL
;
115 * this array of registers need to match the indexes used by GDB. The
116 * whole reason this exists is cause the various ROM monitors use
117 * different strings than GDB does, and doesn't support all the
118 * registers either. So, typing "info reg sp" becomes a "r30".
120 extern char *tmp_mips_processor_type
;
121 extern int mips_set_processor_type();
123 static struct target_ops array_ops
= {
124 "array", /* to_shortname */
126 "Debug using the standard GDB remote protocol for the Array Tech target.",
128 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
129 Specify the serial device it is connected to (e.g. /dev/ttya).",
130 array_open
, /* to_open */
131 array_close
, /* to_close */
132 NULL
, /* to_attach */
133 array_detach
, /* to_detach */
134 array_resume
, /* to_resume */
135 array_wait
, /* to_wait */
136 array_fetch_registers
, /* to_fetch_registers */
137 array_store_registers
, /* to_store_registers */
138 array_prepare_to_store
, /* to_prepare_to_store */
139 array_xfer_memory
, /* to_xfer_memory */
140 array_files_info
, /* to_files_info */
141 array_insert_breakpoint
, /* to_insert_breakpoint */
142 array_remove_breakpoint
, /* to_remove_breakpoint */
143 0, /* to_terminal_init */
144 0, /* to_terminal_inferior */
145 0, /* to_terminal_ours_for_output */
146 0, /* to_terminal_ours */
147 0, /* to_terminal_info */
148 array_kill
, /* to_kill */
150 0, /* to_lookup_symbol */
151 array_create_inferior
, /* to_create_inferior */
152 array_mourn_inferior
, /* to_mourn_inferior */
154 0, /* to_notice_signals */
156 process_stratum
, /* to_stratum */
158 1, /* to_has_all_memory */
159 1, /* to_has_memory */
160 1, /* to_has_stack */
161 1, /* to_has_registers */
162 1, /* to_has_execution */
164 0, /* sections_end */
165 OPS_MAGIC
/* to_magic */
169 * printf_monitor -- send data to monitor. Works just like printf.
172 printf_monitor(va_alist
)
182 pattern
= va_arg(args
, char *);
184 vsprintf(buf
, pattern
, args
);
186 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
188 if (strlen(buf
) > PBUFSIZ
)
189 error ("printf_monitor(): string too long");
190 if (SERIAL_WRITE(array_desc
, buf
, strlen(buf
)))
191 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
194 * write_monitor -- send raw data to monitor.
197 write_monitor(data
, len
)
201 if (SERIAL_WRITE(array_desc
, data
, len
))
202 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
204 *(data
+ len
+1) = '\0';
205 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
210 * debuglogs -- deal with debugging info to multiple sources. This takes
211 * two real args, the first one is the level to be compared against
212 * the sr_get_debug() value, the second arg is a printf buffer and args
213 * to be formatted and printed. A CR is added after each string is printed.
221 unsigned char buf
[PBUFSIZ
];
222 char newbuf
[PBUFSIZ
];
227 level
= va_arg(args
, int); /* get the debug level */
228 if ((level
<0) || (level
> 100)) {
229 error ("Bad argument passed to debuglogs(), needs debug level");
233 pattern
= va_arg(args
, char *); /* get the printf style pattern */
235 vsprintf(buf
, pattern
, args
); /* format the string */
237 /* convert some characters so it'll look right in the log */
239 for (i
= 0 ; buf
[i
] != '\0'; i
++) {
241 error ("Debug message too long");
243 case '\n': /* newlines */
247 case '\r': /* carriage returns */
251 case '\033': /* escape */
259 case '\b': /* backspace */
263 default: /* no change */
267 if (buf
[i
] < 26) { /* modify control characters */
272 if (buf
[i
] >= 128) { /* modify control characters */
278 *p
= '\0'; /* terminate the string */
280 if (sr_get_debug() > level
)
281 printf_unfiltered ("%s\n", newbuf
);
283 #ifdef LOG_FILE /* write to the monitor log */
284 if (log_file
!= 0x0) {
285 fputs (newbuf
, log_file
);
286 fputc ('\n', log_file
);
292 /* readchar -- read a character from the remote system, doing all the fancy
301 c
= SERIAL_READCHAR(array_desc
, abs(timeout
));
303 if (sr_get_debug() > 5) {
305 debuglogs (5, "readchar: timeout = %d\n", timeout
);
310 putc(c
& 0x7f, log_file
);
316 if (c
== SERIAL_TIMEOUT
) {
318 return c
; /* Polls shouldn't generate timeout errors */
319 error("Timeout reading from remote system.");
321 fputs ("ERROR: Timeout reading from remote system", log_file
);
324 perror_with_name("readchar");
328 * expect -- scan input from the remote system, until STRING is found.
329 * If DISCARD is non-zero, then discard non-matching input, else print
330 * it out. Let the user break out immediately.
333 expect (string
, discard
)
341 debuglogs (1, "Expecting \"%s\".", string
);
345 c
= readchar(timeout
);
351 debuglogs (4, "Matched");
356 fputc_unfiltered (c
, gdb_stdout
);
363 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
365 The convention for dealing with the expect_prompt is that you
367 o *then* wait for the expect_prompt.
369 Thus the last thing that a procedure does with the serial line
370 will be an expect_prompt(). Exception: array_resume does not
371 wait for the expect_prompt, because the terminal is being handed over
372 to the inferior. However, the next thing which happens after that
373 is a array_wait which does wait for the expect_prompt.
374 Note that this includes abnormal exit, e.g. error(). This is
375 necessary to prevent getting into states from which we can't
378 expect_prompt(discard
)
381 expect (expect_prompt
, discard
);
385 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
398 if (sr_get_debug() > 5)
399 debuglogs (5, "Ignoring \'%c\'.", ch
);
402 if (sr_get_debug() > 5)
403 debuglogs (5, "Accepting \'%c\'.", ch
);
409 * get_hex_digit -- Get a hex digit from the remote system & return its value.
410 * If ignore is nonzero, ignore spaces, newline & tabs.
413 get_hex_digit(ignore
)
418 ch
= readchar(timeout
);
421 if (sr_get_debug() > 4) {
422 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
424 #ifdef LOG_FILE /* write to the monitor log */
425 if (log_file
!= 0x0) {
426 fputs ("get_hex_digit() got a 0x", log_file
);
427 fputc (ch
, log_file
);
428 fputc ('\n', log_file
);
434 if (ch
>= '0' && ch
<= '9')
436 else if (ch
>= 'A' && ch
<= 'F')
437 return ch
- 'A' + 10;
438 else if (ch
>= 'a' && ch
<= 'f')
439 return ch
- 'a' + 10;
440 else if (ch
== ' ' && ignore
)
444 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
445 error("Invalid hex digit from remote system. (0x%x)", ch
);
450 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
451 * Accept any number leading spaces.
459 val
= get_hex_digit (1) << 4;
460 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
462 val
|= get_hex_digit (0);
463 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
466 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
470 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
471 * and put them in registers starting at REGNO.
482 if (HOST_BYTE_ORDER
== BIG_ENDIAN
) {
484 for (i
= 0; i
< 8; i
++)
485 val
= (val
<< 4) + get_hex_digit (i
== 0);
488 for (i
= 7; i
>= 0; i
--)
489 val
= (val
<< 4) + get_hex_digit (i
== 0);
493 debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val
, (HOST_BYTE_ORDER
== BIG_ENDIAN
) ? "big endian" : "little endian");
498 /* This is called not only when we first attach, but also when the
499 user types "run" after having attached. */
501 array_create_inferior (execfile
, args
, env
)
509 error("Can't pass arguments to remote MONITOR process");
511 if (execfile
== 0 || exec_bfd
== 0)
512 error("No exec file specified");
514 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
516 /* The "process" (board) is already stopped awaiting our commands, and
517 the program is already downloaded. We just set its PC and go. */
519 clear_proceed_status ();
521 /* Tell wait_for_inferior that we've started a new process. */
522 init_wait_for_inferior ();
524 /* Set up the "saved terminal modes" of the inferior
525 based on what modes we are starting it with. */
526 target_terminal_init ();
528 /* Install inferior's terminal modes. */
529 target_terminal_inferior ();
531 /* insert_step_breakpoint (); FIXME, do we need this? */
534 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
538 * array_open -- open a connection to a remote debugger.
539 * NAME is the filename used for communication.
541 static int baudrate
= 9600;
542 static char dev_name
[100];
545 array_open(args
, name
, from_tty
)
550 char packet
[PBUFSIZ
];
553 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
554 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
559 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
560 mips_set_processor_type_command ("lsi33k", 0);
562 strcpy(dev_name
, args
);
563 array_desc
= SERIAL_OPEN(dev_name
);
565 if (array_desc
== NULL
)
566 perror_with_name(dev_name
);
568 if (baud_rate
!= -1) {
569 if (SERIAL_SETBAUDRATE (array_desc
, baud_rate
)) {
570 SERIAL_CLOSE (array_desc
);
571 perror_with_name (name
);
575 SERIAL_RAW(array_desc
);
577 #if defined (LOG_FILE)
578 log_file
= fopen (LOG_FILE
, "w");
579 if (log_file
== NULL
)
580 perror_with_name (LOG_FILE
);
581 fprintf_filtered (log_file
, "GDB %s (%s", version
);
582 fprintf_filtered (log_file
, " --target %s)\n", array_ops
.to_shortname
);
583 fprintf_filtered (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
586 /* see if the target is alive. For a ROM monitor, we can just try to force the
587 expect_prompt to print a few times. For the GDB remote protocol, the application
588 being debugged is sitting at a breakpoint and waiting for GDB to initialize
589 the connection. We force it to give us an empty packet to see if it's alive.
591 debuglogs (3, "Trying to ACK the target's debug stub");
592 /* unless your are on the new hardware, the old board won't initialize
593 because the '+' doesn't flush output like it does on the new ROMS.
595 printf_monitor ("+"); /* ask for the last signal */
596 expect_prompt(1); /* See if we get a expect_prompt */
597 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
598 if (array_send_packet (packet
) == 0)
599 error ("Couldn't transmit packet\n");
600 printf_monitor ("+\n"); /* force it to flush stdout */
601 expect_prompt(1); /* See if we get a expect_prompt */
604 printf("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
608 * array_close -- Close out all files and local state before this
609 * target loses control.
613 array_close (quitting
)
616 SERIAL_CLOSE(array_desc
);
619 debuglogs (1, "array_close (quitting=%d)", quitting
);
621 #if defined (LOG_FILE)
623 if (ferror(log_file
))
624 printf_filtered ("Error writing log file.\n");
625 if (fclose(log_file
) != 0)
626 printf_filtered ("Error closing log file.\n");
632 * array_detach -- terminate the open connection to the remote
633 * debugger. Use this when you want to detach and do something
634 * else with your gdb.
637 array_detach (from_tty
)
641 debuglogs (1, "array_detach ()");
643 pop_target(); /* calls array_close to do the real work */
645 printf ("Ending remote %s debugging\n", target_shortname
);
649 * array_attach -- attach GDB to the target.
652 array_attach (args
, from_tty
)
657 printf ("Starting remote %s debugging\n", target_shortname
);
659 debuglogs (1, "array_attach (args=%s)", args
);
661 printf_monitor ("go %x\n");
662 /* swallow the echo. */
663 expect ("go %x\n", 1);
667 * array_resume -- Tell the remote machine to resume.
670 array_resume (pid
, step
, sig
)
672 enum target_signal sig
;
674 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
677 printf_monitor ("s\n");
679 printf_monitor ("go");
684 * array_wait -- Wait until the remote machine stops, then return,
685 * storing status in status just as `wait' would.
688 array_wait (pid
, status
)
690 struct target_waitstatus
*status
;
692 int old_timeout
= timeout
;
694 debuglogs(1, "array_wait (), printing extraneous text.");
696 status
->kind
= TARGET_WAITKIND_EXITED
;
697 status
->value
.integer
= 0;
699 timeout
= 0; /* Don't time out -- user program is running. */
701 expect_prompt(0); /* Wait for expect_prompt, outputting extraneous text */
702 debuglogs (4, "array_wait(), got the expect_prompt.");
704 status
->kind
= TARGET_WAITKIND_STOPPED
;
705 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
709 timeout
= old_timeout
;
715 * array_fetch_registers -- read the remote registers into the
719 array_fetch_registers (ignored
)
724 unsigned char packet
[PBUFSIZ
];
725 char regs
[REGISTER_BYTES
];
727 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
729 memset (packet
, 0, PBUFSIZ
);
730 /* Unimplemented registers read as all bits zero. */
731 memset (regs
, 0, REGISTER_BYTES
);
732 make_gdb_packet (packet
, "g");
733 if (array_send_packet (packet
) == 0)
734 error ("Couldn't transmit packet\n");
735 if (array_get_packet (packet
) == 0)
736 error ("Couldn't receive packet\n");
737 /* FIXME: read bytes from packet */
738 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
739 for (regno
= 0; regno
<= PC_REGNUM
+4; regno
++) {
740 /* supply register stores in target byte order, so swap here */
741 /* FIXME: convert from ASCII hex to raw bytes */
742 i
= ascii2hexword (packet
+ (regno
* 8));
743 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
744 SWAP_TARGET_AND_HOST (&i
, 4);
745 supply_register (regno
, (char *)&i
);
750 * This is unused by targets like this one that use a
751 * protocol based on GDB's remote protocol.
754 array_fetch_register (ignored
)
757 array_fetch_registers ();
761 * Get all the registers from the targets. They come back in a large array.
764 array_store_registers (ignored
)
769 char packet
[PBUFSIZ
];
773 debuglogs (1, "array_store_registers()");
775 memset (packet
, 0, PBUFSIZ
);
776 memset (buf
, 0, PBUFSIZ
);
779 /* Unimplemented registers read as all bits zero. */
780 /* FIXME: read bytes from packet */
781 for (regno
= 0; regno
< 41; regno
++) { /* FIXME */
782 /* supply register stores in target byte order, so swap here */
783 /* FIXME: convert from ASCII hex to raw bytes */
784 i
= (unsigned long)read_register (regno
);
785 hexword2ascii (num
, i
);
786 strcpy (buf
+(regno
* 8)+1, num
);
788 *(buf
+ (regno
* 8) + 2) = 0;
789 make_gdb_packet (packet
, buf
);
790 if (array_send_packet (packet
) == 0)
791 error ("Couldn't transmit packet\n");
792 if (array_get_packet (packet
) == 0)
793 error ("Couldn't receive packet\n");
795 registers_changed ();
799 * This is unused by targets like this one that use a
800 * protocol based on GDB's remote protocol.
803 array_store_register (ignored
)
806 array_store_registers ();
809 /* Get ready to modify the registers array. On machines which store
810 individual registers, this doesn't need to do anything. On machines
811 which store all the registers in one fell swoop, this makes sure
812 that registers contains all the registers from the program being
816 array_prepare_to_store ()
818 /* Do nothing, since we can store individual regs */
824 printf ("\tAttached to %s at %d baud.\n",
829 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
830 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
833 array_write_inferior_memory (memaddr
, myaddr
, len
)
835 unsigned char *myaddr
;
840 char packet
[PBUFSIZ
];
845 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
846 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
849 *p
++ = 'M'; /* The command to write memory */
850 hexword2ascii (num
, memaddr
); /* convert the address */
851 strcpy (p
, num
); /* copy the address */
853 *p
++ = ','; /* add comma delimeter */
854 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
859 *p
++ = ':'; /* add the colon delimeter */
860 for (j
= 0; j
< len
; j
++) { /* copy the data in after converting it */
861 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
862 *p
++ = tohex (myaddr
[j
] & 0xf);
865 make_gdb_packet (packet
, buf
);
866 if (array_send_packet (packet
) == 0)
867 error ("Couldn't transmit packet\n");
868 if (array_get_packet (packet
) == 0)
869 error ("Couldn't receive packet\n");
875 * array_read_inferior_memory -- read LEN bytes from inferior memory
876 * at MEMADDR. Put the result at debugger address MYADDR. Returns
880 array_read_inferior_memory(memaddr
, myaddr
, len
)
887 char packet
[PBUFSIZ
];
889 /* Number of bytes read so far. */
892 /* Starting address of this pass. */
893 unsigned long startaddr
;
895 /* Starting address of this pass. */
896 unsigned long endaddr
;
898 /* Number of bytes to read in this pass. */
901 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
903 /* Note that this code works correctly if startaddr is just less
904 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
905 thing). That is, something like
906 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
907 works--it never adds len To memaddr and gets 0. */
908 /* However, something like
909 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
910 doesn't need to work. Detect it and give up if there's an attempt
912 if (((memaddr
- 1) + len
) < memaddr
) {
919 while (count
< len
) {
921 if ((startaddr
% 16) != 0)
922 len_this_pass
-= startaddr
% 16;
923 if (len_this_pass
> (len
- count
))
924 len_this_pass
= (len
- count
);
926 debuglogs (3, "Display %d bytes at %x for Big Endian host", len_this_pass
, startaddr
);
928 for (i
= 0; i
< len_this_pass
; i
++) {
929 sprintf (buf
, "m%08x,%04x", startaddr
, len_this_pass
);
930 make_gdb_packet (packet
, buf
);
931 if (array_send_packet (packet
) == 0)
932 error ("Couldn't transmit packet\n");
933 if (array_get_packet (packet
) == 0)
934 error ("Couldn't receive packet\n");
936 error ("Got no data in the GDB packet\n");
937 debuglogs (4, "array_read_inferior: Got a \"%s\" back\n", packet
);
938 for (j
= 0; j
< len_this_pass
; j
++) { /* extract the byte values */
939 myaddr
[count
++] = from_hex (*(packet
+(j
*2))) * 16 + from_hex (*(packet
+(j
*2)+1));
940 debuglogs (5, "myaddr set to %x\n", myaddr
[count
-1]);
949 /* FIXME-someday! merge these two. */
951 array_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
956 struct target_ops
*target
; /* ignored */
959 return array_write_inferior_memory (memaddr
, myaddr
, len
);
961 return array_read_inferior_memory (memaddr
, myaddr
, len
);
965 array_kill (args
, from_tty
)
969 return; /* ignore attempts to kill target system */
972 /* Clean up when a program exits.
973 The program actually lives on in the remote processor's RAM, and may be
974 run again without a download. Don't leave it full of breakpoint
978 array_mourn_inferior ()
980 remove_breakpoints ();
981 generic_mourn_inferior (); /* Do all the proper things now */
984 #define MAX_ARRAY_BREAKPOINTS 16
986 extern int memory_breakpoint_size
;
987 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] = {0};
990 * array_insert_breakpoint -- add a breakpoint
993 array_insert_breakpoint (addr
, shadow
)
999 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1001 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++) {
1002 if (breakaddr
[i
] == 0) {
1003 breakaddr
[i
] = addr
;
1004 if (sr_get_debug() > 4)
1005 printf ("Breakpoint at %x\n", addr
);
1006 array_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
1007 printf_monitor("brk 0x%x\n", addr
);
1013 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
1018 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1021 array_remove_breakpoint (addr
, shadow
)
1027 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1029 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++) {
1030 if (breakaddr
[i
] == addr
) {
1032 /* some monitors remove breakpoints based on the address */
1033 printf_monitor("unbrk %x\n", i
);
1038 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1045 debuglogs (1, "array_stop()");
1046 printf_monitor("\003");
1051 * array_command -- put a command string, in args, out to MONITOR.
1052 * Output from MONITOR is placed on the users terminal until the
1053 * expect_prompt is seen. FIXME
1056 monitor_command (args
, fromtty
)
1060 debuglogs (1, "monitor_command (args=%s)", args
);
1062 if (array_desc
== NULL
)
1063 error("monitor target not open.");
1066 error("Missing command.");
1068 printf_monitor ("%s\n", args
);
1073 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1074 * A debug packet whose contents are <data>
1075 * is encapsulated for transmission in the form:
1077 * $ <data> # CSUM1 CSUM2
1079 * <data> must be ASCII alphanumeric and cannot include characters
1080 * '$' or '#'. If <data> starts with two characters followed by
1081 * ':', then the existing stubs interpret this as a sequence number.
1083 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1084 * checksum of <data>, the most significant nibble is sent first.
1085 * the hex digits 0-9,a-f are used.
1089 make_gdb_packet (buf
, data
)
1093 unsigned char csum
= 0;
1097 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1098 cnt
= strlen (data
);
1100 error ("make_gdb_packet(): to much data\n");
1102 /* start with the packet header */
1106 /* calculate the checksum */
1107 for (i
= 0; i
< cnt
; i
++) {
1112 /* terminate the data with a '#' */
1115 /* add the checksum as two ascii digits */
1116 *p
++ = tohex ((csum
>> 4) & 0xf);
1117 *p
++ = tohex (csum
& 0xf);
1118 *p
= 0x0; /* Null terminator on string */
1122 * array_send_packet -- send a GDB packet to the target with error handling. We
1123 * get a '+' (ACK) back if the packet is received and the checksum
1124 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1125 * successful transmition, or a 0 for a failure.
1128 array_send_packet (packet
)
1137 /* scan the packet to make sure it only contains valid characters.
1138 this may sound silly, but sometimes a garbled packet will hang
1139 the target board. We scan the whole thing, then print the error
1142 for (i
= 0; i
< strlen(packet
); i
++) {
1143 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1144 /* legit hex numbers or command */
1145 if ((isxdigit(packet
[i
])) || (isalpha(packet
[i
])))
1147 switch (packet
[i
]) {
1150 case '#': /* end of packet */
1151 case '$': /* start of packet */
1153 default: /* bogus character */
1155 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1161 error ("Can't send packet, found %d non-ascii characters", retries
);
1163 /* ok, try to send the packet */
1165 while (retries
++ <= 10) {
1166 printf_monitor ("%s", packet
);
1168 /* read until either a timeout occurs (-2) or '+' is read */
1169 while (retries
<= 10) {
1170 c
= readchar (-timeout
);
1171 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1174 debuglogs (3, "Got Ack\n");
1176 case SERIAL_TIMEOUT
:
1177 debuglogs (3, "Timed out reading serial port\n");
1178 printf_monitor("+"); /* resync with the monitor */
1179 expect_prompt(1); /* See if we get a expect_prompt */
1180 break; /* Retransmit buffer */
1182 debuglogs (3, "Got NAK\n");
1183 printf_monitor("+"); /* resync with the monitor */
1184 expect_prompt(1); /* See if we get a expect_prompt */
1187 /* it's probably an old response, or the echo of our command.
1188 * just gobble up the packet and ignore it.
1190 debuglogs (3, "Got a junk packet\n");
1193 c
= readchar (timeout
);
1196 c
= readchar (timeout
);
1198 c
= readchar (timeout
);
1201 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1202 continue; /* Now, go look for next packet */
1207 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1208 break; /* Here to retransmit */
1215 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1216 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1217 * packet, or a 0 it the packet wasn't transmitted correctly.
1220 array_get_packet (packet
)
1226 unsigned char pktcsum
;
1232 memset (packet
, 1, PBUFSIZ
);
1234 while (retries
<= 10) {
1236 c
= readchar (timeout
);
1237 if (c
== SERIAL_TIMEOUT
) {
1238 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1240 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1244 while (retries
<= 10) {
1245 c
= readchar (timeout
);
1246 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1248 case SERIAL_TIMEOUT
:
1249 debuglogs (3, "Timeout in mid-packet, retrying\n");
1252 debuglogs (3, "Saw new packet start in middle of old one\n");
1253 return 0; /* Start a new packet, count retries */
1256 pktcsum
= from_hex (readchar (timeout
)) << 4;
1257 pktcsum
|= from_hex (readchar (timeout
));
1259 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1260 if (csum
== pktcsum
) {
1261 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1262 printf_monitor ("+");
1266 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1268 case '*': /* Run length encoding */
1269 debuglogs (5, "Run length encoding in packet\n");
1271 c
= readchar (timeout
);
1273 c
= c
- ' ' + 3; /* Compute repeat count */
1275 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1) {
1276 memset (bp
, *(bp
- 1), c
);
1281 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1285 if ((!isxdigit(c
)) && (!ispunct(c
)))
1286 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1287 if (bp
< packet
+ PBUFSIZ
- 1) {
1294 puts_filtered ("Remote packet too long.\n");
1302 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1304 static unsigned long
1313 for (i
= 0; i
< 8; i
++) {
1315 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1316 val
= val
+ mem
[i
] - 'A' + 10;
1317 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1318 val
= val
+ mem
[i
] - 'a' + 10;
1319 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1320 val
= val
+ mem
[i
] - '0';
1324 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1329 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1333 hexword2ascii (mem
, num
)
1340 debuglogs (4, "hexword2ascii() converting %x ", num
);
1341 for (i
= 7; i
>= 0; i
--) {
1342 mem
[i
] = tohex ((num
>> 4) & 0xf);
1343 mem
[i
] = tohex (num
& 0xf);
1347 debuglogs (4, "\tto a %s", mem
);
1350 /* Convert hex digit A to a number. */
1358 debuglogs (4, "from_hex got a 0x%x(%c)\n",a
,a
);
1359 if (a
>= '0' && a
<= '9')
1361 if (a
>= 'a' && a
<= 'f')
1362 return a
- 'a' + 10;
1363 if (a
>= 'A' && a
<= 'F')
1364 return a
- 'A' + 10;
1366 error ("Reply contains invalid hex digit 0x%x", a
);
1370 /* Convert number NIB to a hex digit. */
1382 * _initialize_remote_monitors -- setup a few addtitional commands that
1383 * are usually only used by monitors.
1386 _initialize_remote_monitors ()
1388 /* generic monitor command */
1389 add_com ("monitor", class_obscure
, monitor_command
,
1390 "Send a command to the debug monitor.");
1395 * _initialize_array -- do any special init stuff for the target.
1398 _initialize_array ()
1400 add_target (&array_ops
);
1401 baud_rate
= 4800; /* this is the only supported baud rate */
This page took 0.061948 seconds and 5 git commands to generate.