1 /* Remote debugging interface for Array Tech RAID controller..
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
6 This module talks to a debug monitor called 'MONITOR', which
7 We communicate with MONITOR via either a direct serial line, or a TCP
8 (or possibly TELNET) stream to a terminal multiplexor,
9 which in turn talks to the target board.
11 This file is part of GDB.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330,
26 Boston, MA 02111-1307, USA.
33 #include <sys/types.h>
34 #include "gdb_string.h"
38 #include "remote-utils.h"
45 #define ARRAY_PROMPT ">> "
47 #define SWAP_TARGET_AND_HOST(buffer,len) \
50 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
53 char *p = (char *)(buffer); \
54 char *q = ((char *)(buffer)) + len - 1; \
55 for (; p < q; p++, q--) \
65 static void debuglogs (int, char *, ...);
66 static void array_open ();
67 static void array_close ();
68 static void array_detach ();
69 static void array_attach ();
70 static void array_resume ();
71 static void array_fetch_register ();
72 static void array_store_register ();
73 static void array_fetch_registers ();
74 static void array_store_registers ();
75 static void array_prepare_to_store ();
76 static void array_files_info ();
77 static void array_kill ();
78 static void array_create_inferior ();
79 static void array_mourn_inferior ();
80 static void make_gdb_packet ();
81 static int array_xfer_memory ();
82 static int array_wait ();
83 static int array_insert_breakpoint ();
84 static int array_remove_breakpoint ();
87 static int from_hex ();
88 static int array_send_packet ();
89 static int array_get_packet ();
90 static unsigned long ascii2hexword ();
91 static void hexword2ascii ();
93 #define LOG_FILE "monitor.log"
94 #if defined (LOG_FILE)
98 static int timeout
= 30;
99 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
100 and i386-stub.c. Normally, no one would notice because it only matters
101 for writing large chunks of memory (e.g. in downloads). Also, this needs
102 to be more than 400 if required to hold the registers (see below, where
103 we round it up based on REGISTER_BYTES). */
107 * Descriptor for I/O to remote machine. Initialize it to NULL so that
108 * array_open knows that we don't have a file open when the program starts.
110 serial_t array_desc
= NULL
;
113 * this array of registers need to match the indexes used by GDB. The
114 * whole reason this exists is cause the various ROM monitors use
115 * different strings than GDB does, and doesn't support all the
116 * registers either. So, typing "info reg sp" becomes a "r30".
118 extern char *tmp_mips_processor_type
;
119 extern int mips_set_processor_type ();
121 static struct target_ops array_ops
;
124 init_array_ops (void)
126 array_ops
.to_shortname
= "array";
127 array_ops
.to_longname
=
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_ops
.to_open
= array_open
;
133 array_ops
.to_close
= array_close
;
134 array_ops
.to_attach
= NULL
;
135 array_ops
.to_post_attach
= NULL
;
136 array_ops
.to_require_attach
= NULL
;
137 array_ops
.to_detach
= array_detach
;
138 array_ops
.to_require_detach
= NULL
;
139 array_ops
.to_resume
= array_resume
;
140 array_ops
.to_wait
= array_wait
;
141 array_ops
.to_post_wait
= NULL
;
142 array_ops
.to_fetch_registers
= array_fetch_registers
;
143 array_ops
.to_store_registers
= array_store_registers
;
144 array_ops
.to_prepare_to_store
= array_prepare_to_store
;
145 array_ops
.to_xfer_memory
= array_xfer_memory
;
146 array_ops
.to_files_info
= array_files_info
;
147 array_ops
.to_insert_breakpoint
= array_insert_breakpoint
;
148 array_ops
.to_remove_breakpoint
= array_remove_breakpoint
;
149 array_ops
.to_terminal_init
= 0;
150 array_ops
.to_terminal_inferior
= 0;
151 array_ops
.to_terminal_ours_for_output
= 0;
152 array_ops
.to_terminal_ours
= 0;
153 array_ops
.to_terminal_info
= 0;
154 array_ops
.to_kill
= array_kill
;
155 array_ops
.to_load
= 0;
156 array_ops
.to_lookup_symbol
= 0;
157 array_ops
.to_create_inferior
= array_create_inferior
;
158 array_ops
.to_post_startup_inferior
= NULL
;
159 array_ops
.to_acknowledge_created_inferior
= NULL
;
160 array_ops
.to_clone_and_follow_inferior
= NULL
;
161 array_ops
.to_post_follow_inferior_by_clone
= NULL
;
162 array_ops
.to_insert_fork_catchpoint
= NULL
;
163 array_ops
.to_remove_fork_catchpoint
= NULL
;
164 array_ops
.to_insert_vfork_catchpoint
= NULL
;
165 array_ops
.to_remove_vfork_catchpoint
= NULL
;
166 array_ops
.to_has_forked
= NULL
;
167 array_ops
.to_has_vforked
= NULL
;
168 array_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
169 array_ops
.to_post_follow_vfork
= NULL
;
170 array_ops
.to_insert_exec_catchpoint
= NULL
;
171 array_ops
.to_remove_exec_catchpoint
= NULL
;
172 array_ops
.to_has_execd
= NULL
;
173 array_ops
.to_reported_exec_events_per_exec_call
= NULL
;
174 array_ops
.to_has_exited
= NULL
;
175 array_ops
.to_mourn_inferior
= array_mourn_inferior
;
176 array_ops
.to_can_run
= 0;
177 array_ops
.to_notice_signals
= 0;
178 array_ops
.to_thread_alive
= 0;
179 array_ops
.to_stop
= 0;
180 array_ops
.to_pid_to_exec_file
= NULL
;
181 array_ops
.to_core_file_to_sym_file
= NULL
;
182 array_ops
.to_stratum
= process_stratum
;
183 array_ops
.DONT_USE
= 0;
184 array_ops
.to_has_all_memory
= 1;
185 array_ops
.to_has_memory
= 1;
186 array_ops
.to_has_stack
= 1;
187 array_ops
.to_has_registers
= 1;
188 array_ops
.to_has_execution
= 1;
189 array_ops
.to_sections
= 0;
190 array_ops
.to_sections_end
= 0;
191 array_ops
.to_magic
= OPS_MAGIC
;
195 * printf_monitor -- send data to monitor. Works just like printf.
198 printf_monitor (char *pattern
,...)
204 va_start (args
, pattern
);
206 vsprintf (buf
, pattern
, args
);
208 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
210 if (strlen (buf
) > PBUFSIZ
)
211 error ("printf_monitor(): string too long");
212 if (SERIAL_WRITE (array_desc
, buf
, strlen (buf
)))
213 fprintf (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
216 * write_monitor -- send raw data to monitor.
219 write_monitor (char data
[], int len
)
221 if (SERIAL_WRITE (array_desc
, data
, len
))
222 fprintf (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
224 *(data
+ len
+ 1) = '\0';
225 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
230 * debuglogs -- deal with debugging info to multiple sources. This takes
231 * two real args, the first one is the level to be compared against
232 * the sr_get_debug() value, the second arg is a printf buffer and args
233 * to be formatted and printed. A CR is added after each string is printed.
236 debuglogs (int level
, char *pattern
,...)
240 unsigned char buf
[PBUFSIZ
];
241 char newbuf
[PBUFSIZ
];
244 va_start (args
, pattern
);
246 if ((level
< 0) || (level
> 100))
248 error ("Bad argument passed to debuglogs(), needs debug level");
252 vsprintf (buf
, pattern
, args
); /* format the string */
254 /* convert some characters so it'll look right in the log */
256 for (i
= 0; buf
[i
] != '\0'; i
++)
259 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 */
287 { /* modify control characters */
293 { /* 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 */
307 fputs (newbuf
, log_file
);
308 fputc ('\n', log_file
);
314 /* readchar -- read a character from the remote system, doing all the fancy
318 readchar (int timeout
)
322 c
= SERIAL_READCHAR (array_desc
, abs (timeout
));
324 if (sr_get_debug () > 5)
327 debuglogs (5, "readchar: timeout = %d\n", timeout
);
332 putc (c
& 0x7f, log_file
);
338 if (c
== SERIAL_TIMEOUT
)
341 return c
; /* Polls shouldn't generate timeout errors */
342 error ("Timeout reading from remote system.");
344 fputs ("ERROR: Timeout reading from remote system", log_file
);
347 perror_with_name ("readchar");
351 * expect -- scan input from the remote system, until STRING is found.
352 * If DISCARD is non-zero, then discard non-matching input, else print
353 * it out. Let the user break out immediately.
356 expect (char *string
, int discard
)
362 debuglogs (1, "Expecting \"%s\".", string
);
367 c
= readchar (timeout
);
375 debuglogs (4, "Matched");
383 fputc_unfiltered (c
, gdb_stdout
);
390 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
392 The convention for dealing with the expect_prompt is that you
394 o *then* wait for the expect_prompt.
396 Thus the last thing that a procedure does with the serial line
397 will be an expect_prompt(). Exception: array_resume does not
398 wait for the expect_prompt, because the terminal is being handed over
399 to the inferior. However, the next thing which happens after that
400 is a array_wait which does wait for the expect_prompt.
401 Note that this includes abnormal exit, e.g. error(). This is
402 necessary to prevent getting into states from which we can't
405 expect_prompt (int discard
)
407 expect (ARRAY_PROMPT
, discard
);
411 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
424 if (sr_get_debug () > 5)
425 debuglogs (5, "Ignoring \'%c\'.", ch
);
428 if (sr_get_debug () > 5)
429 debuglogs (5, "Accepting \'%c\'.", ch
);
435 * get_hex_digit -- Get a hex digit from the remote system & return its value.
436 * If ignore is nonzero, ignore spaces, newline & tabs.
439 get_hex_digit (int ignore
)
444 ch
= readchar (timeout
);
447 if (sr_get_debug () > 4)
449 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
453 #ifdef LOG_FILE /* write to the monitor log */
456 fputs ("get_hex_digit() got a 0x", log_file
);
457 fputc (ch
, log_file
);
458 fputc ('\n', log_file
);
464 if (ch
>= '0' && ch
<= '9')
466 else if (ch
>= 'A' && ch
<= 'F')
467 return ch
- 'A' + 10;
468 else if (ch
>= 'a' && ch
<= 'f')
469 return ch
- 'a' + 10;
470 else if (ch
== ' ' && ignore
)
475 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
476 error ("Invalid hex digit from remote system. (0x%x)", ch
);
481 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
482 * Accept any number leading spaces.
485 get_hex_byte (char *byt
)
489 val
= get_hex_digit (1) << 4;
490 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
492 val
|= get_hex_digit (0);
493 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
496 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
500 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
501 * and put them in registers starting at REGNO.
512 if (HOST_BYTE_ORDER
== BIG_ENDIAN
)
515 for (i
= 0; i
< 8; i
++)
516 val
= (val
<< 4) + get_hex_digit (i
== 0);
521 for (i
= 7; i
>= 0; i
--)
522 val
= (val
<< 4) + get_hex_digit (i
== 0);
526 debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val
, (HOST_BYTE_ORDER
== BIG_ENDIAN
) ? "big endian" : "little endian");
531 /* This is called not only when we first attach, but also when the
532 user types "run" after having attached. */
534 array_create_inferior (char *execfile
, char *args
, char **env
)
539 error ("Can't pass arguments to remote MONITOR process");
541 if (execfile
== 0 || exec_bfd
== 0)
542 error ("No executable file specified");
544 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
546 /* The "process" (board) is already stopped awaiting our commands, and
547 the program is already downloaded. We just set its PC and go. */
549 clear_proceed_status ();
551 /* Tell wait_for_inferior that we've started a new process. */
552 init_wait_for_inferior ();
554 /* Set up the "saved terminal modes" of the inferior
555 based on what modes we are starting it with. */
556 target_terminal_init ();
558 /* Install inferior's terminal modes. */
559 target_terminal_inferior ();
561 /* insert_step_breakpoint (); FIXME, do we need this? */
564 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
568 * array_open -- open a connection to a remote debugger.
569 * NAME is the filename used for communication.
571 static int baudrate
= 9600;
572 static char dev_name
[100];
575 array_open (char *args
, char *name
, int from_tty
)
577 char packet
[PBUFSIZ
];
580 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
581 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
586 target_preopen (from_tty
);
587 unpush_target (&array_ops
);
589 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
590 mips_set_processor_type_command ("lsi33k", 0);
592 strcpy (dev_name
, args
);
593 array_desc
= SERIAL_OPEN (dev_name
);
595 if (array_desc
== NULL
)
596 perror_with_name (dev_name
);
600 if (SERIAL_SETBAUDRATE (array_desc
, baud_rate
))
602 SERIAL_CLOSE (array_desc
);
603 perror_with_name (name
);
607 SERIAL_RAW (array_desc
);
609 #if defined (LOG_FILE)
610 log_file
= fopen (LOG_FILE
, "w");
611 if (log_file
== NULL
)
612 perror_with_name (LOG_FILE
);
613 fprintf (log_file
, "GDB %s (%s", version
, host_name
);
614 fprintf (log_file
, " --target %s)\n", array_ops
.to_shortname
);
615 fprintf (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
618 /* see if the target is alive. For a ROM monitor, we can just try to force the
619 expect_prompt to print a few times. For the GDB remote protocol, the application
620 being debugged is sitting at a breakpoint and waiting for GDB to initialize
621 the connection. We force it to give us an empty packet to see if it's alive.
623 debuglogs (3, "Trying to ACK the target's debug stub");
624 /* unless your are on the new hardware, the old board won't initialize
625 because the '@' doesn't flush output like it does on the new ROMS.
627 printf_monitor ("@"); /* ask for the last signal */
628 expect_prompt (1); /* See if we get a expect_prompt */
629 #ifdef TEST_ARRAY /* skip packet for testing */
630 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
631 if (array_send_packet (packet
) == 0)
632 error ("Couldn't transmit packet\n");
633 printf_monitor ("@\n"); /* force it to flush stdout */
634 expect_prompt (1); /* See if we get a expect_prompt */
636 push_target (&array_ops
);
638 printf ("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
642 * array_close -- Close out all files and local state before this
643 * target loses control.
647 array_close (int quitting
)
649 SERIAL_CLOSE (array_desc
);
652 debuglogs (1, "array_close (quitting=%d)", quitting
);
654 #if defined (LOG_FILE)
657 if (ferror (log_file
))
658 printf_filtered ("Error writing log file.\n");
659 if (fclose (log_file
) != 0)
660 printf_filtered ("Error closing log file.\n");
666 * array_detach -- terminate the open connection to the remote
667 * debugger. Use this when you want to detach and do something
668 * else with your gdb.
671 array_detach (int from_tty
)
674 debuglogs (1, "array_detach ()");
676 pop_target (); /* calls array_close to do the real work */
678 printf ("Ending remote %s debugging\n", target_shortname
);
682 * array_attach -- attach GDB to the target.
685 array_attach (char *args
, int from_tty
)
688 printf ("Starting remote %s debugging\n", target_shortname
);
690 debuglogs (1, "array_attach (args=%s)", args
);
692 printf_monitor ("go %x\n");
693 /* swallow the echo. */
694 expect ("go %x\n", 1);
698 * array_resume -- Tell the remote machine to resume.
701 array_resume (int pid
, int step
, enum target_signal sig
)
703 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
707 printf_monitor ("s\n");
711 printf_monitor ("go\n");
718 * array_wait -- Wait until the remote machine stops, then return,
719 * storing status in status just as `wait' would.
722 array_wait (int pid
, struct target_waitstatus
*status
)
724 int old_timeout
= timeout
;
728 serial_ttystate ttystate
;
730 debuglogs (1, "array_wait (), printing extraneous text.");
732 status
->kind
= TARGET_WAITKIND_EXITED
;
733 status
->value
.integer
= 0;
735 timeout
= 0; /* Don't time out -- user program is running. */
737 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
738 tty_desc
= SERIAL_FDOPEN (0);
739 ttystate
= SERIAL_GET_TTY_STATE (tty_desc
);
740 SERIAL_RAW (tty_desc
);
743 /* poll on the serial port and the keyboard. */
746 c
= readchar (timeout
);
749 if (c
== *(ARRAY_PROMPT
+ i
))
751 if (++i
>= strlen (ARRAY_PROMPT
))
752 { /* matched the prompt */
753 debuglogs (4, "array_wait(), got the expect_prompt.");
758 { /* not the prompt */
761 fputc_unfiltered (c
, gdb_stdout
);
762 gdb_flush (gdb_stdout
);
764 c
= SERIAL_READCHAR (tty_desc
, timeout
);
767 SERIAL_WRITE (array_desc
, &c
, 1);
768 /* do this so it looks like there's keyboard echo */
769 if (c
== 3) /* exit on Control-C */
772 fputc_unfiltered (c
, gdb_stdout
);
773 gdb_flush (gdb_stdout
);
777 SERIAL_SET_TTY_STATE (tty_desc
, ttystate
);
780 debuglogs (4, "array_wait(), got the expect_prompt.");
783 status
->kind
= TARGET_WAITKIND_STOPPED
;
784 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
786 timeout
= old_timeout
;
792 * array_fetch_registers -- read the remote registers into the
796 array_fetch_registers (int ignored
)
800 unsigned char packet
[PBUFSIZ
];
801 char regs
[REGISTER_BYTES
];
803 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
805 memset (packet
, 0, PBUFSIZ
);
806 /* Unimplemented registers read as all bits zero. */
807 memset (regs
, 0, REGISTER_BYTES
);
808 make_gdb_packet (packet
, "g");
809 if (array_send_packet (packet
) == 0)
810 error ("Couldn't transmit packet\n");
811 if (array_get_packet (packet
) == 0)
812 error ("Couldn't receive packet\n");
813 /* FIXME: read bytes from packet */
814 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
815 for (regno
= 0; regno
<= PC_REGNUM
+ 4; regno
++)
817 /* supply register stores in target byte order, so swap here */
818 /* FIXME: convert from ASCII hex to raw bytes */
819 i
= ascii2hexword (packet
+ (regno
* 8));
820 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
821 SWAP_TARGET_AND_HOST (&i
, 4);
822 supply_register (regno
, (char *) &i
);
827 * This is unused by targets like this one that use a
828 * protocol based on GDB's remote protocol.
831 array_fetch_register (int ignored
)
833 array_fetch_registers (0 /* ignored */);
837 * Get all the registers from the targets. They come back in a large array.
840 array_store_registers (int ignored
)
844 char packet
[PBUFSIZ
];
848 debuglogs (1, "array_store_registers()");
850 memset (packet
, 0, PBUFSIZ
);
851 memset (buf
, 0, PBUFSIZ
);
854 /* Unimplemented registers read as all bits zero. */
855 /* FIXME: read bytes from packet */
856 for (regno
= 0; regno
< 41; regno
++)
858 /* supply register stores in target byte order, so swap here */
859 /* FIXME: convert from ASCII hex to raw bytes */
860 i
= (unsigned long) read_register (regno
);
861 hexword2ascii (num
, i
);
862 strcpy (buf
+ (regno
* 8) + 1, num
);
864 *(buf
+ (regno
* 8) + 2) = 0;
865 make_gdb_packet (packet
, buf
);
866 if (array_send_packet (packet
) == 0)
867 error ("Couldn't transmit packet\n");
868 if (array_get_packet (packet
) == 0)
869 error ("Couldn't receive packet\n");
871 registers_changed ();
875 * This is unused by targets like this one that use a
876 * protocol based on GDB's remote protocol.
879 array_store_register (int ignored
)
881 array_store_registers (0 /* ignored */);
884 /* Get ready to modify the registers array. On machines which store
885 individual registers, this doesn't need to do anything. On machines
886 which store all the registers in one fell swoop, this makes sure
887 that registers contains all the registers from the program being
891 array_prepare_to_store (void)
893 /* Do nothing, since we can store individual regs */
897 array_files_info (void)
899 printf ("\tAttached to %s at %d baud.\n",
904 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
905 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
908 array_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
912 char packet
[PBUFSIZ
];
917 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
918 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
921 *p
++ = 'M'; /* The command to write memory */
922 hexword2ascii (num
, memaddr
); /* convert the address */
923 strcpy (p
, num
); /* copy the address */
925 *p
++ = ','; /* add comma delimeter */
926 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
931 *p
++ = ':'; /* add the colon delimeter */
932 for (j
= 0; j
< len
; j
++)
933 { /* copy the data in after converting it */
934 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
935 *p
++ = tohex (myaddr
[j
] & 0xf);
938 make_gdb_packet (packet
, buf
);
939 if (array_send_packet (packet
) == 0)
940 error ("Couldn't transmit packet\n");
941 if (array_get_packet (packet
) == 0)
942 error ("Couldn't receive packet\n");
948 * array_read_inferior_memory -- read LEN bytes from inferior memory
949 * at MEMADDR. Put the result at debugger address MYADDR. Returns
953 array_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
957 char packet
[PBUFSIZ
];
958 int count
; /* Number of bytes read so far. */
959 unsigned long startaddr
; /* Starting address of this pass. */
960 int len_this_pass
; /* Number of bytes to read in this pass. */
962 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
964 /* Note that this code works correctly if startaddr is just less
965 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
966 thing). That is, something like
967 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
968 works--it never adds len To memaddr and gets 0. */
969 /* However, something like
970 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
971 doesn't need to work. Detect it and give up if there's an attempt
973 if (((memaddr
- 1) + len
) < memaddr
)
979 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
981 /* Try to align to 16 byte boundry (why?) */
983 if ((startaddr
% 16) != 0)
985 len_this_pass
-= startaddr
% 16;
987 /* Only transfer bytes we need */
988 if (len_this_pass
> (len
- count
))
990 len_this_pass
= (len
- count
);
992 /* Fetch the bytes */
993 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
995 sprintf (buf
, "m%08lx,%04x", startaddr
, len_this_pass
);
996 make_gdb_packet (packet
, buf
);
997 if (array_send_packet (packet
) == 0)
999 error ("Couldn't transmit packet\n");
1001 if (array_get_packet (packet
) == 0)
1003 error ("Couldn't receive packet\n");
1007 error ("Got no data in the GDB packet\n");
1009 /* Pick packet apart and xfer bytes to myaddr */
1010 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
1011 for (j
= 0; j
< len_this_pass
; j
++)
1013 /* extract the byte values */
1014 myaddr
[count
++] = from_hex (*(packet
+ (j
* 2))) * 16 + from_hex (*(packet
+ (j
* 2) + 1));
1015 debuglogs (5, "myaddr[%d] set to %x\n", count
- 1, myaddr
[count
- 1]);
1021 /* Transfer LEN bytes between GDB address MYADDR and target address
1022 MEMADDR. If WRITE is non-zero, transfer them to the target,
1023 otherwise transfer them from the target. TARGET is unused.
1025 Returns the number of bytes transferred. */
1028 array_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1029 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
1030 struct target_ops
*target ATTRIBUTE_UNUSED
)
1033 return array_write_inferior_memory (memaddr
, myaddr
, len
);
1035 return array_read_inferior_memory (memaddr
, myaddr
, len
);
1039 array_kill (char *args
, int from_tty
)
1041 return; /* ignore attempts to kill target system */
1044 /* Clean up when a program exits.
1045 The program actually lives on in the remote processor's RAM, and may be
1046 run again without a download. Don't leave it full of breakpoint
1050 array_mourn_inferior (void)
1052 remove_breakpoints ();
1053 generic_mourn_inferior (); /* Do all the proper things now */
1056 #define MAX_ARRAY_BREAKPOINTS 16
1058 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] =
1062 * array_insert_breakpoint -- add a breakpoint
1065 array_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
1069 CORE_ADDR bp_addr
= addr
;
1071 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1072 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
1074 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++)
1076 if (breakaddr
[i
] == 0)
1078 breakaddr
[i
] = addr
;
1079 if (sr_get_debug () > 4)
1080 printf ("Breakpoint at %s\n", paddr_nz (addr
));
1081 array_read_inferior_memory (bp_addr
, shadow
, bp_size
);
1082 printf_monitor ("b 0x%x\n", addr
);
1088 fprintf (stderr
, "Too many breakpoints (> 16) for monitor\n");
1093 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1096 array_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
1100 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1102 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++)
1104 if (breakaddr
[i
] == addr
)
1107 /* some monitors remove breakpoints based on the address */
1108 printf_monitor ("bd %x\n", i
);
1113 fprintf (stderr
, "Can't find breakpoint associated with 0x%s\n",
1121 debuglogs (1, "array_stop()");
1122 printf_monitor ("\003");
1127 * array_command -- put a command string, in args, out to MONITOR.
1128 * Output from MONITOR is placed on the users terminal until the
1129 * expect_prompt is seen. FIXME
1132 monitor_command (char *args
, int fromtty
)
1134 debuglogs (1, "monitor_command (args=%s)", args
);
1136 if (array_desc
== NULL
)
1137 error ("monitor target not open.");
1140 error ("Missing command.");
1142 printf_monitor ("%s\n", args
);
1147 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1148 * A debug packet whose contents are <data>
1149 * is encapsulated for transmission in the form:
1151 * $ <data> # CSUM1 CSUM2
1153 * <data> must be ASCII alphanumeric and cannot include characters
1154 * '$' or '#'. If <data> starts with two characters followed by
1155 * ':', then the existing stubs interpret this as a sequence number.
1157 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1158 * checksum of <data>, the most significant nibble is sent first.
1159 * the hex digits 0-9,a-f are used.
1163 make_gdb_packet (char *buf
, char *data
)
1166 unsigned char csum
= 0;
1170 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1171 cnt
= strlen (data
);
1173 error ("make_gdb_packet(): to much data\n");
1175 /* start with the packet header */
1179 /* calculate the checksum */
1180 for (i
= 0; i
< cnt
; i
++)
1186 /* terminate the data with a '#' */
1189 /* add the checksum as two ascii digits */
1190 *p
++ = tohex ((csum
>> 4) & 0xf);
1191 *p
++ = tohex (csum
& 0xf);
1192 *p
= 0x0; /* Null terminator on string */
1196 * array_send_packet -- send a GDB packet to the target with error handling. We
1197 * get a '+' (ACK) back if the packet is received and the checksum
1198 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1199 * successful transmition, or a 0 for a failure.
1202 array_send_packet (char *packet
)
1210 /* scan the packet to make sure it only contains valid characters.
1211 this may sound silly, but sometimes a garbled packet will hang
1212 the target board. We scan the whole thing, then print the error
1215 for (i
= 0; i
< strlen (packet
); i
++)
1217 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1218 /* legit hex numbers or command */
1219 if ((isxdigit (packet
[i
])) || (isalpha (packet
[i
])))
1225 case '#': /* end of packet */
1226 case '$': /* start of packet */
1228 default: /* bogus character */
1230 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1236 error ("Can't send packet, found %d non-ascii characters", retries
);
1238 /* ok, try to send the packet */
1240 while (retries
++ <= 10)
1242 printf_monitor ("%s", packet
);
1244 /* read until either a timeout occurs (-2) or '+' is read */
1245 while (retries
<= 10)
1247 c
= readchar (-timeout
);
1248 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1252 debuglogs (3, "Got Ack\n");
1254 case SERIAL_TIMEOUT
:
1255 debuglogs (3, "Timed out reading serial port\n");
1256 printf_monitor ("@"); /* resync with the monitor */
1257 expect_prompt (1); /* See if we get a expect_prompt */
1258 break; /* Retransmit buffer */
1260 debuglogs (3, "Got NAK\n");
1261 printf_monitor ("@"); /* resync with the monitor */
1262 expect_prompt (1); /* See if we get a expect_prompt */
1265 /* it's probably an old response, or the echo of our command.
1266 * just gobble up the packet and ignore it.
1268 debuglogs (3, "Got a junk packet\n");
1272 c
= readchar (timeout
);
1276 c
= readchar (timeout
);
1278 c
= readchar (timeout
);
1281 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1282 continue; /* Now, go look for next packet */
1287 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1288 break; /* Here to retransmit */
1295 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1296 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1297 * packet, or a 0 it the packet wasn't transmitted correctly.
1300 array_get_packet (char *packet
)
1305 unsigned char pktcsum
;
1311 memset (packet
, 1, PBUFSIZ
);
1313 while (retries
<= 10)
1317 c
= readchar (timeout
);
1318 if (c
== SERIAL_TIMEOUT
)
1320 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1322 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1327 while (retries
<= 10)
1329 c
= readchar (timeout
);
1330 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1333 case SERIAL_TIMEOUT
:
1334 debuglogs (3, "Timeout in mid-packet, retrying\n");
1337 debuglogs (3, "Saw new packet start in middle of old one\n");
1338 return 0; /* Start a new packet, count retries */
1341 pktcsum
= from_hex (readchar (timeout
)) << 4;
1342 pktcsum
|= from_hex (readchar (timeout
));
1344 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1345 if (csum
== pktcsum
)
1347 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1348 printf_monitor ("@");
1352 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1354 case '*': /* Run length encoding */
1355 debuglogs (5, "Run length encoding in packet\n");
1357 c
= readchar (timeout
);
1359 c
= c
- ' ' + 3; /* Compute repeat count */
1361 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1)
1363 memset (bp
, *(bp
- 1), c
);
1368 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1372 if ((!isxdigit (c
)) && (!ispunct (c
)))
1373 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1374 if (bp
< packet
+ PBUFSIZ
- 1)
1382 puts_filtered ("Remote packet too long.\n");
1387 return 0; /* exceeded retries */
1391 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1393 static unsigned long
1394 ascii2hexword (unsigned char *mem
)
1401 for (i
= 0; i
< 8; i
++)
1404 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1405 val
= val
+ mem
[i
] - 'A' + 10;
1406 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1407 val
= val
+ mem
[i
] - 'a' + 10;
1408 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1409 val
= val
+ mem
[i
] - '0';
1413 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1418 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1422 hexword2ascii (unsigned char *mem
, unsigned long num
)
1427 debuglogs (4, "hexword2ascii() converting %x ", num
);
1428 for (i
= 7; i
>= 0; i
--)
1430 mem
[i
] = tohex ((num
>> 4) & 0xf);
1431 mem
[i
] = tohex (num
& 0xf);
1435 debuglogs (4, "\tto a %s", mem
);
1438 /* Convert hex digit A to a number. */
1445 debuglogs (4, "from_hex got a 0x%x(%c)\n", a
, a
);
1446 if (a
>= '0' && a
<= '9')
1448 if (a
>= 'a' && a
<= 'f')
1449 return a
- 'a' + 10;
1450 if (a
>= 'A' && a
<= 'F')
1451 return a
- 'A' + 10;
1454 error ("Reply contains invalid hex digit 0x%x", a
);
1458 /* Convert number NIB to a hex digit. */
1465 return 'a' + nib
- 10;
1469 * _initialize_remote_monitors -- setup a few addtitional commands that
1470 * are usually only used by monitors.
1473 _initialize_remote_monitors (void)
1475 /* generic monitor command */
1476 add_com ("monitor", class_obscure
, monitor_command
,
1477 "Send a command to the debug monitor.");
1482 * _initialize_array -- do any special init stuff for the target.
1485 _initialize_array (void)
1488 add_target (&array_ops
);