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 static void debuglogs (int, char *, ...);
48 static void array_open ();
49 static void array_close ();
50 static void array_detach ();
51 static void array_attach ();
52 static void array_resume (ptid_t ptid
, int step
, enum target_signal sig
);
53 static void array_fetch_register ();
54 static void array_store_register ();
55 static void array_fetch_registers ();
56 static void array_store_registers ();
57 static void array_prepare_to_store ();
58 static void array_files_info ();
59 static void array_kill ();
60 static void array_create_inferior ();
61 static void array_mourn_inferior ();
62 static void make_gdb_packet ();
63 static int array_xfer_memory ();
64 static ptid_t
array_wait (ptid_t ptid
,
65 struct target_waitstatus
*status
);
66 static int array_insert_breakpoint ();
67 static int array_remove_breakpoint ();
70 static int from_hex ();
71 static int array_send_packet ();
72 static int array_get_packet ();
73 static unsigned long ascii2hexword ();
74 static void hexword2ascii ();
76 #define LOG_FILE "monitor.log"
77 #if defined (LOG_FILE)
81 static int timeout
= 30;
82 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
83 and i386-stub.c. Normally, no one would notice because it only matters
84 for writing large chunks of memory (e.g. in downloads). Also, this needs
85 to be more than 400 if required to hold the registers (see below, where
86 we round it up based on REGISTER_BYTES). */
90 * Descriptor for I/O to remote machine. Initialize it to NULL so that
91 * array_open knows that we don't have a file open when the program starts.
93 struct serial
*array_desc
= NULL
;
96 * this array of registers need to match the indexes used by GDB. The
97 * whole reason this exists is cause the various ROM monitors use
98 * different strings than GDB does, and doesn't support all the
99 * registers either. So, typing "info reg sp" becomes a "r30".
101 extern char *tmp_mips_processor_type
;
102 extern int mips_set_processor_type ();
104 static struct target_ops array_ops
;
107 init_array_ops (void)
109 array_ops
.to_shortname
= "array";
110 array_ops
.to_longname
=
111 "Debug using the standard GDB remote protocol for the Array Tech target.",
113 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
114 Specify the serial device it is connected to (e.g. /dev/ttya).";
115 array_ops
.to_open
= array_open
;
116 array_ops
.to_close
= array_close
;
117 array_ops
.to_attach
= NULL
;
118 array_ops
.to_post_attach
= NULL
;
119 array_ops
.to_require_attach
= NULL
;
120 array_ops
.to_detach
= array_detach
;
121 array_ops
.to_require_detach
= NULL
;
122 array_ops
.to_resume
= array_resume
;
123 array_ops
.to_wait
= array_wait
;
124 array_ops
.to_post_wait
= NULL
;
125 array_ops
.to_fetch_registers
= array_fetch_registers
;
126 array_ops
.to_store_registers
= array_store_registers
;
127 array_ops
.to_prepare_to_store
= array_prepare_to_store
;
128 array_ops
.to_xfer_memory
= array_xfer_memory
;
129 array_ops
.to_files_info
= array_files_info
;
130 array_ops
.to_insert_breakpoint
= array_insert_breakpoint
;
131 array_ops
.to_remove_breakpoint
= array_remove_breakpoint
;
132 array_ops
.to_terminal_init
= 0;
133 array_ops
.to_terminal_inferior
= 0;
134 array_ops
.to_terminal_ours_for_output
= 0;
135 array_ops
.to_terminal_ours
= 0;
136 array_ops
.to_terminal_info
= 0;
137 array_ops
.to_kill
= array_kill
;
138 array_ops
.to_load
= 0;
139 array_ops
.to_lookup_symbol
= 0;
140 array_ops
.to_create_inferior
= array_create_inferior
;
141 array_ops
.to_post_startup_inferior
= NULL
;
142 array_ops
.to_acknowledge_created_inferior
= NULL
;
143 array_ops
.to_clone_and_follow_inferior
= NULL
;
144 array_ops
.to_post_follow_inferior_by_clone
= NULL
;
145 array_ops
.to_insert_fork_catchpoint
= NULL
;
146 array_ops
.to_remove_fork_catchpoint
= NULL
;
147 array_ops
.to_insert_vfork_catchpoint
= NULL
;
148 array_ops
.to_remove_vfork_catchpoint
= NULL
;
149 array_ops
.to_has_forked
= NULL
;
150 array_ops
.to_has_vforked
= NULL
;
151 array_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
152 array_ops
.to_post_follow_vfork
= NULL
;
153 array_ops
.to_insert_exec_catchpoint
= NULL
;
154 array_ops
.to_remove_exec_catchpoint
= NULL
;
155 array_ops
.to_has_execd
= NULL
;
156 array_ops
.to_reported_exec_events_per_exec_call
= NULL
;
157 array_ops
.to_has_exited
= NULL
;
158 array_ops
.to_mourn_inferior
= array_mourn_inferior
;
159 array_ops
.to_can_run
= 0;
160 array_ops
.to_notice_signals
= 0;
161 array_ops
.to_thread_alive
= 0;
162 array_ops
.to_stop
= 0;
163 array_ops
.to_pid_to_exec_file
= NULL
;
164 array_ops
.to_stratum
= process_stratum
;
165 array_ops
.DONT_USE
= 0;
166 array_ops
.to_has_all_memory
= 1;
167 array_ops
.to_has_memory
= 1;
168 array_ops
.to_has_stack
= 1;
169 array_ops
.to_has_registers
= 1;
170 array_ops
.to_has_execution
= 1;
171 array_ops
.to_sections
= 0;
172 array_ops
.to_sections_end
= 0;
173 array_ops
.to_magic
= OPS_MAGIC
;
177 * printf_monitor -- send data to monitor. Works just like printf.
180 printf_monitor (char *pattern
,...)
186 va_start (args
, pattern
);
188 vsprintf (buf
, pattern
, args
);
190 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
192 if (strlen (buf
) > PBUFSIZ
)
193 error ("printf_monitor(): string too long");
194 if (serial_write (array_desc
, buf
, strlen (buf
)))
195 fprintf (stderr
, "serial_write failed: %s\n", safe_strerror (errno
));
198 * write_monitor -- send raw data to monitor.
201 write_monitor (char data
[], int len
)
203 if (serial_write (array_desc
, data
, len
))
204 fprintf (stderr
, "serial_write failed: %s\n", safe_strerror (errno
));
206 *(data
+ len
+ 1) = '\0';
207 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
212 * debuglogs -- deal with debugging info to multiple sources. This takes
213 * two real args, the first one is the level to be compared against
214 * the sr_get_debug() value, the second arg is a printf buffer and args
215 * to be formatted and printed. A CR is added after each string is printed.
218 debuglogs (int level
, char *pattern
,...)
222 unsigned char buf
[PBUFSIZ
];
223 char newbuf
[PBUFSIZ
];
226 va_start (args
, pattern
);
228 if ((level
< 0) || (level
> 100))
230 error ("Bad argument passed to debuglogs(), needs debug level");
234 vsprintf (buf
, pattern
, args
); /* format the string */
236 /* convert some characters so it'll look right in the log */
238 for (i
= 0; buf
[i
] != '\0'; i
++)
241 error ("Debug message too long");
244 case '\n': /* newlines */
248 case '\r': /* carriage returns */
252 case '\033': /* escape */
260 case '\b': /* backspace */
264 default: /* no change */
269 { /* modify control characters */
275 { /* modify control characters */
281 *p
= '\0'; /* terminate the string */
283 if (sr_get_debug () > level
)
284 printf_unfiltered ("%s\n", newbuf
);
286 #ifdef LOG_FILE /* write to the monitor log */
289 fputs (newbuf
, log_file
);
290 fputc ('\n', log_file
);
296 /* readchar -- read a character from the remote system, doing all the fancy
300 readchar (int timeout
)
304 c
= serial_readchar (array_desc
, abs (timeout
));
306 if (sr_get_debug () > 5)
309 debuglogs (5, "readchar: timeout = %d\n", timeout
);
314 putc (c
& 0x7f, log_file
);
320 if (c
== SERIAL_TIMEOUT
)
323 return c
; /* Polls shouldn't generate timeout errors */
324 error ("Timeout reading from remote system.");
326 fputs ("ERROR: Timeout reading from remote system", log_file
);
329 perror_with_name ("readchar");
333 * expect -- scan input from the remote system, until STRING is found.
334 * If DISCARD is non-zero, then discard non-matching input, else print
335 * it out. Let the user break out immediately.
338 expect (char *string
, int discard
)
344 debuglogs (1, "Expecting \"%s\".", string
);
349 c
= readchar (timeout
);
357 debuglogs (4, "Matched");
365 fputc_unfiltered (c
, gdb_stdout
);
372 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
374 The convention for dealing with the expect_prompt is that you
376 o *then* wait for the expect_prompt.
378 Thus the last thing that a procedure does with the serial line
379 will be an expect_prompt(). Exception: array_resume does not
380 wait for the expect_prompt, because the terminal is being handed over
381 to the inferior. However, the next thing which happens after that
382 is a array_wait which does wait for the expect_prompt.
383 Note that this includes abnormal exit, e.g. error(). This is
384 necessary to prevent getting into states from which we can't
387 expect_prompt (int discard
)
389 expect (ARRAY_PROMPT
, discard
);
393 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
406 if (sr_get_debug () > 5)
407 debuglogs (5, "Ignoring \'%c\'.", ch
);
410 if (sr_get_debug () > 5)
411 debuglogs (5, "Accepting \'%c\'.", ch
);
417 * get_hex_digit -- Get a hex digit from the remote system & return its value.
418 * If ignore is nonzero, ignore spaces, newline & tabs.
421 get_hex_digit (int ignore
)
426 ch
= readchar (timeout
);
429 if (sr_get_debug () > 4)
431 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
435 #ifdef LOG_FILE /* write to the monitor log */
438 fputs ("get_hex_digit() got a 0x", log_file
);
439 fputc (ch
, log_file
);
440 fputc ('\n', log_file
);
446 if (ch
>= '0' && ch
<= '9')
448 else if (ch
>= 'A' && ch
<= 'F')
449 return ch
- 'A' + 10;
450 else if (ch
>= 'a' && ch
<= 'f')
451 return ch
- 'a' + 10;
452 else if (ch
== ' ' && ignore
)
457 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
458 error ("Invalid hex digit from remote system. (0x%x)", ch
);
463 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
464 * Accept any number leading spaces.
467 get_hex_byte (char *byt
)
471 val
= get_hex_digit (1) << 4;
472 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
474 val
|= get_hex_digit (0);
475 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
478 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
482 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
483 * and put them in registers starting at REGNO.
493 for (i
= 0; i
< 8; i
++)
494 val
= (val
<< 4) + get_hex_digit (i
== 0);
496 debuglogs (4, "get_hex_word() got a 0x%x.", val
);
501 /* This is called not only when we first attach, but also when the
502 user types "run" after having attached. */
504 array_create_inferior (char *execfile
, char *args
, char **env
)
509 error ("Can't pass arguments to remote MONITOR process");
511 if (execfile
== 0 || exec_bfd
== 0)
512 error ("No executable file specified");
514 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
516 /* The "process" (board) is already stopped awaiting our commands, and
517 the program is already downloaded. We just set its PC and go. */
519 clear_proceed_status ();
521 /* Tell wait_for_inferior that we've started a new process. */
522 init_wait_for_inferior ();
524 /* Set up the "saved terminal modes" of the inferior
525 based on what modes we are starting it with. */
526 target_terminal_init ();
528 /* Install inferior's terminal modes. */
529 target_terminal_inferior ();
531 /* insert_step_breakpoint (); FIXME, do we need this? */
534 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
538 * array_open -- open a connection to a remote debugger.
539 * NAME is the filename used for communication.
541 static int baudrate
= 9600;
542 static char dev_name
[100];
545 array_open (char *args
, char *name
, int from_tty
)
547 char packet
[PBUFSIZ
];
550 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
551 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
556 target_preopen (from_tty
);
557 unpush_target (&array_ops
);
559 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
560 mips_set_processor_type_command ("lsi33k", 0);
562 strcpy (dev_name
, args
);
563 array_desc
= serial_open (dev_name
);
565 if (array_desc
== NULL
)
566 perror_with_name (dev_name
);
570 if (serial_setbaudrate (array_desc
, baud_rate
))
572 serial_close (array_desc
);
573 perror_with_name (name
);
577 serial_raw (array_desc
);
579 #if defined (LOG_FILE)
580 log_file
= fopen (LOG_FILE
, "w");
581 if (log_file
== NULL
)
582 perror_with_name (LOG_FILE
);
583 fprintf (log_file
, "GDB %s (%s", version
, host_name
);
584 fprintf (log_file
, " --target %s)\n", array_ops
.to_shortname
);
585 fprintf (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
588 /* see if the target is alive. For a ROM monitor, we can just try to force the
589 expect_prompt to print a few times. For the GDB remote protocol, the application
590 being debugged is sitting at a breakpoint and waiting for GDB to initialize
591 the connection. We force it to give us an empty packet to see if it's alive.
593 debuglogs (3, "Trying to ACK the target's debug stub");
594 /* unless your are on the new hardware, the old board won't initialize
595 because the '@' doesn't flush output like it does on the new ROMS.
597 printf_monitor ("@"); /* ask for the last signal */
598 expect_prompt (1); /* See if we get a expect_prompt */
599 #ifdef TEST_ARRAY /* skip packet for testing */
600 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
601 if (array_send_packet (packet
) == 0)
602 error ("Couldn't transmit packet\n");
603 printf_monitor ("@\n"); /* force it to flush stdout */
604 expect_prompt (1); /* See if we get a expect_prompt */
606 push_target (&array_ops
);
608 printf ("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
612 * array_close -- Close out all files and local state before this
613 * target loses control.
617 array_close (int quitting
)
619 serial_close (array_desc
);
622 debuglogs (1, "array_close (quitting=%d)", quitting
);
624 #if defined (LOG_FILE)
627 if (ferror (log_file
))
628 printf_filtered ("Error writing log file.\n");
629 if (fclose (log_file
) != 0)
630 printf_filtered ("Error closing log file.\n");
636 * array_detach -- terminate the open connection to the remote
637 * debugger. Use this when you want to detach and do something
638 * else with your gdb.
641 array_detach (int from_tty
)
644 debuglogs (1, "array_detach ()");
646 pop_target (); /* calls array_close to do the real work */
648 printf ("Ending remote %s debugging\n", target_shortname
);
652 * array_attach -- attach GDB to the target.
655 array_attach (char *args
, int from_tty
)
658 printf ("Starting remote %s debugging\n", target_shortname
);
660 debuglogs (1, "array_attach (args=%s)", args
);
662 printf_monitor ("go %x\n");
663 /* swallow the echo. */
664 expect ("go %x\n", 1);
668 * array_resume -- Tell the remote machine to resume.
671 array_resume (ptid_t ptid
, int step
, enum target_signal sig
)
673 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
677 printf_monitor ("s\n");
681 printf_monitor ("go\n");
688 * array_wait -- Wait until the remote machine stops, then return,
689 * storing status in status just as `wait' would.
692 array_wait (ptid_t ptid
, struct target_waitstatus
*status
)
694 int old_timeout
= timeout
;
697 struct serial
*tty_desc
;
698 serial_ttystate ttystate
;
700 debuglogs (1, "array_wait (), printing extraneous text.");
702 status
->kind
= TARGET_WAITKIND_EXITED
;
703 status
->value
.integer
= 0;
705 timeout
= 0; /* Don't time out -- user program is running. */
707 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
708 tty_desc
= serial_fdopen (0);
709 ttystate
= serial_get_tty_state (tty_desc
);
710 serial_raw (tty_desc
);
713 /* poll on the serial port and the keyboard. */
716 c
= readchar (timeout
);
719 if (c
== *(ARRAY_PROMPT
+ i
))
721 if (++i
>= strlen (ARRAY_PROMPT
))
722 { /* matched the prompt */
723 debuglogs (4, "array_wait(), got the expect_prompt.");
728 { /* not the prompt */
731 fputc_unfiltered (c
, gdb_stdout
);
732 gdb_flush (gdb_stdout
);
734 c
= serial_readchar (tty_desc
, timeout
);
737 serial_write (array_desc
, &c
, 1);
738 /* do this so it looks like there's keyboard echo */
739 if (c
== 3) /* exit on Control-C */
742 fputc_unfiltered (c
, gdb_stdout
);
743 gdb_flush (gdb_stdout
);
747 serial_set_tty_state (tty_desc
, ttystate
);
750 debuglogs (4, "array_wait(), got the expect_prompt.");
753 status
->kind
= TARGET_WAITKIND_STOPPED
;
754 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
756 timeout
= old_timeout
;
758 return inferior_ptid
;
762 * array_fetch_registers -- read the remote registers into the
766 array_fetch_registers (int ignored
)
768 char *reg
= alloca (MAX_REGISTER_RAW_SIZE
);
771 char *packet
= alloca (PBUFSIZ
);
773 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
775 memset (packet
, 0, PBUFSIZ
);
776 make_gdb_packet (packet
, "g");
777 if (array_send_packet (packet
) == 0)
778 error ("Couldn't transmit packet\n");
779 if (array_get_packet (packet
) == 0)
780 error ("Couldn't receive packet\n");
781 /* FIXME: read bytes from packet */
782 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
783 for (regno
= 0; regno
<= PC_REGNUM
+ 4; regno
++)
785 /* supply register stores in target byte order, so swap here */
786 /* FIXME: convert from ASCII hex to raw bytes */
787 LONGEST i
= ascii2hexword (packet
+ (regno
* 8));
788 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
789 store_unsigned_integer (®
, REGISTER_RAW_SIZE (regno
), i
);
790 supply_register (regno
, (char *) ®
);
795 * This is unused by targets like this one that use a
796 * protocol based on GDB's remote protocol.
799 array_fetch_register (int ignored
)
801 array_fetch_registers (0 /* ignored */);
805 * Get all the registers from the targets. They come back in a large array.
808 array_store_registers (int ignored
)
812 char packet
[PBUFSIZ
];
816 debuglogs (1, "array_store_registers()");
818 memset (packet
, 0, PBUFSIZ
);
819 memset (buf
, 0, PBUFSIZ
);
822 /* Unimplemented registers read as all bits zero. */
823 /* FIXME: read bytes from packet */
824 for (regno
= 0; regno
< 41; regno
++)
826 /* supply register stores in target byte order, so swap here */
827 /* FIXME: convert from ASCII hex to raw bytes */
828 i
= (unsigned long) read_register (regno
);
829 hexword2ascii (num
, i
);
830 strcpy (buf
+ (regno
* 8) + 1, num
);
832 *(buf
+ (regno
* 8) + 2) = 0;
833 make_gdb_packet (packet
, buf
);
834 if (array_send_packet (packet
) == 0)
835 error ("Couldn't transmit packet\n");
836 if (array_get_packet (packet
) == 0)
837 error ("Couldn't receive packet\n");
839 registers_changed ();
843 * This is unused by targets like this one that use a
844 * protocol based on GDB's remote protocol.
847 array_store_register (int ignored
)
849 array_store_registers (0 /* ignored */);
852 /* Get ready to modify the registers array. On machines which store
853 individual registers, this doesn't need to do anything. On machines
854 which store all the registers in one fell swoop, this makes sure
855 that registers contains all the registers from the program being
859 array_prepare_to_store (void)
861 /* Do nothing, since we can store individual regs */
865 array_files_info (void)
867 printf ("\tAttached to %s at %d baud.\n",
872 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
873 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
876 array_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
880 char packet
[PBUFSIZ
];
885 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
886 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
889 *p
++ = 'M'; /* The command to write memory */
890 hexword2ascii (num
, memaddr
); /* convert the address */
891 strcpy (p
, num
); /* copy the address */
893 *p
++ = ','; /* add comma delimeter */
894 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
899 *p
++ = ':'; /* add the colon delimeter */
900 for (j
= 0; j
< len
; j
++)
901 { /* copy the data in after converting it */
902 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
903 *p
++ = tohex (myaddr
[j
] & 0xf);
906 make_gdb_packet (packet
, buf
);
907 if (array_send_packet (packet
) == 0)
908 error ("Couldn't transmit packet\n");
909 if (array_get_packet (packet
) == 0)
910 error ("Couldn't receive packet\n");
916 * array_read_inferior_memory -- read LEN bytes from inferior memory
917 * at MEMADDR. Put the result at debugger address MYADDR. Returns
921 array_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
925 char packet
[PBUFSIZ
];
926 int count
; /* Number of bytes read so far. */
927 unsigned long startaddr
; /* Starting address of this pass. */
928 int len_this_pass
; /* Number of bytes to read in this pass. */
930 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
932 /* Note that this code works correctly if startaddr is just less
933 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
934 thing). That is, something like
935 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
936 works--it never adds len To memaddr and gets 0. */
937 /* However, something like
938 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
939 doesn't need to work. Detect it and give up if there's an attempt
941 if (((memaddr
- 1) + len
) < memaddr
)
947 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
949 /* Try to align to 16 byte boundry (why?) */
951 if ((startaddr
% 16) != 0)
953 len_this_pass
-= startaddr
% 16;
955 /* Only transfer bytes we need */
956 if (len_this_pass
> (len
- count
))
958 len_this_pass
= (len
- count
);
960 /* Fetch the bytes */
961 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
963 sprintf (buf
, "m%08lx,%04x", startaddr
, len_this_pass
);
964 make_gdb_packet (packet
, buf
);
965 if (array_send_packet (packet
) == 0)
967 error ("Couldn't transmit packet\n");
969 if (array_get_packet (packet
) == 0)
971 error ("Couldn't receive packet\n");
975 error ("Got no data in the GDB packet\n");
977 /* Pick packet apart and xfer bytes to myaddr */
978 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
979 for (j
= 0; j
< len_this_pass
; j
++)
981 /* extract the byte values */
982 myaddr
[count
++] = from_hex (*(packet
+ (j
* 2))) * 16 + from_hex (*(packet
+ (j
* 2) + 1));
983 debuglogs (5, "myaddr[%d] set to %x\n", count
- 1, myaddr
[count
- 1]);
989 /* Transfer LEN bytes between GDB address MYADDR and target address
990 MEMADDR. If WRITE is non-zero, transfer them to the target,
991 otherwise transfer them from the target. TARGET is unused.
993 Returns the number of bytes transferred. */
996 array_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
997 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
998 struct target_ops
*target ATTRIBUTE_UNUSED
)
1001 return array_write_inferior_memory (memaddr
, myaddr
, len
);
1003 return array_read_inferior_memory (memaddr
, myaddr
, len
);
1007 array_kill (char *args
, int from_tty
)
1009 return; /* ignore attempts to kill target system */
1012 /* Clean up when a program exits.
1013 The program actually lives on in the remote processor's RAM, and may be
1014 run again without a download. Don't leave it full of breakpoint
1018 array_mourn_inferior (void)
1020 remove_breakpoints ();
1021 generic_mourn_inferior (); /* Do all the proper things now */
1024 #define MAX_ARRAY_BREAKPOINTS 16
1026 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] =
1030 * array_insert_breakpoint -- add a breakpoint
1033 array_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
1037 CORE_ADDR bp_addr
= addr
;
1039 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1040 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
1042 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++)
1044 if (breakaddr
[i
] == 0)
1046 breakaddr
[i
] = addr
;
1047 if (sr_get_debug () > 4)
1048 printf ("Breakpoint at %s\n", paddr_nz (addr
));
1049 array_read_inferior_memory (bp_addr
, shadow
, bp_size
);
1050 printf_monitor ("b 0x%x\n", addr
);
1056 fprintf (stderr
, "Too many breakpoints (> 16) for monitor\n");
1061 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1064 array_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
1068 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1070 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++)
1072 if (breakaddr
[i
] == addr
)
1075 /* some monitors remove breakpoints based on the address */
1076 printf_monitor ("bd %x\n", i
);
1081 fprintf (stderr
, "Can't find breakpoint associated with 0x%s\n",
1089 debuglogs (1, "array_stop()");
1090 printf_monitor ("\003");
1095 * array_command -- put a command string, in args, out to MONITOR.
1096 * Output from MONITOR is placed on the users terminal until the
1097 * expect_prompt is seen. FIXME
1100 monitor_command (char *args
, int fromtty
)
1102 debuglogs (1, "monitor_command (args=%s)", args
);
1104 if (array_desc
== NULL
)
1105 error ("monitor target not open.");
1108 error ("Missing command.");
1110 printf_monitor ("%s\n", args
);
1115 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1116 * A debug packet whose contents are <data>
1117 * is encapsulated for transmission in the form:
1119 * $ <data> # CSUM1 CSUM2
1121 * <data> must be ASCII alphanumeric and cannot include characters
1122 * '$' or '#'. If <data> starts with two characters followed by
1123 * ':', then the existing stubs interpret this as a sequence number.
1125 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1126 * checksum of <data>, the most significant nibble is sent first.
1127 * the hex digits 0-9,a-f are used.
1131 make_gdb_packet (char *buf
, char *data
)
1134 unsigned char csum
= 0;
1138 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1139 cnt
= strlen (data
);
1141 error ("make_gdb_packet(): to much data\n");
1143 /* start with the packet header */
1147 /* calculate the checksum */
1148 for (i
= 0; i
< cnt
; i
++)
1154 /* terminate the data with a '#' */
1157 /* add the checksum as two ascii digits */
1158 *p
++ = tohex ((csum
>> 4) & 0xf);
1159 *p
++ = tohex (csum
& 0xf);
1160 *p
= 0x0; /* Null terminator on string */
1164 * array_send_packet -- send a GDB packet to the target with error handling. We
1165 * get a '+' (ACK) back if the packet is received and the checksum
1166 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1167 * successful transmition, or a 0 for a failure.
1170 array_send_packet (char *packet
)
1178 /* scan the packet to make sure it only contains valid characters.
1179 this may sound silly, but sometimes a garbled packet will hang
1180 the target board. We scan the whole thing, then print the error
1183 for (i
= 0; i
< strlen (packet
); i
++)
1185 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1186 /* legit hex numbers or command */
1187 if ((isxdigit (packet
[i
])) || (isalpha (packet
[i
])))
1193 case '#': /* end of packet */
1194 case '$': /* start of packet */
1196 default: /* bogus character */
1198 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1204 error ("Can't send packet, found %d non-ascii characters", retries
);
1206 /* ok, try to send the packet */
1208 while (retries
++ <= 10)
1210 printf_monitor ("%s", packet
);
1212 /* read until either a timeout occurs (-2) or '+' is read */
1213 while (retries
<= 10)
1215 c
= readchar (-timeout
);
1216 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1220 debuglogs (3, "Got Ack\n");
1222 case SERIAL_TIMEOUT
:
1223 debuglogs (3, "Timed out reading serial port\n");
1224 printf_monitor ("@"); /* resync with the monitor */
1225 expect_prompt (1); /* See if we get a expect_prompt */
1226 break; /* Retransmit buffer */
1228 debuglogs (3, "Got NAK\n");
1229 printf_monitor ("@"); /* resync with the monitor */
1230 expect_prompt (1); /* See if we get a expect_prompt */
1233 /* it's probably an old response, or the echo of our command.
1234 * just gobble up the packet and ignore it.
1236 debuglogs (3, "Got a junk packet\n");
1240 c
= readchar (timeout
);
1244 c
= readchar (timeout
);
1246 c
= readchar (timeout
);
1249 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1250 continue; /* Now, go look for next packet */
1255 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1256 break; /* Here to retransmit */
1263 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1264 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1265 * packet, or a 0 it the packet wasn't transmitted correctly.
1268 array_get_packet (char *packet
)
1273 unsigned char pktcsum
;
1279 memset (packet
, 1, PBUFSIZ
);
1281 while (retries
<= 10)
1285 c
= readchar (timeout
);
1286 if (c
== SERIAL_TIMEOUT
)
1288 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1290 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1295 while (retries
<= 10)
1297 c
= readchar (timeout
);
1298 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1301 case SERIAL_TIMEOUT
:
1302 debuglogs (3, "Timeout in mid-packet, retrying\n");
1305 debuglogs (3, "Saw new packet start in middle of old one\n");
1306 return 0; /* Start a new packet, count retries */
1309 pktcsum
= from_hex (readchar (timeout
)) << 4;
1310 pktcsum
|= from_hex (readchar (timeout
));
1312 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1313 if (csum
== pktcsum
)
1315 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1316 printf_monitor ("@");
1320 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1322 case '*': /* Run length encoding */
1323 debuglogs (5, "Run length encoding in packet\n");
1325 c
= readchar (timeout
);
1327 c
= c
- ' ' + 3; /* Compute repeat count */
1329 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1)
1331 memset (bp
, *(bp
- 1), c
);
1336 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1340 if ((!isxdigit (c
)) && (!ispunct (c
)))
1341 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1342 if (bp
< packet
+ PBUFSIZ
- 1)
1350 puts_filtered ("Remote packet too long.\n");
1355 return 0; /* exceeded retries */
1359 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1361 static unsigned long
1362 ascii2hexword (unsigned char *mem
)
1369 for (i
= 0; i
< 8; i
++)
1372 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1373 val
= val
+ mem
[i
] - 'A' + 10;
1374 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1375 val
= val
+ mem
[i
] - 'a' + 10;
1376 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1377 val
= val
+ mem
[i
] - '0';
1381 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1386 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1390 hexword2ascii (unsigned char *mem
, unsigned long num
)
1395 debuglogs (4, "hexword2ascii() converting %x ", num
);
1396 for (i
= 7; i
>= 0; i
--)
1398 mem
[i
] = tohex ((num
>> 4) & 0xf);
1399 mem
[i
] = tohex (num
& 0xf);
1403 debuglogs (4, "\tto a %s", mem
);
1406 /* Convert hex digit A to a number. */
1413 debuglogs (4, "from_hex got a 0x%x(%c)\n", a
, a
);
1414 if (a
>= '0' && a
<= '9')
1416 if (a
>= 'a' && a
<= 'f')
1417 return a
- 'a' + 10;
1418 if (a
>= 'A' && a
<= 'F')
1419 return a
- 'A' + 10;
1422 error ("Reply contains invalid hex digit 0x%x", a
);
1426 /* Convert number NIB to a hex digit. */
1433 return 'a' + nib
- 10;
1437 * _initialize_remote_monitors -- setup a few addtitional commands that
1438 * are usually only used by monitors.
1441 _initialize_remote_monitors (void)
1443 /* generic monitor command */
1444 add_com ("monitor", class_obscure
, monitor_command
,
1445 "Send a command to the debug monitor.");
1450 * _initialize_array -- do any special init stuff for the target.
1453 _initialize_array (void)
1456 add_target (&array_ops
);