0ed84cade2c37db40d82752fe9ff56c48d20a4c9
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 #ifdef ANSI_PROTOTYPES
37 #include <sys/types.h>
38 #include "gdb_string.h"
42 #include "remote-utils.h"
46 #define ARRAY_PROMPT ">> "
48 #define SWAP_TARGET_AND_HOST(buffer,len) \
51 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
54 char *p = (char *)(buffer); \
55 char *q = ((char *)(buffer)) + len - 1; \
56 for (; p < q; p++, q--) \
66 static void debuglogs
PARAMS((int, char *, ...));
67 static void array_open();
68 static void array_close();
69 static void array_detach();
70 static void array_attach();
71 static void array_resume();
72 static void array_fetch_register();
73 static void array_store_register();
74 static void array_fetch_registers();
75 static void array_store_registers();
76 static void array_prepare_to_store();
77 static void array_files_info();
78 static void array_kill();
79 static void array_create_inferior();
80 static void array_mourn_inferior();
81 static void make_gdb_packet();
82 static int array_xfer_memory();
83 static int array_wait();
84 static int array_insert_breakpoint();
85 static int array_remove_breakpoint();
88 static int from_hex();
89 static int array_send_packet();
90 static int array_get_packet();
91 static unsigned long ascii2hexword();
92 static char *hexword2ascii();
96 #define LOG_FILE "monitor.log"
97 #if defined (LOG_FILE)
101 static int timeout
= 30;
102 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
103 and i386-stub.c. Normally, no one would notice because it only matters
104 for writing large chunks of memory (e.g. in downloads). Also, this needs
105 to be more than 400 if required to hold the registers (see below, where
106 we round it up based on REGISTER_BYTES). */
110 * Descriptor for I/O to remote machine. Initialize it to NULL so that
111 * array_open knows that we don't have a file open when the program starts.
113 serial_t array_desc
= NULL
;
116 * this array of registers need to match the indexes used by GDB. The
117 * whole reason this exists is cause the various ROM monitors use
118 * different strings than GDB does, and doesn't support all the
119 * registers either. So, typing "info reg sp" becomes a "r30".
121 extern char *tmp_mips_processor_type
;
122 extern int mips_set_processor_type();
124 static struct target_ops array_ops
= {
125 "array", /* to_shortname */
127 "Debug using the standard GDB remote protocol for the Array Tech target.",
129 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
130 Specify the serial device it is connected to (e.g. /dev/ttya).",
131 array_open
, /* to_open */
132 array_close
, /* to_close */
133 NULL
, /* to_attach */
134 array_detach
, /* to_detach */
135 array_resume
, /* to_resume */
136 array_wait
, /* to_wait */
137 array_fetch_registers
, /* to_fetch_registers */
138 array_store_registers
, /* to_store_registers */
139 array_prepare_to_store
, /* to_prepare_to_store */
140 array_xfer_memory
, /* to_xfer_memory */
141 array_files_info
, /* to_files_info */
142 array_insert_breakpoint
, /* to_insert_breakpoint */
143 array_remove_breakpoint
, /* to_remove_breakpoint */
144 0, /* to_terminal_init */
145 0, /* to_terminal_inferior */
146 0, /* to_terminal_ours_for_output */
147 0, /* to_terminal_ours */
148 0, /* to_terminal_info */
149 array_kill
, /* to_kill */
151 0, /* to_lookup_symbol */
152 array_create_inferior
, /* to_create_inferior */
153 array_mourn_inferior
, /* to_mourn_inferior */
155 0, /* to_notice_signals */
156 0, /* to_thread_alive */
158 process_stratum
, /* to_stratum */
160 1, /* to_has_all_memory */
161 1, /* to_has_memory */
162 1, /* to_has_stack */
163 1, /* to_has_registers */
164 1, /* to_has_execution */
166 0, /* sections_end */
167 OPS_MAGIC
/* to_magic */
171 * printf_monitor -- send data to monitor. Works just like printf.
174 #ifdef ANSI_PROTOTYPES
175 printf_monitor(char *pattern
, ...)
177 printf_monitor(va_alist
)
185 #ifdef ANSI_PROTOTYPES
186 va_start(args
, pattern
);
190 pattern
= va_arg(args
, char *);
193 vsprintf(buf
, pattern
, args
);
195 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
197 if (strlen(buf
) > PBUFSIZ
)
198 error ("printf_monitor(): string too long");
199 if (SERIAL_WRITE(array_desc
, buf
, strlen(buf
)))
200 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
203 * write_monitor -- send raw data to monitor.
206 write_monitor(data
, len
)
210 if (SERIAL_WRITE(array_desc
, data
, len
))
211 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
213 *(data
+ len
+1) = '\0';
214 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
219 * debuglogs -- deal with debugging info to multiple sources. This takes
220 * two real args, the first one is the level to be compared against
221 * the sr_get_debug() value, the second arg is a printf buffer and args
222 * to be formatted and printed. A CR is added after each string is printed.
225 #ifdef ANSI_PROTOTYPES
226 debuglogs(int level
, char *pattern
, ...)
234 unsigned char buf
[PBUFSIZ
];
235 char newbuf
[PBUFSIZ
];
238 #ifdef ANSI_PROTOTYPES
239 va_start(args
, pattern
);
244 level
= va_arg(args
, int); /* get the debug level */
245 pattern
= va_arg(args
, char *); /* get the printf style pattern */
248 if ((level
<0) || (level
> 100)) {
249 error ("Bad argument passed to debuglogs(), needs debug level");
253 vsprintf(buf
, pattern
, args
); /* format the string */
255 /* convert some characters so it'll look right in the log */
257 for (i
= 0 ; buf
[i
] != '\0'; i
++) {
259 error ("Debug message too long");
261 case '\n': /* newlines */
265 case '\r': /* carriage returns */
269 case '\033': /* escape */
277 case '\b': /* backspace */
281 default: /* no change */
285 if (buf
[i
] < 26) { /* modify control characters */
290 if (buf
[i
] >= 128) { /* modify control characters */
296 *p
= '\0'; /* terminate the string */
298 if (sr_get_debug() > level
)
299 printf_unfiltered ("%s\n", newbuf
);
301 #ifdef LOG_FILE /* write to the monitor log */
302 if (log_file
!= 0x0) {
303 fputs (newbuf
, log_file
);
304 fputc ('\n', log_file
);
310 /* readchar -- read a character from the remote system, doing all the fancy
319 c
= SERIAL_READCHAR(array_desc
, abs(timeout
));
321 if (sr_get_debug() > 5) {
323 debuglogs (5, "readchar: timeout = %d\n", timeout
);
328 putc(c
& 0x7f, log_file
);
334 if (c
== SERIAL_TIMEOUT
) {
336 return c
; /* Polls shouldn't generate timeout errors */
337 error("Timeout reading from remote system.");
339 fputs ("ERROR: Timeout reading from remote system", log_file
);
342 perror_with_name("readchar");
346 * expect -- scan input from the remote system, until STRING is found.
347 * If DISCARD is non-zero, then discard non-matching input, else print
348 * it out. Let the user break out immediately.
351 expect (string
, discard
)
359 debuglogs (1, "Expecting \"%s\".", string
);
363 c
= readchar(timeout
);
369 debuglogs (4, "Matched");
374 fputc_unfiltered (c
, gdb_stdout
);
381 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
383 The convention for dealing with the expect_prompt is that you
385 o *then* wait for the expect_prompt.
387 Thus the last thing that a procedure does with the serial line
388 will be an expect_prompt(). Exception: array_resume does not
389 wait for the expect_prompt, because the terminal is being handed over
390 to the inferior. However, the next thing which happens after that
391 is a array_wait which does wait for the expect_prompt.
392 Note that this includes abnormal exit, e.g. error(). This is
393 necessary to prevent getting into states from which we can't
396 expect_prompt(discard
)
399 expect (ARRAY_PROMPT
, discard
);
403 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
416 if (sr_get_debug() > 5)
417 debuglogs (5, "Ignoring \'%c\'.", ch
);
420 if (sr_get_debug() > 5)
421 debuglogs (5, "Accepting \'%c\'.", ch
);
427 * get_hex_digit -- Get a hex digit from the remote system & return its value.
428 * If ignore is nonzero, ignore spaces, newline & tabs.
431 get_hex_digit(ignore
)
436 ch
= readchar(timeout
);
439 if (sr_get_debug() > 4) {
440 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
442 #ifdef LOG_FILE /* write to the monitor log */
443 if (log_file
!= 0x0) {
444 fputs ("get_hex_digit() got a 0x", log_file
);
445 fputc (ch
, log_file
);
446 fputc ('\n', log_file
);
452 if (ch
>= '0' && ch
<= '9')
454 else if (ch
>= 'A' && ch
<= 'F')
455 return ch
- 'A' + 10;
456 else if (ch
>= 'a' && ch
<= 'f')
457 return ch
- 'a' + 10;
458 else if (ch
== ' ' && ignore
)
462 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
463 error("Invalid hex digit from remote system. (0x%x)", ch
);
468 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
469 * Accept any number leading spaces.
477 val
= get_hex_digit (1) << 4;
478 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
480 val
|= get_hex_digit (0);
481 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
484 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
488 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
489 * and put them in registers starting at REGNO.
500 if (HOST_BYTE_ORDER
== BIG_ENDIAN
) {
502 for (i
= 0; i
< 8; i
++)
503 val
= (val
<< 4) + get_hex_digit (i
== 0);
506 for (i
= 7; i
>= 0; i
--)
507 val
= (val
<< 4) + get_hex_digit (i
== 0);
511 debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val
, (HOST_BYTE_ORDER
== BIG_ENDIAN
) ? "big endian" : "little endian");
516 /* This is called not only when we first attach, but also when the
517 user types "run" after having attached. */
519 array_create_inferior (execfile
, args
, env
)
527 error("Can't pass arguments to remote MONITOR process");
529 if (execfile
== 0 || exec_bfd
== 0)
530 error("No exec file specified");
532 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
534 /* The "process" (board) is already stopped awaiting our commands, and
535 the program is already downloaded. We just set its PC and go. */
537 clear_proceed_status ();
539 /* Tell wait_for_inferior that we've started a new process. */
540 init_wait_for_inferior ();
542 /* Set up the "saved terminal modes" of the inferior
543 based on what modes we are starting it with. */
544 target_terminal_init ();
546 /* Install inferior's terminal modes. */
547 target_terminal_inferior ();
549 /* insert_step_breakpoint (); FIXME, do we need this? */
552 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
556 * array_open -- open a connection to a remote debugger.
557 * NAME is the filename used for communication.
559 static int baudrate
= 9600;
560 static char dev_name
[100];
563 array_open(args
, name
, from_tty
)
568 char packet
[PBUFSIZ
];
571 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
572 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
577 target_preopen (from_tty
);
578 unpush_target (&array_ops
);
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 #ifdef TEST_ARRAY /* skip packet for testing */
619 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
620 if (array_send_packet (packet
) == 0)
621 error ("Couldn't transmit packet\n");
622 printf_monitor ("@\n"); /* force it to flush stdout */
623 expect_prompt(1); /* See if we get a expect_prompt */
625 push_target (&array_ops
);
627 printf("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
631 * array_close -- Close out all files and local state before this
632 * target loses control.
636 array_close (quitting
)
639 SERIAL_CLOSE(array_desc
);
642 debuglogs (1, "array_close (quitting=%d)", quitting
);
644 #if defined (LOG_FILE)
646 if (ferror(log_file
))
647 printf_filtered ("Error writing log file.\n");
648 if (fclose(log_file
) != 0)
649 printf_filtered ("Error closing log file.\n");
655 * array_detach -- terminate the open connection to the remote
656 * debugger. Use this when you want to detach and do something
657 * else with your gdb.
660 array_detach (from_tty
)
664 debuglogs (1, "array_detach ()");
666 pop_target(); /* calls array_close to do the real work */
668 printf ("Ending remote %s debugging\n", target_shortname
);
672 * array_attach -- attach GDB to the target.
675 array_attach (args
, from_tty
)
680 printf ("Starting remote %s debugging\n", target_shortname
);
682 debuglogs (1, "array_attach (args=%s)", args
);
684 printf_monitor ("go %x\n");
685 /* swallow the echo. */
686 expect ("go %x\n", 1);
690 * array_resume -- Tell the remote machine to resume.
693 array_resume (pid
, step
, sig
)
695 enum target_signal sig
;
697 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
700 printf_monitor ("s\n");
702 printf_monitor ("go\n");
709 * array_wait -- Wait until the remote machine stops, then return,
710 * storing status in status just as `wait' would.
713 array_wait (pid
, status
)
715 struct target_waitstatus
*status
;
717 int old_timeout
= timeout
;
721 serial_ttystate ttystate
;
723 debuglogs(1, "array_wait (), printing extraneous text.");
725 status
->kind
= TARGET_WAITKIND_EXITED
;
726 status
->value
.integer
= 0;
728 timeout
= 0; /* Don't time out -- user program is running. */
730 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(__WIN32__)
731 tty_desc
= SERIAL_FDOPEN (0);
732 ttystate
= SERIAL_GET_TTY_STATE (tty_desc
);
733 SERIAL_RAW (tty_desc
);
736 /* poll on the serial port and the keyboard. */
738 c
= readchar(timeout
);
740 if (c
== *(ARRAY_PROMPT
+ i
)) {
741 if (++i
>= strlen (ARRAY_PROMPT
)) { /* matched the prompt */
742 debuglogs (4, "array_wait(), got the expect_prompt.");
745 } else { /* not the prompt */
748 fputc_unfiltered (c
, gdb_stdout
);
751 c
= SERIAL_READCHAR(tty_desc
, timeout
);
753 SERIAL_WRITE(array_desc
, &c
, 1);
754 /* do this so it looks like there's keyboard echo */
755 if (c
== 3) /* exit on Control-C */
758 fputc_unfiltered (c
, gdb_stdout
);
763 SERIAL_SET_TTY_STATE (tty_desc
, ttystate
);
766 debuglogs (4, "array_wait(), got the expect_prompt.");
769 status
->kind
= TARGET_WAITKIND_STOPPED
;
770 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
772 timeout
= old_timeout
;
778 * array_fetch_registers -- read the remote registers into the
782 array_fetch_registers (ignored
)
787 unsigned char packet
[PBUFSIZ
];
788 char regs
[REGISTER_BYTES
];
790 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
792 memset (packet
, 0, PBUFSIZ
);
793 /* Unimplemented registers read as all bits zero. */
794 memset (regs
, 0, REGISTER_BYTES
);
795 make_gdb_packet (packet
, "g");
796 if (array_send_packet (packet
) == 0)
797 error ("Couldn't transmit packet\n");
798 if (array_get_packet (packet
) == 0)
799 error ("Couldn't receive packet\n");
800 /* FIXME: read bytes from packet */
801 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
802 for (regno
= 0; regno
<= PC_REGNUM
+4; regno
++) {
803 /* supply register stores in target byte order, so swap here */
804 /* FIXME: convert from ASCII hex to raw bytes */
805 i
= ascii2hexword (packet
+ (regno
* 8));
806 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
807 SWAP_TARGET_AND_HOST (&i
, 4);
808 supply_register (regno
, (char *)&i
);
813 * This is unused by targets like this one that use a
814 * protocol based on GDB's remote protocol.
817 array_fetch_register (ignored
)
820 array_fetch_registers ();
824 * Get all the registers from the targets. They come back in a large array.
827 array_store_registers (ignored
)
832 char packet
[PBUFSIZ
];
836 debuglogs (1, "array_store_registers()");
838 memset (packet
, 0, PBUFSIZ
);
839 memset (buf
, 0, PBUFSIZ
);
842 /* Unimplemented registers read as all bits zero. */
843 /* FIXME: read bytes from packet */
844 for (regno
= 0; regno
< 41; regno
++) { /* FIXME */
845 /* supply register stores in target byte order, so swap here */
846 /* FIXME: convert from ASCII hex to raw bytes */
847 i
= (unsigned long)read_register (regno
);
848 hexword2ascii (num
, i
);
849 strcpy (buf
+(regno
* 8)+1, num
);
851 *(buf
+ (regno
* 8) + 2) = 0;
852 make_gdb_packet (packet
, buf
);
853 if (array_send_packet (packet
) == 0)
854 error ("Couldn't transmit packet\n");
855 if (array_get_packet (packet
) == 0)
856 error ("Couldn't receive packet\n");
858 registers_changed ();
862 * This is unused by targets like this one that use a
863 * protocol based on GDB's remote protocol.
866 array_store_register (ignored
)
869 array_store_registers ();
872 /* Get ready to modify the registers array. On machines which store
873 individual registers, this doesn't need to do anything. On machines
874 which store all the registers in one fell swoop, this makes sure
875 that registers contains all the registers from the program being
879 array_prepare_to_store ()
881 /* Do nothing, since we can store individual regs */
887 printf ("\tAttached to %s at %d baud.\n",
892 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
893 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
896 array_write_inferior_memory (memaddr
, myaddr
, len
)
898 unsigned char *myaddr
;
903 char packet
[PBUFSIZ
];
908 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
909 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
912 *p
++ = 'M'; /* The command to write memory */
913 hexword2ascii (num
, memaddr
); /* convert the address */
914 strcpy (p
, num
); /* copy the address */
916 *p
++ = ','; /* add comma delimeter */
917 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
922 *p
++ = ':'; /* add the colon delimeter */
923 for (j
= 0; j
< len
; j
++) { /* copy the data in after converting it */
924 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
925 *p
++ = tohex (myaddr
[j
] & 0xf);
928 make_gdb_packet (packet
, buf
);
929 if (array_send_packet (packet
) == 0)
930 error ("Couldn't transmit packet\n");
931 if (array_get_packet (packet
) == 0)
932 error ("Couldn't receive packet\n");
938 * array_read_inferior_memory -- read LEN bytes from inferior memory
939 * at MEMADDR. Put the result at debugger address MYADDR. Returns
943 array_read_inferior_memory(memaddr
, myaddr
, len
)
950 char packet
[PBUFSIZ
];
951 int count
; /* Number of bytes read so far. */
952 unsigned long startaddr
; /* Starting address of this pass. */
953 int len_this_pass
; /* Number of bytes to read in this pass. */
955 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
957 /* Note that this code works correctly if startaddr is just less
958 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
959 thing). That is, something like
960 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
961 works--it never adds len To memaddr and gets 0. */
962 /* However, something like
963 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
964 doesn't need to work. Detect it and give up if there's an attempt
966 if (((memaddr
- 1) + len
) < memaddr
) {
971 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
973 /* Try to align to 16 byte boundry (why?) */
975 if ((startaddr
% 16) != 0)
977 len_this_pass
-= startaddr
% 16;
979 /* Only transfer bytes we need */
980 if (len_this_pass
> (len
- count
))
982 len_this_pass
= (len
- count
);
984 /* Fetch the bytes */
985 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
987 sprintf (buf
, "m%08x,%04x", startaddr
, len_this_pass
);
988 make_gdb_packet (packet
, buf
);
989 if (array_send_packet (packet
) == 0)
991 error ("Couldn't transmit packet\n");
993 if (array_get_packet (packet
) == 0)
995 error ("Couldn't receive packet\n");
999 error ("Got no data in the GDB packet\n");
1001 /* Pick packet apart and xfer bytes to myaddr */
1002 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
1003 for (j
= 0; j
< len_this_pass
; j
++)
1005 /* extract the byte values */
1006 myaddr
[count
++] = from_hex (*(packet
+(j
*2))) * 16 + from_hex (*(packet
+(j
*2)+1));
1007 debuglogs (5, "myaddr[%d] set to %x\n", count
-1, myaddr
[count
-1]);
1013 /* FIXME-someday! merge these two. */
1015 array_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1020 struct target_ops
*target
; /* ignored */
1023 return array_write_inferior_memory (memaddr
, myaddr
, len
);
1025 return array_read_inferior_memory (memaddr
, myaddr
, len
);
1029 array_kill (args
, from_tty
)
1033 return; /* ignore attempts to kill target system */
1036 /* Clean up when a program exits.
1037 The program actually lives on in the remote processor's RAM, and may be
1038 run again without a download. Don't leave it full of breakpoint
1042 array_mourn_inferior ()
1044 remove_breakpoints ();
1045 generic_mourn_inferior (); /* Do all the proper things now */
1048 #define MAX_ARRAY_BREAKPOINTS 16
1050 extern int memory_breakpoint_size
;
1051 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] = {0};
1054 * array_insert_breakpoint -- add a breakpoint
1057 array_insert_breakpoint (addr
, shadow
)
1063 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1065 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++) {
1066 if (breakaddr
[i
] == 0) {
1067 breakaddr
[i
] = addr
;
1068 if (sr_get_debug() > 4)
1069 printf ("Breakpoint at %x\n", addr
);
1070 array_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
1071 printf_monitor("b 0x%x\n", addr
);
1077 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
1082 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1085 array_remove_breakpoint (addr
, shadow
)
1091 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1093 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++) {
1094 if (breakaddr
[i
] == addr
) {
1096 /* some monitors remove breakpoints based on the address */
1097 printf_monitor("bd %x\n", i
);
1102 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1109 debuglogs (1, "array_stop()");
1110 printf_monitor("\003");
1115 * array_command -- put a command string, in args, out to MONITOR.
1116 * Output from MONITOR is placed on the users terminal until the
1117 * expect_prompt is seen. FIXME
1120 monitor_command (args
, fromtty
)
1124 debuglogs (1, "monitor_command (args=%s)", args
);
1126 if (array_desc
== NULL
)
1127 error("monitor target not open.");
1130 error("Missing command.");
1132 printf_monitor ("%s\n", args
);
1137 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1138 * A debug packet whose contents are <data>
1139 * is encapsulated for transmission in the form:
1141 * $ <data> # CSUM1 CSUM2
1143 * <data> must be ASCII alphanumeric and cannot include characters
1144 * '$' or '#'. If <data> starts with two characters followed by
1145 * ':', then the existing stubs interpret this as a sequence number.
1147 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1148 * checksum of <data>, the most significant nibble is sent first.
1149 * the hex digits 0-9,a-f are used.
1153 make_gdb_packet (buf
, data
)
1157 unsigned char csum
= 0;
1161 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1162 cnt
= strlen (data
);
1164 error ("make_gdb_packet(): to much data\n");
1166 /* start with the packet header */
1170 /* calculate the checksum */
1171 for (i
= 0; i
< cnt
; i
++) {
1176 /* terminate the data with a '#' */
1179 /* add the checksum as two ascii digits */
1180 *p
++ = tohex ((csum
>> 4) & 0xf);
1181 *p
++ = tohex (csum
& 0xf);
1182 *p
= 0x0; /* Null terminator on string */
1186 * array_send_packet -- send a GDB packet to the target with error handling. We
1187 * get a '+' (ACK) back if the packet is received and the checksum
1188 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1189 * successful transmition, or a 0 for a failure.
1192 array_send_packet (packet
)
1201 /* scan the packet to make sure it only contains valid characters.
1202 this may sound silly, but sometimes a garbled packet will hang
1203 the target board. We scan the whole thing, then print the error
1206 for (i
= 0; i
< strlen(packet
); i
++) {
1207 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1208 /* legit hex numbers or command */
1209 if ((isxdigit(packet
[i
])) || (isalpha(packet
[i
])))
1211 switch (packet
[i
]) {
1214 case '#': /* end of packet */
1215 case '$': /* start of packet */
1217 default: /* bogus character */
1219 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1225 error ("Can't send packet, found %d non-ascii characters", retries
);
1227 /* ok, try to send the packet */
1229 while (retries
++ <= 10) {
1230 printf_monitor ("%s", packet
);
1232 /* read until either a timeout occurs (-2) or '+' is read */
1233 while (retries
<= 10) {
1234 c
= readchar (-timeout
);
1235 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1238 debuglogs (3, "Got Ack\n");
1240 case SERIAL_TIMEOUT
:
1241 debuglogs (3, "Timed out reading serial port\n");
1242 printf_monitor("@"); /* resync with the monitor */
1243 expect_prompt(1); /* See if we get a expect_prompt */
1244 break; /* Retransmit buffer */
1246 debuglogs (3, "Got NAK\n");
1247 printf_monitor("@"); /* resync with the monitor */
1248 expect_prompt(1); /* See if we get a expect_prompt */
1251 /* it's probably an old response, or the echo of our command.
1252 * just gobble up the packet and ignore it.
1254 debuglogs (3, "Got a junk packet\n");
1257 c
= readchar (timeout
);
1260 c
= readchar (timeout
);
1262 c
= readchar (timeout
);
1265 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1266 continue; /* Now, go look for next packet */
1271 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1272 break; /* Here to retransmit */
1279 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1280 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1281 * packet, or a 0 it the packet wasn't transmitted correctly.
1284 array_get_packet (packet
)
1290 unsigned char pktcsum
;
1296 memset (packet
, 1, PBUFSIZ
);
1298 while (retries
<= 10) {
1300 c
= readchar (timeout
);
1301 if (c
== SERIAL_TIMEOUT
) {
1302 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1304 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1308 while (retries
<= 10) {
1309 c
= readchar (timeout
);
1310 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1312 case SERIAL_TIMEOUT
:
1313 debuglogs (3, "Timeout in mid-packet, retrying\n");
1316 debuglogs (3, "Saw new packet start in middle of old one\n");
1317 return 0; /* Start a new packet, count retries */
1320 pktcsum
= from_hex (readchar (timeout
)) << 4;
1321 pktcsum
|= from_hex (readchar (timeout
));
1323 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1324 if (csum
== pktcsum
) {
1325 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1326 printf_monitor ("@");
1330 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1332 case '*': /* Run length encoding */
1333 debuglogs (5, "Run length encoding in packet\n");
1335 c
= readchar (timeout
);
1337 c
= c
- ' ' + 3; /* Compute repeat count */
1339 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1) {
1340 memset (bp
, *(bp
- 1), c
);
1345 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1349 if ((!isxdigit(c
)) && (!ispunct(c
)))
1350 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1351 if (bp
< packet
+ PBUFSIZ
- 1) {
1358 puts_filtered ("Remote packet too long.\n");
1366 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1368 static unsigned long
1377 for (i
= 0; i
< 8; i
++) {
1379 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1380 val
= val
+ mem
[i
] - 'A' + 10;
1381 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1382 val
= val
+ mem
[i
] - 'a' + 10;
1383 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1384 val
= val
+ mem
[i
] - '0';
1388 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1393 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1397 hexword2ascii (mem
, num
)
1404 debuglogs (4, "hexword2ascii() converting %x ", num
);
1405 for (i
= 7; i
>= 0; i
--) {
1406 mem
[i
] = tohex ((num
>> 4) & 0xf);
1407 mem
[i
] = tohex (num
& 0xf);
1411 debuglogs (4, "\tto a %s", mem
);
1414 /* Convert hex digit A to a number. */
1422 debuglogs (4, "from_hex got a 0x%x(%c)\n",a
,a
);
1423 if (a
>= '0' && a
<= '9')
1425 if (a
>= 'a' && a
<= 'f')
1426 return a
- 'a' + 10;
1427 if (a
>= 'A' && a
<= 'F')
1428 return a
- 'A' + 10;
1430 error ("Reply contains invalid hex digit 0x%x", a
);
1434 /* Convert number NIB to a hex digit. */
1446 * _initialize_remote_monitors -- setup a few addtitional commands that
1447 * are usually only used by monitors.
1450 _initialize_remote_monitors ()
1452 /* generic monitor command */
1453 add_com ("monitor", class_obscure
, monitor_command
,
1454 "Send a command to the debug monitor.");
1459 * _initialize_array -- do any special init stuff for the target.
1462 _initialize_array ()
1464 add_target (&array_ops
);
This page took 0.058354 seconds and 4 git commands to generate.