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.
31 #ifdef ANSI_PROTOTYPES
37 #include "gdb_string.h"
38 #include <sys/types.h>
42 #include "remote-utils.h"
46 static const char hexchars
[]="0123456789abcdef";
47 static char *hex2mem();
51 #define SWAP_TARGET_AND_HOST(buffer,len) \
54 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
57 char *p = (char *)(buffer); \
58 char *q = ((char *)(buffer)) + len - 1; \
59 for (; p < q; p++, q--) \
69 static void debuglogs
PARAMS((int, char *, ...));
70 static void array_open();
71 static void array_close();
72 static void array_detach();
73 static void array_attach();
74 static void array_resume();
75 static void array_fetch_register();
76 static void array_store_register();
77 static void array_fetch_registers();
78 static void array_store_registers();
79 static void array_prepare_to_store();
80 static void array_files_info();
81 static void array_kill();
82 static void array_create_inferior();
83 static void array_mourn_inferior();
84 static void make_gdb_packet();
85 static int array_xfer_memory();
86 static int array_wait();
87 static int array_insert_breakpoint();
88 static int array_remove_breakpoint();
91 static int from_hex();
92 static int array_send_packet();
93 static int array_get_packet();
94 static unsigned long ascii2hexword();
95 static char *hexword2ascii();
99 #define LOG_FILE "monitor.log"
100 #if defined (LOG_FILE)
104 static int timeout
= 30;
105 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
106 and i386-stub.c. Normally, no one would notice because it only matters
107 for writing large chunks of memory (e.g. in downloads). Also, this needs
108 to be more than 400 if required to hold the registers (see below, where
109 we round it up based on REGISTER_BYTES). */
113 * Descriptor for I/O to remote machine. Initialize it to NULL so that
114 * array_open knows that we don't have a file open when the program starts.
116 serial_t array_desc
= NULL
;
119 * this array of registers need to match the indexes used by GDB. The
120 * whole reason this exists is cause the various ROM monitors use
121 * different strings than GDB does, and doesn't support all the
122 * registers either. So, typing "info reg sp" becomes a "r30".
124 extern char *tmp_mips_processor_type
;
125 extern int mips_set_processor_type();
127 static struct target_ops array_ops
= {
128 "array", /* to_shortname */
130 "Debug using the standard GDB remote protocol for the Array Tech target.",
132 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
133 Specify the serial device it is connected to (e.g. /dev/ttya).",
134 array_open
, /* to_open */
135 array_close
, /* to_close */
136 NULL
, /* to_attach */
137 array_detach
, /* to_detach */
138 array_resume
, /* to_resume */
139 array_wait
, /* to_wait */
140 array_fetch_registers
, /* to_fetch_registers */
141 array_store_registers
, /* to_store_registers */
142 array_prepare_to_store
, /* to_prepare_to_store */
143 array_xfer_memory
, /* to_xfer_memory */
144 array_files_info
, /* to_files_info */
145 array_insert_breakpoint
, /* to_insert_breakpoint */
146 array_remove_breakpoint
, /* to_remove_breakpoint */
147 0, /* to_terminal_init */
148 0, /* to_terminal_inferior */
149 0, /* to_terminal_ours_for_output */
150 0, /* to_terminal_ours */
151 0, /* to_terminal_info */
152 array_kill
, /* to_kill */
154 0, /* to_lookup_symbol */
155 array_create_inferior
, /* to_create_inferior */
156 array_mourn_inferior
, /* to_mourn_inferior */
158 0, /* to_notice_signals */
159 0, /* to_thread_alive */
161 process_stratum
, /* to_stratum */
163 1, /* to_has_all_memory */
164 1, /* to_has_memory */
165 1, /* to_has_stack */
166 1, /* to_has_registers */
167 1, /* to_has_execution */
169 0, /* sections_end */
170 OPS_MAGIC
/* to_magic */
174 * printf_monitor -- send data to monitor. Works just like printf.
177 #ifdef ANSI_PROTOTYPES
178 printf_monitor(char *pattern
, ...)
180 printf_monitor(va_alist
)
188 #ifdef ANSI_PROTOTYPES
189 va_start(args
, pattern
);
193 pattern
= va_arg(args
, char *);
196 vsprintf(buf
, pattern
, args
);
198 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
200 if (strlen(buf
) > PBUFSIZ
)
201 error ("printf_monitor(): string too long");
202 if (SERIAL_WRITE(array_desc
, buf
, strlen(buf
)))
203 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
206 * write_monitor -- send raw data to monitor.
209 write_monitor(data
, len
)
213 if (SERIAL_WRITE(array_desc
, data
, len
))
214 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
216 *(data
+ len
+1) = '\0';
217 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
222 * debuglogs -- deal with debugging info to multiple sources. This takes
223 * two real args, the first one is the level to be compared against
224 * the sr_get_debug() value, the second arg is a printf buffer and args
225 * to be formatted and printed. A CR is added after each string is printed.
228 #ifdef ANSI_PROTOTYPES
229 debuglogs(int level
, char *pattern
, ...)
237 unsigned char buf
[PBUFSIZ
];
238 char newbuf
[PBUFSIZ
];
241 #ifdef ANSI_PROTOTYPES
242 va_start(args
, pattern
);
247 level
= va_arg(args
, int); /* get the debug level */
248 pattern
= va_arg(args
, char *); /* get the printf style pattern */
251 if ((level
<0) || (level
> 100)) {
252 error ("Bad argument passed to debuglogs(), needs debug level");
256 vsprintf(buf
, pattern
, args
); /* format the string */
258 /* convert some characters so it'll look right in the log */
260 for (i
= 0 ; buf
[i
] != '\0'; i
++) {
262 error ("Debug message too long");
264 case '\n': /* newlines */
268 case '\r': /* carriage returns */
272 case '\033': /* escape */
280 case '\b': /* backspace */
284 default: /* no change */
288 if (buf
[i
] < 26) { /* modify control characters */
293 if (buf
[i
] >= 128) { /* modify control characters */
299 *p
= '\0'; /* terminate the string */
301 if (sr_get_debug() > level
)
302 printf_unfiltered ("%s\n", newbuf
);
304 #ifdef LOG_FILE /* write to the monitor log */
305 if (log_file
!= 0x0) {
306 fputs (newbuf
, log_file
);
307 fputc ('\n', log_file
);
313 /* readchar -- read a character from the remote system, doing all the fancy
322 c
= SERIAL_READCHAR(array_desc
, abs(timeout
));
324 if (sr_get_debug() > 5) {
326 debuglogs (5, "readchar: timeout = %d\n", timeout
);
331 putc(c
& 0x7f, log_file
);
337 if (c
== SERIAL_TIMEOUT
) {
339 return c
; /* Polls shouldn't generate timeout errors */
340 error("Timeout reading from remote system.");
342 fputs ("ERROR: Timeout reading from remote system", log_file
);
345 perror_with_name("readchar");
349 * expect -- scan input from the remote system, until STRING is found.
350 * If DISCARD is non-zero, then discard non-matching input, else print
351 * it out. Let the user break out immediately.
354 expect (string
, discard
)
362 debuglogs (1, "Expecting \"%s\".", string
);
366 c
= readchar(timeout
);
372 debuglogs (4, "Matched");
377 fputc_unfiltered (c
, gdb_stdout
);
384 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
386 The convention for dealing with the expect_prompt is that you
388 o *then* wait for the expect_prompt.
390 Thus the last thing that a procedure does with the serial line
391 will be an expect_prompt(). Exception: array_resume does not
392 wait for the expect_prompt, because the terminal is being handed over
393 to the inferior. However, the next thing which happens after that
394 is a array_wait which does wait for the expect_prompt.
395 Note that this includes abnormal exit, e.g. error(). This is
396 necessary to prevent getting into states from which we can't
399 expect_prompt(discard
)
402 expect (expect_prompt
, discard
);
406 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
419 if (sr_get_debug() > 5)
420 debuglogs (5, "Ignoring \'%c\'.", ch
);
423 if (sr_get_debug() > 5)
424 debuglogs (5, "Accepting \'%c\'.", ch
);
430 * get_hex_digit -- Get a hex digit from the remote system & return its value.
431 * If ignore is nonzero, ignore spaces, newline & tabs.
434 get_hex_digit(ignore
)
439 ch
= readchar(timeout
);
442 if (sr_get_debug() > 4) {
443 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
445 #ifdef LOG_FILE /* write to the monitor log */
446 if (log_file
!= 0x0) {
447 fputs ("get_hex_digit() got a 0x", log_file
);
448 fputc (ch
, log_file
);
449 fputc ('\n', log_file
);
455 if (ch
>= '0' && ch
<= '9')
457 else if (ch
>= 'A' && ch
<= 'F')
458 return ch
- 'A' + 10;
459 else if (ch
>= 'a' && ch
<= 'f')
460 return ch
- 'a' + 10;
461 else if (ch
== ' ' && ignore
)
465 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
466 error("Invalid hex digit from remote system. (0x%x)", ch
);
471 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
472 * Accept any number leading spaces.
480 val
= get_hex_digit (1) << 4;
481 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
483 val
|= get_hex_digit (0);
484 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
487 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
491 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
492 * and put them in registers starting at REGNO.
503 if (HOST_BYTE_ORDER
== BIG_ENDIAN
) {
505 for (i
= 0; i
< 8; i
++)
506 val
= (val
<< 4) + get_hex_digit (i
== 0);
509 for (i
= 7; i
>= 0; i
--)
510 val
= (val
<< 4) + get_hex_digit (i
== 0);
514 debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val
, (HOST_BYTE_ORDER
== BIG_ENDIAN
) ? "big endian" : "little endian");
519 /* This is called not only when we first attach, but also when the
520 user types "run" after having attached. */
522 array_create_inferior (execfile
, args
, env
)
530 error("Can't pass arguments to remote MONITOR process");
532 if (execfile
== 0 || exec_bfd
== 0)
533 error("No exec file specified");
535 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
537 /* The "process" (board) is already stopped awaiting our commands, and
538 the program is already downloaded. We just set its PC and go. */
540 clear_proceed_status ();
542 /* Tell wait_for_inferior that we've started a new process. */
543 init_wait_for_inferior ();
545 /* Set up the "saved terminal modes" of the inferior
546 based on what modes we are starting it with. */
547 target_terminal_init ();
549 /* Install inferior's terminal modes. */
550 target_terminal_inferior ();
552 /* insert_step_breakpoint (); FIXME, do we need this? */
555 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
559 * array_open -- open a connection to a remote debugger.
560 * NAME is the filename used for communication.
562 static int baudrate
= 9600;
563 static char dev_name
[100];
566 array_open(args
, name
, from_tty
)
571 char packet
[PBUFSIZ
];
574 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
575 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
580 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
581 mips_set_processor_type_command ("lsi33k", 0);
583 strcpy(dev_name
, args
);
584 array_desc
= SERIAL_OPEN(dev_name
);
586 if (array_desc
== NULL
)
587 perror_with_name(dev_name
);
589 if (baud_rate
!= -1) {
590 if (SERIAL_SETBAUDRATE (array_desc
, baud_rate
)) {
591 SERIAL_CLOSE (array_desc
);
592 perror_with_name (name
);
596 SERIAL_RAW(array_desc
);
598 #if defined (LOG_FILE)
599 log_file
= fopen (LOG_FILE
, "w");
600 if (log_file
== NULL
)
601 perror_with_name (LOG_FILE
);
602 fprintf_filtered (log_file
, "GDB %s (%s", version
);
603 fprintf_filtered (log_file
, " --target %s)\n", array_ops
.to_shortname
);
604 fprintf_filtered (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
607 /* see if the target is alive. For a ROM monitor, we can just try to force the
608 expect_prompt to print a few times. For the GDB remote protocol, the application
609 being debugged is sitting at a breakpoint and waiting for GDB to initialize
610 the connection. We force it to give us an empty packet to see if it's alive.
612 debuglogs (3, "Trying to ACK the target's debug stub");
613 /* unless your are on the new hardware, the old board won't initialize
614 because the '+' doesn't flush output like it does on the new ROMS.
616 printf_monitor ("+"); /* ask for the last signal */
617 expect_prompt(1); /* See if we get a expect_prompt */
618 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
619 if (array_send_packet (packet
) == 0)
620 error ("Couldn't transmit packet\n");
621 printf_monitor ("+\n"); /* force it to flush stdout */
622 expect_prompt(1); /* See if we get a expect_prompt */
625 printf("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
629 * array_close -- Close out all files and local state before this
630 * target loses control.
634 array_close (quitting
)
637 SERIAL_CLOSE(array_desc
);
640 debuglogs (1, "array_close (quitting=%d)", quitting
);
642 #if defined (LOG_FILE)
644 if (ferror(log_file
))
645 printf_filtered ("Error writing log file.\n");
646 if (fclose(log_file
) != 0)
647 printf_filtered ("Error closing log file.\n");
653 * array_detach -- terminate the open connection to the remote
654 * debugger. Use this when you want to detach and do something
655 * else with your gdb.
658 array_detach (from_tty
)
662 debuglogs (1, "array_detach ()");
664 pop_target(); /* calls array_close to do the real work */
666 printf ("Ending remote %s debugging\n", target_shortname
);
670 * array_attach -- attach GDB to the target.
673 array_attach (args
, from_tty
)
678 printf ("Starting remote %s debugging\n", target_shortname
);
680 debuglogs (1, "array_attach (args=%s)", args
);
682 printf_monitor ("go %x\n");
683 /* swallow the echo. */
684 expect ("go %x\n", 1);
688 * array_resume -- Tell the remote machine to resume.
691 array_resume (pid
, step
, sig
)
693 enum target_signal sig
;
695 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
698 printf_monitor ("s\n");
700 printf_monitor ("go");
705 * array_wait -- Wait until the remote machine stops, then return,
706 * storing status in status just as `wait' would.
709 array_wait (pid
, status
)
711 struct target_waitstatus
*status
;
713 int old_timeout
= timeout
;
715 debuglogs(1, "array_wait (), printing extraneous text.");
717 status
->kind
= TARGET_WAITKIND_EXITED
;
718 status
->value
.integer
= 0;
720 timeout
= 0; /* Don't time out -- user program is running. */
722 expect_prompt(0); /* Wait for expect_prompt, outputting extraneous text */
723 debuglogs (4, "array_wait(), got the expect_prompt.");
725 status
->kind
= TARGET_WAITKIND_STOPPED
;
726 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
730 timeout
= old_timeout
;
736 * array_fetch_registers -- read the remote registers into the
740 array_fetch_registers (ignored
)
745 unsigned char packet
[PBUFSIZ
];
746 char regs
[REGISTER_BYTES
];
748 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
750 memset (packet
, 0, PBUFSIZ
);
751 /* Unimplemented registers read as all bits zero. */
752 memset (regs
, 0, REGISTER_BYTES
);
753 make_gdb_packet (packet
, "g");
754 if (array_send_packet (packet
) == 0)
755 error ("Couldn't transmit packet\n");
756 if (array_get_packet (packet
) == 0)
757 error ("Couldn't receive packet\n");
758 /* FIXME: read bytes from packet */
759 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
760 for (regno
= 0; regno
<= PC_REGNUM
+4; regno
++) {
761 /* supply register stores in target byte order, so swap here */
762 /* FIXME: convert from ASCII hex to raw bytes */
763 i
= ascii2hexword (packet
+ (regno
* 8));
764 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
765 SWAP_TARGET_AND_HOST (&i
, 4);
766 supply_register (regno
, (char *)&i
);
771 * This is unused by targets like this one that use a
772 * protocol based on GDB's remote protocol.
775 array_fetch_register (ignored
)
778 array_fetch_registers ();
782 * Get all the registers from the targets. They come back in a large array.
785 array_store_registers (ignored
)
790 char packet
[PBUFSIZ
];
794 debuglogs (1, "array_store_registers()");
796 memset (packet
, 0, PBUFSIZ
);
797 memset (buf
, 0, PBUFSIZ
);
800 /* Unimplemented registers read as all bits zero. */
801 /* FIXME: read bytes from packet */
802 for (regno
= 0; regno
< 41; regno
++) { /* FIXME */
803 /* supply register stores in target byte order, so swap here */
804 /* FIXME: convert from ASCII hex to raw bytes */
805 i
= (unsigned long)read_register (regno
);
806 hexword2ascii (num
, i
);
807 strcpy (buf
+(regno
* 8)+1, num
);
809 *(buf
+ (regno
* 8) + 2) = 0;
810 make_gdb_packet (packet
, buf
);
811 if (array_send_packet (packet
) == 0)
812 error ("Couldn't transmit packet\n");
813 if (array_get_packet (packet
) == 0)
814 error ("Couldn't receive packet\n");
816 registers_changed ();
820 * This is unused by targets like this one that use a
821 * protocol based on GDB's remote protocol.
824 array_store_register (ignored
)
827 array_store_registers ();
830 /* Get ready to modify the registers array. On machines which store
831 individual registers, this doesn't need to do anything. On machines
832 which store all the registers in one fell swoop, this makes sure
833 that registers contains all the registers from the program being
837 array_prepare_to_store ()
839 /* Do nothing, since we can store individual regs */
845 printf ("\tAttached to %s at %d baud.\n",
850 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
851 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
854 array_write_inferior_memory (memaddr
, myaddr
, len
)
856 unsigned char *myaddr
;
861 char packet
[PBUFSIZ
];
866 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
867 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
870 *p
++ = 'M'; /* The command to write memory */
871 hexword2ascii (num
, memaddr
); /* convert the address */
872 strcpy (p
, num
); /* copy the address */
874 *p
++ = ','; /* add comma delimeter */
875 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
880 *p
++ = ':'; /* add the colon delimeter */
881 for (j
= 0; j
< len
; j
++) { /* copy the data in after converting it */
882 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
883 *p
++ = tohex (myaddr
[j
] & 0xf);
886 make_gdb_packet (packet
, buf
);
887 if (array_send_packet (packet
) == 0)
888 error ("Couldn't transmit packet\n");
889 if (array_get_packet (packet
) == 0)
890 error ("Couldn't receive packet\n");
896 * array_read_inferior_memory -- read LEN bytes from inferior memory
897 * at MEMADDR. Put the result at debugger address MYADDR. Returns
901 array_read_inferior_memory(memaddr
, myaddr
, len
)
908 char packet
[PBUFSIZ
];
910 /* Number of bytes read so far. */
913 /* Starting address of this pass. */
914 unsigned long startaddr
;
916 /* Starting address of this pass. */
917 unsigned long endaddr
;
919 /* Number of bytes to read in this pass. */
922 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
924 /* Note that this code works correctly if startaddr is just less
925 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
926 thing). That is, something like
927 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
928 works--it never adds len To memaddr and gets 0. */
929 /* However, something like
930 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
931 doesn't need to work. Detect it and give up if there's an attempt
933 if (((memaddr
- 1) + len
) < memaddr
) {
940 while (count
< len
) {
942 if ((startaddr
% 16) != 0)
943 len_this_pass
-= startaddr
% 16;
944 if (len_this_pass
> (len
- count
))
945 len_this_pass
= (len
- count
);
947 debuglogs (3, "Display %d bytes at %x for Big Endian host", len_this_pass
, startaddr
);
949 for (i
= 0; i
< len_this_pass
; i
++) {
950 sprintf (buf
, "m%08x,%04x", startaddr
, len_this_pass
);
951 make_gdb_packet (packet
, buf
);
952 if (array_send_packet (packet
) == 0)
953 error ("Couldn't transmit packet\n");
954 if (array_get_packet (packet
) == 0)
955 error ("Couldn't receive packet\n");
957 error ("Got no data in the GDB packet\n");
958 debuglogs (4, "array_read_inferior: Got a \"%s\" back\n", packet
);
959 for (j
= 0; j
< len_this_pass
; j
++) { /* extract the byte values */
960 myaddr
[count
++] = from_hex (*(packet
+(j
*2))) * 16 + from_hex (*(packet
+(j
*2)+1));
961 debuglogs (5, "myaddr set to %x\n", myaddr
[count
-1]);
970 /* FIXME-someday! merge these two. */
972 array_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
977 struct target_ops
*target
; /* ignored */
980 return array_write_inferior_memory (memaddr
, myaddr
, len
);
982 return array_read_inferior_memory (memaddr
, myaddr
, len
);
986 array_kill (args
, from_tty
)
990 return; /* ignore attempts to kill target system */
993 /* Clean up when a program exits.
994 The program actually lives on in the remote processor's RAM, and may be
995 run again without a download. Don't leave it full of breakpoint
999 array_mourn_inferior ()
1001 remove_breakpoints ();
1002 generic_mourn_inferior (); /* Do all the proper things now */
1005 #define MAX_ARRAY_BREAKPOINTS 16
1007 extern int memory_breakpoint_size
;
1008 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] = {0};
1011 * array_insert_breakpoint -- add a breakpoint
1014 array_insert_breakpoint (addr
, shadow
)
1020 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1022 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++) {
1023 if (breakaddr
[i
] == 0) {
1024 breakaddr
[i
] = addr
;
1025 if (sr_get_debug() > 4)
1026 printf ("Breakpoint at %x\n", addr
);
1027 array_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
1028 printf_monitor("brk 0x%x\n", addr
);
1034 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
1039 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1042 array_remove_breakpoint (addr
, shadow
)
1048 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1050 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++) {
1051 if (breakaddr
[i
] == addr
) {
1053 /* some monitors remove breakpoints based on the address */
1054 printf_monitor("unbrk %x\n", i
);
1059 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1066 debuglogs (1, "array_stop()");
1067 printf_monitor("\003");
1072 * array_command -- put a command string, in args, out to MONITOR.
1073 * Output from MONITOR is placed on the users terminal until the
1074 * expect_prompt is seen. FIXME
1077 monitor_command (args
, fromtty
)
1081 debuglogs (1, "monitor_command (args=%s)", args
);
1083 if (array_desc
== NULL
)
1084 error("monitor target not open.");
1087 error("Missing command.");
1089 printf_monitor ("%s\n", args
);
1094 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1095 * A debug packet whose contents are <data>
1096 * is encapsulated for transmission in the form:
1098 * $ <data> # CSUM1 CSUM2
1100 * <data> must be ASCII alphanumeric and cannot include characters
1101 * '$' or '#'. If <data> starts with two characters followed by
1102 * ':', then the existing stubs interpret this as a sequence number.
1104 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1105 * checksum of <data>, the most significant nibble is sent first.
1106 * the hex digits 0-9,a-f are used.
1110 make_gdb_packet (buf
, data
)
1114 unsigned char csum
= 0;
1118 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1119 cnt
= strlen (data
);
1121 error ("make_gdb_packet(): to much data\n");
1123 /* start with the packet header */
1127 /* calculate the checksum */
1128 for (i
= 0; i
< cnt
; i
++) {
1133 /* terminate the data with a '#' */
1136 /* add the checksum as two ascii digits */
1137 *p
++ = tohex ((csum
>> 4) & 0xf);
1138 *p
++ = tohex (csum
& 0xf);
1139 *p
= 0x0; /* Null terminator on string */
1143 * array_send_packet -- send a GDB packet to the target with error handling. We
1144 * get a '+' (ACK) back if the packet is received and the checksum
1145 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1146 * successful transmition, or a 0 for a failure.
1149 array_send_packet (packet
)
1158 /* scan the packet to make sure it only contains valid characters.
1159 this may sound silly, but sometimes a garbled packet will hang
1160 the target board. We scan the whole thing, then print the error
1163 for (i
= 0; i
< strlen(packet
); i
++) {
1164 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1165 /* legit hex numbers or command */
1166 if ((isxdigit(packet
[i
])) || (isalpha(packet
[i
])))
1168 switch (packet
[i
]) {
1171 case '#': /* end of packet */
1172 case '$': /* start of packet */
1174 default: /* bogus character */
1176 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1182 error ("Can't send packet, found %d non-ascii characters", retries
);
1184 /* ok, try to send the packet */
1186 while (retries
++ <= 10) {
1187 printf_monitor ("%s", packet
);
1189 /* read until either a timeout occurs (-2) or '+' is read */
1190 while (retries
<= 10) {
1191 c
= readchar (-timeout
);
1192 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1195 debuglogs (3, "Got Ack\n");
1197 case SERIAL_TIMEOUT
:
1198 debuglogs (3, "Timed out reading serial port\n");
1199 printf_monitor("+"); /* resync with the monitor */
1200 expect_prompt(1); /* See if we get a expect_prompt */
1201 break; /* Retransmit buffer */
1203 debuglogs (3, "Got NAK\n");
1204 printf_monitor("+"); /* resync with the monitor */
1205 expect_prompt(1); /* See if we get a expect_prompt */
1208 /* it's probably an old response, or the echo of our command.
1209 * just gobble up the packet and ignore it.
1211 debuglogs (3, "Got a junk packet\n");
1214 c
= readchar (timeout
);
1217 c
= readchar (timeout
);
1219 c
= readchar (timeout
);
1222 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1223 continue; /* Now, go look for next packet */
1228 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1229 break; /* Here to retransmit */
1236 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1237 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1238 * packet, or a 0 it the packet wasn't transmitted correctly.
1241 array_get_packet (packet
)
1247 unsigned char pktcsum
;
1253 memset (packet
, 1, PBUFSIZ
);
1255 while (retries
<= 10) {
1257 c
= readchar (timeout
);
1258 if (c
== SERIAL_TIMEOUT
) {
1259 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1261 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1265 while (retries
<= 10) {
1266 c
= readchar (timeout
);
1267 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1269 case SERIAL_TIMEOUT
:
1270 debuglogs (3, "Timeout in mid-packet, retrying\n");
1273 debuglogs (3, "Saw new packet start in middle of old one\n");
1274 return 0; /* Start a new packet, count retries */
1277 pktcsum
= from_hex (readchar (timeout
)) << 4;
1278 pktcsum
|= from_hex (readchar (timeout
));
1280 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1281 if (csum
== pktcsum
) {
1282 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1283 printf_monitor ("+");
1287 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1289 case '*': /* Run length encoding */
1290 debuglogs (5, "Run length encoding in packet\n");
1292 c
= readchar (timeout
);
1294 c
= c
- ' ' + 3; /* Compute repeat count */
1296 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1) {
1297 memset (bp
, *(bp
- 1), c
);
1302 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1306 if ((!isxdigit(c
)) && (!ispunct(c
)))
1307 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1308 if (bp
< packet
+ PBUFSIZ
- 1) {
1315 puts_filtered ("Remote packet too long.\n");
1323 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1325 static unsigned long
1334 for (i
= 0; i
< 8; i
++) {
1336 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1337 val
= val
+ mem
[i
] - 'A' + 10;
1338 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1339 val
= val
+ mem
[i
] - 'a' + 10;
1340 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1341 val
= val
+ mem
[i
] - '0';
1345 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1350 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1354 hexword2ascii (mem
, num
)
1361 debuglogs (4, "hexword2ascii() converting %x ", num
);
1362 for (i
= 7; i
>= 0; i
--) {
1363 mem
[i
] = tohex ((num
>> 4) & 0xf);
1364 mem
[i
] = tohex (num
& 0xf);
1368 debuglogs (4, "\tto a %s", mem
);
1371 /* Convert hex digit A to a number. */
1379 debuglogs (4, "from_hex got a 0x%x(%c)\n",a
,a
);
1380 if (a
>= '0' && a
<= '9')
1382 if (a
>= 'a' && a
<= 'f')
1383 return a
- 'a' + 10;
1384 if (a
>= 'A' && a
<= 'F')
1385 return a
- 'A' + 10;
1387 error ("Reply contains invalid hex digit 0x%x", a
);
1391 /* Convert number NIB to a hex digit. */
1403 * _initialize_remote_monitors -- setup a few addtitional commands that
1404 * are usually only used by monitors.
1407 _initialize_remote_monitors ()
1409 /* generic monitor command */
1410 add_com ("monitor", class_obscure
, monitor_command
,
1411 "Send a command to the debug monitor.");
1416 * _initialize_array -- do any special init stuff for the target.
1419 _initialize_array ()
1421 add_target (&array_ops
);
1422 baud_rate
= 4800; /* this is the only supported baud rate */
This page took 0.058037 seconds and 4 git commands to generate.