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
38 #include <sys/types.h>
39 #include "gdb_string.h"
43 #include "remote-utils.h"
47 #define ARRAY_PROMPT ">> "
49 #define SWAP_TARGET_AND_HOST(buffer,len) \
52 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
55 char *p = (char *)(buffer); \
56 char *q = ((char *)(buffer)) + len - 1; \
57 for (; p < q; p++, q--) \
67 static void debuglogs
PARAMS((int, char *, ...));
68 static void array_open();
69 static void array_close();
70 static void array_detach();
71 static void array_attach();
72 static void array_resume();
73 static void array_fetch_register();
74 static void array_store_register();
75 static void array_fetch_registers();
76 static void array_store_registers();
77 static void array_prepare_to_store();
78 static void array_files_info();
79 static void array_kill();
80 static void array_create_inferior();
81 static void array_mourn_inferior();
82 static void make_gdb_packet();
83 static int array_xfer_memory();
84 static int array_wait();
85 static int array_insert_breakpoint();
86 static int array_remove_breakpoint();
89 static int from_hex();
90 static int array_send_packet();
91 static int array_get_packet();
92 static unsigned long ascii2hexword();
93 static char *hexword2ascii();
97 #define LOG_FILE "monitor.log"
98 #if defined (LOG_FILE)
102 static int timeout
= 30;
103 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
104 and i386-stub.c. Normally, no one would notice because it only matters
105 for writing large chunks of memory (e.g. in downloads). Also, this needs
106 to be more than 400 if required to hold the registers (see below, where
107 we round it up based on REGISTER_BYTES). */
111 * Descriptor for I/O to remote machine. Initialize it to NULL so that
112 * array_open knows that we don't have a file open when the program starts.
114 serial_t array_desc
= NULL
;
117 * this array of registers need to match the indexes used by GDB. The
118 * whole reason this exists is cause the various ROM monitors use
119 * different strings than GDB does, and doesn't support all the
120 * registers either. So, typing "info reg sp" becomes a "r30".
122 extern char *tmp_mips_processor_type
;
123 extern int mips_set_processor_type();
125 static struct target_ops array_ops
= {
126 "array", /* to_shortname */
128 "Debug using the standard GDB remote protocol for the Array Tech target.",
130 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
131 Specify the serial device it is connected to (e.g. /dev/ttya).",
132 array_open
, /* to_open */
133 array_close
, /* to_close */
134 NULL
, /* to_attach */
135 array_detach
, /* to_detach */
136 array_resume
, /* to_resume */
137 array_wait
, /* to_wait */
138 array_fetch_registers
, /* to_fetch_registers */
139 array_store_registers
, /* to_store_registers */
140 array_prepare_to_store
, /* to_prepare_to_store */
141 array_xfer_memory
, /* to_xfer_memory */
142 array_files_info
, /* to_files_info */
143 array_insert_breakpoint
, /* to_insert_breakpoint */
144 array_remove_breakpoint
, /* to_remove_breakpoint */
145 0, /* to_terminal_init */
146 0, /* to_terminal_inferior */
147 0, /* to_terminal_ours_for_output */
148 0, /* to_terminal_ours */
149 0, /* to_terminal_info */
150 array_kill
, /* to_kill */
152 0, /* to_lookup_symbol */
153 array_create_inferior
, /* to_create_inferior */
154 array_mourn_inferior
, /* to_mourn_inferior */
156 0, /* to_notice_signals */
157 0, /* to_thread_alive */
159 process_stratum
, /* to_stratum */
161 1, /* to_has_all_memory */
162 1, /* to_has_memory */
163 1, /* to_has_stack */
164 1, /* to_has_registers */
165 1, /* to_has_execution */
167 0, /* sections_end */
168 OPS_MAGIC
/* to_magic */
172 * printf_monitor -- send data to monitor. Works just like printf.
175 #ifdef ANSI_PROTOTYPES
176 printf_monitor(char *pattern
, ...)
178 printf_monitor(va_alist
)
186 #ifdef ANSI_PROTOTYPES
187 va_start(args
, pattern
);
191 pattern
= va_arg(args
, char *);
194 vsprintf(buf
, pattern
, args
);
196 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
198 if (strlen(buf
) > PBUFSIZ
)
199 error ("printf_monitor(): string too long");
200 if (SERIAL_WRITE(array_desc
, buf
, strlen(buf
)))
201 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
204 * write_monitor -- send raw data to monitor.
207 write_monitor(data
, len
)
211 if (SERIAL_WRITE(array_desc
, data
, len
))
212 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
214 *(data
+ len
+1) = '\0';
215 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
220 * debuglogs -- deal with debugging info to multiple sources. This takes
221 * two real args, the first one is the level to be compared against
222 * the sr_get_debug() value, the second arg is a printf buffer and args
223 * to be formatted and printed. A CR is added after each string is printed.
226 #ifdef ANSI_PROTOTYPES
227 debuglogs(int level
, char *pattern
, ...)
235 unsigned char buf
[PBUFSIZ
];
236 char newbuf
[PBUFSIZ
];
239 #ifdef ANSI_PROTOTYPES
240 va_start(args
, pattern
);
245 level
= va_arg(args
, int); /* get the debug level */
246 pattern
= va_arg(args
, char *); /* get the printf style pattern */
249 if ((level
<0) || (level
> 100)) {
250 error ("Bad argument passed to debuglogs(), needs debug level");
254 vsprintf(buf
, pattern
, args
); /* format the string */
256 /* convert some characters so it'll look right in the log */
258 for (i
= 0 ; buf
[i
] != '\0'; i
++) {
260 error ("Debug message too long");
262 case '\n': /* newlines */
266 case '\r': /* carriage returns */
270 case '\033': /* escape */
278 case '\b': /* backspace */
282 default: /* no change */
286 if (buf
[i
] < 26) { /* modify control characters */
291 if (buf
[i
] >= 128) { /* modify control characters */
297 *p
= '\0'; /* terminate the string */
299 if (sr_get_debug() > level
)
300 printf_unfiltered ("%s\n", newbuf
);
302 #ifdef LOG_FILE /* write to the monitor log */
303 if (log_file
!= 0x0) {
304 fputs (newbuf
, log_file
);
305 fputc ('\n', log_file
);
311 /* readchar -- read a character from the remote system, doing all the fancy
320 c
= SERIAL_READCHAR(array_desc
, abs(timeout
));
322 if (sr_get_debug() > 5) {
324 debuglogs (5, "readchar: timeout = %d\n", timeout
);
329 putc(c
& 0x7f, log_file
);
335 if (c
== SERIAL_TIMEOUT
) {
337 return c
; /* Polls shouldn't generate timeout errors */
338 error("Timeout reading from remote system.");
340 fputs ("ERROR: Timeout reading from remote system", log_file
);
343 perror_with_name("readchar");
347 * expect -- scan input from the remote system, until STRING is found.
348 * If DISCARD is non-zero, then discard non-matching input, else print
349 * it out. Let the user break out immediately.
352 expect (string
, discard
)
360 debuglogs (1, "Expecting \"%s\".", string
);
364 c
= readchar(timeout
);
370 debuglogs (4, "Matched");
375 fputc_unfiltered (c
, gdb_stdout
);
382 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
384 The convention for dealing with the expect_prompt is that you
386 o *then* wait for the expect_prompt.
388 Thus the last thing that a procedure does with the serial line
389 will be an expect_prompt(). Exception: array_resume does not
390 wait for the expect_prompt, because the terminal is being handed over
391 to the inferior. However, the next thing which happens after that
392 is a array_wait which does wait for the expect_prompt.
393 Note that this includes abnormal exit, e.g. error(). This is
394 necessary to prevent getting into states from which we can't
397 expect_prompt(discard
)
400 expect (ARRAY_PROMPT
, discard
);
404 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
417 if (sr_get_debug() > 5)
418 debuglogs (5, "Ignoring \'%c\'.", ch
);
421 if (sr_get_debug() > 5)
422 debuglogs (5, "Accepting \'%c\'.", ch
);
428 * get_hex_digit -- Get a hex digit from the remote system & return its value.
429 * If ignore is nonzero, ignore spaces, newline & tabs.
432 get_hex_digit(ignore
)
437 ch
= readchar(timeout
);
440 if (sr_get_debug() > 4) {
441 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
443 #ifdef LOG_FILE /* write to the monitor log */
444 if (log_file
!= 0x0) {
445 fputs ("get_hex_digit() got a 0x", log_file
);
446 fputc (ch
, log_file
);
447 fputc ('\n', log_file
);
453 if (ch
>= '0' && ch
<= '9')
455 else if (ch
>= 'A' && ch
<= 'F')
456 return ch
- 'A' + 10;
457 else if (ch
>= 'a' && ch
<= 'f')
458 return ch
- 'a' + 10;
459 else if (ch
== ' ' && ignore
)
463 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
464 error("Invalid hex digit from remote system. (0x%x)", ch
);
469 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
470 * Accept any number leading spaces.
478 val
= get_hex_digit (1) << 4;
479 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
481 val
|= get_hex_digit (0);
482 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
485 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
489 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
490 * and put them in registers starting at REGNO.
501 if (HOST_BYTE_ORDER
== BIG_ENDIAN
) {
503 for (i
= 0; i
< 8; i
++)
504 val
= (val
<< 4) + get_hex_digit (i
== 0);
507 for (i
= 7; i
>= 0; i
--)
508 val
= (val
<< 4) + get_hex_digit (i
== 0);
512 debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val
, (HOST_BYTE_ORDER
== BIG_ENDIAN
) ? "big endian" : "little endian");
517 /* This is called not only when we first attach, but also when the
518 user types "run" after having attached. */
520 array_create_inferior (execfile
, args
, env
)
528 error("Can't pass arguments to remote MONITOR process");
530 if (execfile
== 0 || exec_bfd
== 0)
531 error("No exec file specified");
533 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
535 /* The "process" (board) is already stopped awaiting our commands, and
536 the program is already downloaded. We just set its PC and go. */
538 clear_proceed_status ();
540 /* Tell wait_for_inferior that we've started a new process. */
541 init_wait_for_inferior ();
543 /* Set up the "saved terminal modes" of the inferior
544 based on what modes we are starting it with. */
545 target_terminal_init ();
547 /* Install inferior's terminal modes. */
548 target_terminal_inferior ();
550 /* insert_step_breakpoint (); FIXME, do we need this? */
553 proceed ((CORE_ADDR
)entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
557 * array_open -- open a connection to a remote debugger.
558 * NAME is the filename used for communication.
560 static int baudrate
= 9600;
561 static char dev_name
[100];
564 array_open(args
, name
, from_tty
)
569 char packet
[PBUFSIZ
];
572 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
573 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
578 target_preopen (from_tty
);
579 unpush_target (&array_ops
);
581 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
582 mips_set_processor_type_command ("lsi33k", 0);
584 strcpy(dev_name
, args
);
585 array_desc
= SERIAL_OPEN(dev_name
);
587 if (array_desc
== NULL
)
588 perror_with_name(dev_name
);
590 if (baud_rate
!= -1) {
591 if (SERIAL_SETBAUDRATE (array_desc
, baud_rate
)) {
592 SERIAL_CLOSE (array_desc
);
593 perror_with_name (name
);
597 SERIAL_RAW(array_desc
);
599 #if defined (LOG_FILE)
600 log_file
= fopen (LOG_FILE
, "w");
601 if (log_file
== NULL
)
602 perror_with_name (LOG_FILE
);
603 fprintf_filtered (log_file
, "GDB %s (%s", version
);
604 fprintf_filtered (log_file
, " --target %s)\n", array_ops
.to_shortname
);
605 fprintf_filtered (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
608 /* see if the target is alive. For a ROM monitor, we can just try to force the
609 expect_prompt to print a few times. For the GDB remote protocol, the application
610 being debugged is sitting at a breakpoint and waiting for GDB to initialize
611 the connection. We force it to give us an empty packet to see if it's alive.
613 debuglogs (3, "Trying to ACK the target's debug stub");
614 /* unless your are on the new hardware, the old board won't initialize
615 because the '@' doesn't flush output like it does on the new ROMS.
617 printf_monitor ("@"); /* ask for the last signal */
618 expect_prompt(1); /* See if we get a expect_prompt */
619 #ifdef TEST_ARRAY /* skip packet for testing */
620 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
621 if (array_send_packet (packet
) == 0)
622 error ("Couldn't transmit packet\n");
623 printf_monitor ("@\n"); /* force it to flush stdout */
624 expect_prompt(1); /* See if we get a expect_prompt */
626 push_target (&array_ops
);
628 printf("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
632 * array_close -- Close out all files and local state before this
633 * target loses control.
637 array_close (quitting
)
640 SERIAL_CLOSE(array_desc
);
643 debuglogs (1, "array_close (quitting=%d)", quitting
);
645 #if defined (LOG_FILE)
647 if (ferror(log_file
))
648 printf_filtered ("Error writing log file.\n");
649 if (fclose(log_file
) != 0)
650 printf_filtered ("Error closing log file.\n");
656 * array_detach -- terminate the open connection to the remote
657 * debugger. Use this when you want to detach and do something
658 * else with your gdb.
661 array_detach (from_tty
)
665 debuglogs (1, "array_detach ()");
667 pop_target(); /* calls array_close to do the real work */
669 printf ("Ending remote %s debugging\n", target_shortname
);
673 * array_attach -- attach GDB to the target.
676 array_attach (args
, from_tty
)
681 printf ("Starting remote %s debugging\n", target_shortname
);
683 debuglogs (1, "array_attach (args=%s)", args
);
685 printf_monitor ("go %x\n");
686 /* swallow the echo. */
687 expect ("go %x\n", 1);
691 * array_resume -- Tell the remote machine to resume.
694 array_resume (pid
, step
, sig
)
696 enum target_signal sig
;
698 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
701 printf_monitor ("s\n");
703 printf_monitor ("go\n");
710 * array_wait -- Wait until the remote machine stops, then return,
711 * storing status in status just as `wait' would.
714 array_wait (pid
, status
)
716 struct target_waitstatus
*status
;
718 int old_timeout
= timeout
;
722 serial_ttystate ttystate
;
724 debuglogs(1, "array_wait (), printing extraneous text.");
726 status
->kind
= TARGET_WAITKIND_EXITED
;
727 status
->value
.integer
= 0;
729 timeout
= 0; /* Don't time out -- user program is running. */
731 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
732 tty_desc
= SERIAL_FDOPEN (0);
733 ttystate
= SERIAL_GET_TTY_STATE (tty_desc
);
734 SERIAL_RAW (tty_desc
);
737 /* poll on the serial port and the keyboard. */
739 c
= readchar(timeout
);
741 if (c
== *(ARRAY_PROMPT
+ i
)) {
742 if (++i
>= strlen (ARRAY_PROMPT
)) { /* matched the prompt */
743 debuglogs (4, "array_wait(), got the expect_prompt.");
746 } else { /* not the prompt */
749 fputc_unfiltered (c
, gdb_stdout
);
752 c
= SERIAL_READCHAR(tty_desc
, timeout
);
754 SERIAL_WRITE(array_desc
, &c
, 1);
755 /* do this so it looks like there's keyboard echo */
756 if (c
== 3) /* exit on Control-C */
759 fputc_unfiltered (c
, gdb_stdout
);
764 SERIAL_SET_TTY_STATE (tty_desc
, ttystate
);
767 debuglogs (4, "array_wait(), got the expect_prompt.");
770 status
->kind
= TARGET_WAITKIND_STOPPED
;
771 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
773 timeout
= old_timeout
;
779 * array_fetch_registers -- read the remote registers into the
783 array_fetch_registers (ignored
)
788 unsigned char packet
[PBUFSIZ
];
789 char regs
[REGISTER_BYTES
];
791 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
793 memset (packet
, 0, PBUFSIZ
);
794 /* Unimplemented registers read as all bits zero. */
795 memset (regs
, 0, REGISTER_BYTES
);
796 make_gdb_packet (packet
, "g");
797 if (array_send_packet (packet
) == 0)
798 error ("Couldn't transmit packet\n");
799 if (array_get_packet (packet
) == 0)
800 error ("Couldn't receive packet\n");
801 /* FIXME: read bytes from packet */
802 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
803 for (regno
= 0; regno
<= PC_REGNUM
+4; regno
++) {
804 /* supply register stores in target byte order, so swap here */
805 /* FIXME: convert from ASCII hex to raw bytes */
806 i
= ascii2hexword (packet
+ (regno
* 8));
807 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
808 SWAP_TARGET_AND_HOST (&i
, 4);
809 supply_register (regno
, (char *)&i
);
814 * This is unused by targets like this one that use a
815 * protocol based on GDB's remote protocol.
818 array_fetch_register (ignored
)
821 array_fetch_registers ();
825 * Get all the registers from the targets. They come back in a large array.
828 array_store_registers (ignored
)
833 char packet
[PBUFSIZ
];
837 debuglogs (1, "array_store_registers()");
839 memset (packet
, 0, PBUFSIZ
);
840 memset (buf
, 0, PBUFSIZ
);
843 /* Unimplemented registers read as all bits zero. */
844 /* FIXME: read bytes from packet */
845 for (regno
= 0; regno
< 41; regno
++) { /* FIXME */
846 /* supply register stores in target byte order, so swap here */
847 /* FIXME: convert from ASCII hex to raw bytes */
848 i
= (unsigned long)read_register (regno
);
849 hexword2ascii (num
, i
);
850 strcpy (buf
+(regno
* 8)+1, num
);
852 *(buf
+ (regno
* 8) + 2) = 0;
853 make_gdb_packet (packet
, buf
);
854 if (array_send_packet (packet
) == 0)
855 error ("Couldn't transmit packet\n");
856 if (array_get_packet (packet
) == 0)
857 error ("Couldn't receive packet\n");
859 registers_changed ();
863 * This is unused by targets like this one that use a
864 * protocol based on GDB's remote protocol.
867 array_store_register (ignored
)
870 array_store_registers ();
873 /* Get ready to modify the registers array. On machines which store
874 individual registers, this doesn't need to do anything. On machines
875 which store all the registers in one fell swoop, this makes sure
876 that registers contains all the registers from the program being
880 array_prepare_to_store ()
882 /* Do nothing, since we can store individual regs */
888 printf ("\tAttached to %s at %d baud.\n",
893 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
894 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
897 array_write_inferior_memory (memaddr
, myaddr
, len
)
899 unsigned char *myaddr
;
904 char packet
[PBUFSIZ
];
909 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
910 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
913 *p
++ = 'M'; /* The command to write memory */
914 hexword2ascii (num
, memaddr
); /* convert the address */
915 strcpy (p
, num
); /* copy the address */
917 *p
++ = ','; /* add comma delimeter */
918 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
923 *p
++ = ':'; /* add the colon delimeter */
924 for (j
= 0; j
< len
; j
++) { /* copy the data in after converting it */
925 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
926 *p
++ = tohex (myaddr
[j
] & 0xf);
929 make_gdb_packet (packet
, buf
);
930 if (array_send_packet (packet
) == 0)
931 error ("Couldn't transmit packet\n");
932 if (array_get_packet (packet
) == 0)
933 error ("Couldn't receive packet\n");
939 * array_read_inferior_memory -- read LEN bytes from inferior memory
940 * at MEMADDR. Put the result at debugger address MYADDR. Returns
944 array_read_inferior_memory(memaddr
, myaddr
, len
)
951 char packet
[PBUFSIZ
];
952 int count
; /* Number of bytes read so far. */
953 unsigned long startaddr
; /* Starting address of this pass. */
954 int len_this_pass
; /* Number of bytes to read in this pass. */
956 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
958 /* Note that this code works correctly if startaddr is just less
959 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
960 thing). That is, something like
961 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
962 works--it never adds len To memaddr and gets 0. */
963 /* However, something like
964 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
965 doesn't need to work. Detect it and give up if there's an attempt
967 if (((memaddr
- 1) + len
) < memaddr
) {
972 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
974 /* Try to align to 16 byte boundry (why?) */
976 if ((startaddr
% 16) != 0)
978 len_this_pass
-= startaddr
% 16;
980 /* Only transfer bytes we need */
981 if (len_this_pass
> (len
- count
))
983 len_this_pass
= (len
- count
);
985 /* Fetch the bytes */
986 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
988 sprintf (buf
, "m%08x,%04x", startaddr
, len_this_pass
);
989 make_gdb_packet (packet
, buf
);
990 if (array_send_packet (packet
) == 0)
992 error ("Couldn't transmit packet\n");
994 if (array_get_packet (packet
) == 0)
996 error ("Couldn't receive packet\n");
1000 error ("Got no data in the GDB packet\n");
1002 /* Pick packet apart and xfer bytes to myaddr */
1003 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
1004 for (j
= 0; j
< len_this_pass
; j
++)
1006 /* extract the byte values */
1007 myaddr
[count
++] = from_hex (*(packet
+(j
*2))) * 16 + from_hex (*(packet
+(j
*2)+1));
1008 debuglogs (5, "myaddr[%d] set to %x\n", count
-1, myaddr
[count
-1]);
1014 /* FIXME-someday! merge these two. */
1016 array_xfer_memory (memaddr
, myaddr
, len
, write
, target
)
1021 struct target_ops
*target
; /* ignored */
1024 return array_write_inferior_memory (memaddr
, myaddr
, len
);
1026 return array_read_inferior_memory (memaddr
, myaddr
, len
);
1030 array_kill (args
, from_tty
)
1034 return; /* ignore attempts to kill target system */
1037 /* Clean up when a program exits.
1038 The program actually lives on in the remote processor's RAM, and may be
1039 run again without a download. Don't leave it full of breakpoint
1043 array_mourn_inferior ()
1045 remove_breakpoints ();
1046 generic_mourn_inferior (); /* Do all the proper things now */
1049 #define MAX_ARRAY_BREAKPOINTS 16
1051 extern int memory_breakpoint_size
;
1052 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] = {0};
1055 * array_insert_breakpoint -- add a breakpoint
1058 array_insert_breakpoint (addr
, shadow
)
1064 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1066 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++) {
1067 if (breakaddr
[i
] == 0) {
1068 breakaddr
[i
] = addr
;
1069 if (sr_get_debug() > 4)
1070 printf ("Breakpoint at %x\n", addr
);
1071 array_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
1072 printf_monitor("b 0x%x\n", addr
);
1078 fprintf(stderr
, "Too many breakpoints (> 16) for monitor\n");
1083 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1086 array_remove_breakpoint (addr
, shadow
)
1092 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1094 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++) {
1095 if (breakaddr
[i
] == addr
) {
1097 /* some monitors remove breakpoints based on the address */
1098 printf_monitor("bd %x\n", i
);
1103 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1110 debuglogs (1, "array_stop()");
1111 printf_monitor("\003");
1116 * array_command -- put a command string, in args, out to MONITOR.
1117 * Output from MONITOR is placed on the users terminal until the
1118 * expect_prompt is seen. FIXME
1121 monitor_command (args
, fromtty
)
1125 debuglogs (1, "monitor_command (args=%s)", args
);
1127 if (array_desc
== NULL
)
1128 error("monitor target not open.");
1131 error("Missing command.");
1133 printf_monitor ("%s\n", args
);
1138 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1139 * A debug packet whose contents are <data>
1140 * is encapsulated for transmission in the form:
1142 * $ <data> # CSUM1 CSUM2
1144 * <data> must be ASCII alphanumeric and cannot include characters
1145 * '$' or '#'. If <data> starts with two characters followed by
1146 * ':', then the existing stubs interpret this as a sequence number.
1148 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1149 * checksum of <data>, the most significant nibble is sent first.
1150 * the hex digits 0-9,a-f are used.
1154 make_gdb_packet (buf
, data
)
1158 unsigned char csum
= 0;
1162 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1163 cnt
= strlen (data
);
1165 error ("make_gdb_packet(): to much data\n");
1167 /* start with the packet header */
1171 /* calculate the checksum */
1172 for (i
= 0; i
< cnt
; i
++) {
1177 /* terminate the data with a '#' */
1180 /* add the checksum as two ascii digits */
1181 *p
++ = tohex ((csum
>> 4) & 0xf);
1182 *p
++ = tohex (csum
& 0xf);
1183 *p
= 0x0; /* Null terminator on string */
1187 * array_send_packet -- send a GDB packet to the target with error handling. We
1188 * get a '+' (ACK) back if the packet is received and the checksum
1189 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1190 * successful transmition, or a 0 for a failure.
1193 array_send_packet (packet
)
1202 /* scan the packet to make sure it only contains valid characters.
1203 this may sound silly, but sometimes a garbled packet will hang
1204 the target board. We scan the whole thing, then print the error
1207 for (i
= 0; i
< strlen(packet
); i
++) {
1208 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1209 /* legit hex numbers or command */
1210 if ((isxdigit(packet
[i
])) || (isalpha(packet
[i
])))
1212 switch (packet
[i
]) {
1215 case '#': /* end of packet */
1216 case '$': /* start of packet */
1218 default: /* bogus character */
1220 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1226 error ("Can't send packet, found %d non-ascii characters", retries
);
1228 /* ok, try to send the packet */
1230 while (retries
++ <= 10) {
1231 printf_monitor ("%s", packet
);
1233 /* read until either a timeout occurs (-2) or '+' is read */
1234 while (retries
<= 10) {
1235 c
= readchar (-timeout
);
1236 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1239 debuglogs (3, "Got Ack\n");
1241 case SERIAL_TIMEOUT
:
1242 debuglogs (3, "Timed out reading serial port\n");
1243 printf_monitor("@"); /* resync with the monitor */
1244 expect_prompt(1); /* See if we get a expect_prompt */
1245 break; /* Retransmit buffer */
1247 debuglogs (3, "Got NAK\n");
1248 printf_monitor("@"); /* resync with the monitor */
1249 expect_prompt(1); /* See if we get a expect_prompt */
1252 /* it's probably an old response, or the echo of our command.
1253 * just gobble up the packet and ignore it.
1255 debuglogs (3, "Got a junk packet\n");
1258 c
= readchar (timeout
);
1261 c
= readchar (timeout
);
1263 c
= readchar (timeout
);
1266 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1267 continue; /* Now, go look for next packet */
1272 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1273 break; /* Here to retransmit */
1280 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1281 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1282 * packet, or a 0 it the packet wasn't transmitted correctly.
1285 array_get_packet (packet
)
1291 unsigned char pktcsum
;
1297 memset (packet
, 1, PBUFSIZ
);
1299 while (retries
<= 10) {
1301 c
= readchar (timeout
);
1302 if (c
== SERIAL_TIMEOUT
) {
1303 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1305 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1309 while (retries
<= 10) {
1310 c
= readchar (timeout
);
1311 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1313 case SERIAL_TIMEOUT
:
1314 debuglogs (3, "Timeout in mid-packet, retrying\n");
1317 debuglogs (3, "Saw new packet start in middle of old one\n");
1318 return 0; /* Start a new packet, count retries */
1321 pktcsum
= from_hex (readchar (timeout
)) << 4;
1322 pktcsum
|= from_hex (readchar (timeout
));
1324 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1325 if (csum
== pktcsum
) {
1326 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1327 printf_monitor ("@");
1331 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1333 case '*': /* Run length encoding */
1334 debuglogs (5, "Run length encoding in packet\n");
1336 c
= readchar (timeout
);
1338 c
= c
- ' ' + 3; /* Compute repeat count */
1340 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1) {
1341 memset (bp
, *(bp
- 1), c
);
1346 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1350 if ((!isxdigit(c
)) && (!ispunct(c
)))
1351 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1352 if (bp
< packet
+ PBUFSIZ
- 1) {
1359 puts_filtered ("Remote packet too long.\n");
1367 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1369 static unsigned long
1378 for (i
= 0; i
< 8; i
++) {
1380 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1381 val
= val
+ mem
[i
] - 'A' + 10;
1382 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1383 val
= val
+ mem
[i
] - 'a' + 10;
1384 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1385 val
= val
+ mem
[i
] - '0';
1389 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1394 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1398 hexword2ascii (mem
, num
)
1405 debuglogs (4, "hexword2ascii() converting %x ", num
);
1406 for (i
= 7; i
>= 0; i
--) {
1407 mem
[i
] = tohex ((num
>> 4) & 0xf);
1408 mem
[i
] = tohex (num
& 0xf);
1412 debuglogs (4, "\tto a %s", mem
);
1415 /* Convert hex digit A to a number. */
1423 debuglogs (4, "from_hex got a 0x%x(%c)\n",a
,a
);
1424 if (a
>= '0' && a
<= '9')
1426 if (a
>= 'a' && a
<= 'f')
1427 return a
- 'a' + 10;
1428 if (a
>= 'A' && a
<= 'F')
1429 return a
- 'A' + 10;
1431 error ("Reply contains invalid hex digit 0x%x", a
);
1435 /* Convert number NIB to a hex digit. */
1447 * _initialize_remote_monitors -- setup a few addtitional commands that
1448 * are usually only used by monitors.
1451 _initialize_remote_monitors ()
1453 /* generic monitor command */
1454 add_com ("monitor", class_obscure
, monitor_command
,
1455 "Send a command to the debug monitor.");
1460 * _initialize_array -- do any special init stuff for the target.
1463 _initialize_array ()
1465 add_target (&array_ops
);
This page took 0.065051 seconds and 4 git commands to generate.