1 /* Remote debugging interface for Array Tech RAID controller..
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
6 Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
8 This module talks to a debug monitor called 'MONITOR', which
9 We communicate with MONITOR via either a direct serial line, or a TCP
10 (or possibly TELNET) stream to a terminal multiplexor,
11 which in turn talks to the target board.
13 This file is part of GDB.
15 This program is free software; you can redistribute it and/or modify
16 it under the terms of the GNU General Public License as published by
17 the Free Software Foundation; either version 2 of the License, or
18 (at your option) any later version.
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
25 You should have received a copy of the GNU General Public License
26 along with this program; if not, write to the Free Software
27 Foundation, Inc., 59 Temple Place - Suite 330,
28 Boston, MA 02111-1307, USA. */
34 #include <sys/types.h>
35 #include "gdb_string.h"
39 #include "remote-utils.h"
46 #define ARRAY_PROMPT ">> "
48 static void debuglogs (int, char *, ...);
49 static void array_open ();
50 static void array_close ();
51 static void array_detach ();
52 static void array_attach ();
53 static void array_resume (ptid_t ptid
, int step
, enum target_signal sig
);
54 static void array_fetch_register ();
55 static void array_store_register ();
56 static void array_fetch_registers ();
57 static void array_store_registers ();
58 static void array_prepare_to_store ();
59 static void array_files_info ();
60 static void array_kill ();
61 static void array_create_inferior ();
62 static void array_mourn_inferior ();
63 static void make_gdb_packet ();
64 static int array_xfer_memory ();
65 static ptid_t
array_wait (ptid_t ptid
,
66 struct target_waitstatus
*status
);
67 static int array_insert_breakpoint ();
68 static int array_remove_breakpoint ();
71 static int from_hex ();
72 static int array_send_packet ();
73 static int array_get_packet ();
74 static unsigned long ascii2hexword ();
75 static void hexword2ascii ();
77 #define LOG_FILE "monitor.log"
78 #if defined (LOG_FILE)
82 static int timeout
= 30;
83 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
84 and i386-stub.c. Normally, no one would notice because it only matters
85 for writing large chunks of memory (e.g. in downloads). Also, this needs
86 to be more than 400 if required to hold the registers (see below, where
87 we round it up based on REGISTER_BYTES). */
91 * Descriptor for I/O to remote machine. Initialize it to NULL so that
92 * array_open knows that we don't have a file open when the program starts.
94 struct serial
*array_desc
= NULL
;
97 * this array of registers need to match the indexes used by GDB. The
98 * whole reason this exists is cause the various ROM monitors use
99 * different strings than GDB does, and doesn't support all the
100 * registers either. So, typing "info reg sp" becomes a "r30".
102 extern char *tmp_mips_processor_type
;
103 extern int mips_set_processor_type ();
105 static struct target_ops array_ops
;
108 init_array_ops (void)
110 array_ops
.to_shortname
= "array";
111 array_ops
.to_longname
=
112 "Debug using the standard GDB remote protocol for the Array Tech target.",
114 "Debug using the standard GDB remote protocol for the Array Tech target.\n\
115 Specify the serial device it is connected to (e.g. /dev/ttya).";
116 array_ops
.to_open
= array_open
;
117 array_ops
.to_close
= array_close
;
118 array_ops
.to_attach
= NULL
;
119 array_ops
.to_post_attach
= NULL
;
120 array_ops
.to_require_attach
= NULL
;
121 array_ops
.to_detach
= array_detach
;
122 array_ops
.to_require_detach
= NULL
;
123 array_ops
.to_resume
= array_resume
;
124 array_ops
.to_wait
= array_wait
;
125 array_ops
.to_post_wait
= NULL
;
126 array_ops
.to_fetch_registers
= array_fetch_registers
;
127 array_ops
.to_store_registers
= array_store_registers
;
128 array_ops
.to_prepare_to_store
= array_prepare_to_store
;
129 array_ops
.to_xfer_memory
= array_xfer_memory
;
130 array_ops
.to_files_info
= array_files_info
;
131 array_ops
.to_insert_breakpoint
= array_insert_breakpoint
;
132 array_ops
.to_remove_breakpoint
= array_remove_breakpoint
;
133 array_ops
.to_terminal_init
= 0;
134 array_ops
.to_terminal_inferior
= 0;
135 array_ops
.to_terminal_ours_for_output
= 0;
136 array_ops
.to_terminal_ours
= 0;
137 array_ops
.to_terminal_info
= 0;
138 array_ops
.to_kill
= array_kill
;
139 array_ops
.to_load
= 0;
140 array_ops
.to_lookup_symbol
= 0;
141 array_ops
.to_create_inferior
= array_create_inferior
;
142 array_ops
.to_post_startup_inferior
= NULL
;
143 array_ops
.to_acknowledge_created_inferior
= NULL
;
144 array_ops
.to_clone_and_follow_inferior
= NULL
;
145 array_ops
.to_post_follow_inferior_by_clone
= NULL
;
146 array_ops
.to_insert_fork_catchpoint
= NULL
;
147 array_ops
.to_remove_fork_catchpoint
= NULL
;
148 array_ops
.to_insert_vfork_catchpoint
= NULL
;
149 array_ops
.to_remove_vfork_catchpoint
= NULL
;
150 array_ops
.to_has_forked
= NULL
;
151 array_ops
.to_has_vforked
= NULL
;
152 array_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
153 array_ops
.to_post_follow_vfork
= NULL
;
154 array_ops
.to_insert_exec_catchpoint
= NULL
;
155 array_ops
.to_remove_exec_catchpoint
= NULL
;
156 array_ops
.to_has_execd
= NULL
;
157 array_ops
.to_reported_exec_events_per_exec_call
= NULL
;
158 array_ops
.to_has_exited
= NULL
;
159 array_ops
.to_mourn_inferior
= array_mourn_inferior
;
160 array_ops
.to_can_run
= 0;
161 array_ops
.to_notice_signals
= 0;
162 array_ops
.to_thread_alive
= 0;
163 array_ops
.to_stop
= 0;
164 array_ops
.to_pid_to_exec_file
= NULL
;
165 array_ops
.to_stratum
= process_stratum
;
166 array_ops
.DONT_USE
= 0;
167 array_ops
.to_has_all_memory
= 1;
168 array_ops
.to_has_memory
= 1;
169 array_ops
.to_has_stack
= 1;
170 array_ops
.to_has_registers
= 1;
171 array_ops
.to_has_execution
= 1;
172 array_ops
.to_sections
= 0;
173 array_ops
.to_sections_end
= 0;
174 array_ops
.to_magic
= OPS_MAGIC
;
178 * printf_monitor -- send data to monitor. Works just like printf.
181 printf_monitor (char *pattern
,...)
187 va_start (args
, pattern
);
189 vsprintf (buf
, pattern
, args
);
191 debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf
);
193 if (strlen (buf
) > PBUFSIZ
)
194 error ("printf_monitor(): string too long");
195 if (serial_write (array_desc
, buf
, strlen (buf
)))
196 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
197 safe_strerror (errno
));
200 * write_monitor -- send raw data to monitor.
203 write_monitor (char data
[], int len
)
205 if (serial_write (array_desc
, data
, len
))
206 fprintf_unfiltered (gdb_stderr
, "serial_write failed: %s\n",
207 safe_strerror (errno
));
209 *(data
+ len
+ 1) = '\0';
210 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
215 * debuglogs -- deal with debugging info to multiple sources. This takes
216 * two real args, the first one is the level to be compared against
217 * the sr_get_debug() value, the second arg is a printf buffer and args
218 * to be formatted and printed. A CR is added after each string is printed.
221 debuglogs (int level
, char *pattern
,...)
225 unsigned char buf
[PBUFSIZ
];
226 char newbuf
[PBUFSIZ
];
229 va_start (args
, pattern
);
231 if ((level
< 0) || (level
> 100))
233 error ("Bad argument passed to debuglogs(), needs debug level");
237 vsprintf (buf
, pattern
, args
); /* format the string */
239 /* convert some characters so it'll look right in the log */
241 for (i
= 0; buf
[i
] != '\0'; i
++)
244 error ("Debug message too long");
247 case '\n': /* newlines */
251 case '\r': /* carriage returns */
255 case '\033': /* escape */
263 case '\b': /* backspace */
267 default: /* no change */
272 { /* modify control characters */
278 { /* modify control characters */
284 *p
= '\0'; /* terminate the string */
286 if (sr_get_debug () > level
)
287 printf_unfiltered ("%s\n", newbuf
);
289 #ifdef LOG_FILE /* write to the monitor log */
292 fputs (newbuf
, log_file
);
293 fputc ('\n', log_file
);
299 /* readchar -- read a character from the remote system, doing all the fancy
303 readchar (int timeout
)
307 c
= serial_readchar (array_desc
, abs (timeout
));
309 if (sr_get_debug () > 5)
312 debuglogs (5, "readchar: timeout = %d\n", timeout
);
317 putc (c
& 0x7f, log_file
);
323 if (c
== SERIAL_TIMEOUT
)
326 return c
; /* Polls shouldn't generate timeout errors */
327 error ("Timeout reading from remote system.");
329 fputs ("ERROR: Timeout reading from remote system", log_file
);
332 perror_with_name ("readchar");
336 * expect -- scan input from the remote system, until STRING is found.
337 * If DISCARD is non-zero, then discard non-matching input, else print
338 * it out. Let the user break out immediately.
341 expect (char *string
, int discard
)
347 debuglogs (1, "Expecting \"%s\".", string
);
352 c
= readchar (timeout
);
360 debuglogs (4, "Matched");
368 fputc_unfiltered (c
, gdb_stdout
);
375 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
377 The convention for dealing with the expect_prompt is that you
379 o *then* wait for the expect_prompt.
381 Thus the last thing that a procedure does with the serial line
382 will be an expect_prompt(). Exception: array_resume does not
383 wait for the expect_prompt, because the terminal is being handed over
384 to the inferior. However, the next thing which happens after that
385 is a array_wait which does wait for the expect_prompt.
386 Note that this includes abnormal exit, e.g. error(). This is
387 necessary to prevent getting into states from which we can't
390 expect_prompt (int discard
)
392 expect (ARRAY_PROMPT
, discard
);
396 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
409 if (sr_get_debug () > 5)
410 debuglogs (5, "Ignoring \'%c\'.", ch
);
413 if (sr_get_debug () > 5)
414 debuglogs (5, "Accepting \'%c\'.", ch
);
420 * get_hex_digit -- Get a hex digit from the remote system & return its value.
421 * If ignore is nonzero, ignore spaces, newline & tabs.
424 get_hex_digit (int ignore
)
429 ch
= readchar (timeout
);
432 if (sr_get_debug () > 4)
434 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
438 #ifdef LOG_FILE /* write to the monitor log */
441 fputs ("get_hex_digit() got a 0x", log_file
);
442 fputc (ch
, log_file
);
443 fputc ('\n', log_file
);
449 if (ch
>= '0' && ch
<= '9')
451 else if (ch
>= 'A' && ch
<= 'F')
452 return ch
- 'A' + 10;
453 else if (ch
>= 'a' && ch
<= 'f')
454 return ch
- 'a' + 10;
455 else if (ch
== ' ' && ignore
)
460 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
461 error ("Invalid hex digit from remote system. (0x%x)", ch
);
466 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
467 * Accept any number leading spaces.
470 get_hex_byte (char *byt
)
474 val
= get_hex_digit (1) << 4;
475 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
477 val
|= get_hex_digit (0);
478 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
481 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
485 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
486 * and put them in registers starting at REGNO.
496 for (i
= 0; i
< 8; i
++)
497 val
= (val
<< 4) + get_hex_digit (i
== 0);
499 debuglogs (4, "get_hex_word() got a 0x%x.", val
);
504 /* This is called not only when we first attach, but also when the
505 user types "run" after having attached. */
507 array_create_inferior (char *execfile
, char *args
, char **env
)
512 error ("Can't pass arguments to remote MONITOR process");
514 if (execfile
== 0 || exec_bfd
== 0)
515 error ("No executable file specified");
517 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
519 /* The "process" (board) is already stopped awaiting our commands, and
520 the program is already downloaded. We just set its PC and go. */
522 clear_proceed_status ();
524 /* Tell wait_for_inferior that we've started a new process. */
525 init_wait_for_inferior ();
527 /* Set up the "saved terminal modes" of the inferior
528 based on what modes we are starting it with. */
529 target_terminal_init ();
531 /* Install inferior's terminal modes. */
532 target_terminal_inferior ();
534 /* insert_step_breakpoint (); FIXME, do we need this? */
537 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
541 * array_open -- open a connection to a remote debugger.
542 * NAME is the filename used for communication.
544 static int baudrate
= 9600;
545 static char dev_name
[100];
548 array_open (char *args
, char *name
, int from_tty
)
550 char packet
[PBUFSIZ
];
553 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
554 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
559 target_preopen (from_tty
);
560 unpush_target (&array_ops
);
562 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
563 mips_set_processor_type_command ("lsi33k", 0);
565 strcpy (dev_name
, args
);
566 array_desc
= serial_open (dev_name
);
568 if (array_desc
== NULL
)
569 perror_with_name (dev_name
);
573 if (serial_setbaudrate (array_desc
, baud_rate
))
575 serial_close (array_desc
);
576 perror_with_name (name
);
580 serial_raw (array_desc
);
582 #if defined (LOG_FILE)
583 log_file
= fopen (LOG_FILE
, "w");
584 if (log_file
== NULL
)
585 perror_with_name (LOG_FILE
);
586 fprintf (log_file
, "GDB %s (%s", version
, host_name
);
587 fprintf (log_file
, " --target %s)\n", array_ops
.to_shortname
);
588 fprintf (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
591 /* see if the target is alive. For a ROM monitor, we can just try to force the
592 expect_prompt to print a few times. For the GDB remote protocol, the application
593 being debugged is sitting at a breakpoint and waiting for GDB to initialize
594 the connection. We force it to give us an empty packet to see if it's alive.
596 debuglogs (3, "Trying to ACK the target's debug stub");
597 /* unless your are on the new hardware, the old board won't initialize
598 because the '@' doesn't flush output like it does on the new ROMS.
600 printf_monitor ("@"); /* ask for the last signal */
601 expect_prompt (1); /* See if we get a expect_prompt */
602 #ifdef TEST_ARRAY /* skip packet for testing */
603 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
604 if (array_send_packet (packet
) == 0)
605 error ("Couldn't transmit packet\n");
606 printf_monitor ("@\n"); /* force it to flush stdout */
607 expect_prompt (1); /* See if we get a expect_prompt */
609 push_target (&array_ops
);
611 printf ("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
615 * array_close -- Close out all files and local state before this
616 * target loses control.
620 array_close (int quitting
)
622 serial_close (array_desc
);
625 debuglogs (1, "array_close (quitting=%d)", quitting
);
627 #if defined (LOG_FILE)
630 if (ferror (log_file
))
631 printf_filtered ("Error writing log file.\n");
632 if (fclose (log_file
) != 0)
633 printf_filtered ("Error closing log file.\n");
639 * array_detach -- terminate the open connection to the remote
640 * debugger. Use this when you want to detach and do something
641 * else with your gdb.
644 array_detach (int from_tty
)
647 debuglogs (1, "array_detach ()");
649 pop_target (); /* calls array_close to do the real work */
651 printf ("Ending remote %s debugging\n", target_shortname
);
655 * array_attach -- attach GDB to the target.
658 array_attach (char *args
, int from_tty
)
661 printf ("Starting remote %s debugging\n", target_shortname
);
663 debuglogs (1, "array_attach (args=%s)", args
);
665 printf_monitor ("go %x\n");
666 /* swallow the echo. */
667 expect ("go %x\n", 1);
671 * array_resume -- Tell the remote machine to resume.
674 array_resume (ptid_t ptid
, int step
, enum target_signal sig
)
676 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
680 printf_monitor ("s\n");
684 printf_monitor ("go\n");
691 * array_wait -- Wait until the remote machine stops, then return,
692 * storing status in status just as `wait' would.
695 array_wait (ptid_t ptid
, struct target_waitstatus
*status
)
697 int old_timeout
= timeout
;
700 struct serial
*tty_desc
;
701 serial_ttystate ttystate
;
703 debuglogs (1, "array_wait (), printing extraneous text.");
705 status
->kind
= TARGET_WAITKIND_EXITED
;
706 status
->value
.integer
= 0;
708 timeout
= 0; /* Don't time out -- user program is running. */
710 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
711 tty_desc
= serial_fdopen (0);
712 ttystate
= serial_get_tty_state (tty_desc
);
713 serial_raw (tty_desc
);
716 /* poll on the serial port and the keyboard. */
719 c
= readchar (timeout
);
722 if (c
== *(ARRAY_PROMPT
+ i
))
724 if (++i
>= strlen (ARRAY_PROMPT
))
725 { /* matched the prompt */
726 debuglogs (4, "array_wait(), got the expect_prompt.");
731 { /* not the prompt */
734 fputc_unfiltered (c
, gdb_stdout
);
735 gdb_flush (gdb_stdout
);
737 c
= serial_readchar (tty_desc
, timeout
);
740 serial_write (array_desc
, &c
, 1);
741 /* do this so it looks like there's keyboard echo */
742 if (c
== 3) /* exit on Control-C */
745 fputc_unfiltered (c
, gdb_stdout
);
746 gdb_flush (gdb_stdout
);
750 serial_set_tty_state (tty_desc
, ttystate
);
753 debuglogs (4, "array_wait(), got the expect_prompt.");
756 status
->kind
= TARGET_WAITKIND_STOPPED
;
757 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
759 timeout
= old_timeout
;
761 return inferior_ptid
;
765 * array_fetch_registers -- read the remote registers into the
769 array_fetch_registers (int ignored
)
771 char *reg
= alloca (MAX_REGISTER_RAW_SIZE
);
774 char *packet
= alloca (PBUFSIZ
);
776 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
778 memset (packet
, 0, PBUFSIZ
);
779 make_gdb_packet (packet
, "g");
780 if (array_send_packet (packet
) == 0)
781 error ("Couldn't transmit packet\n");
782 if (array_get_packet (packet
) == 0)
783 error ("Couldn't receive packet\n");
784 /* FIXME: read bytes from packet */
785 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
786 for (regno
= 0; regno
<= PC_REGNUM
+ 4; regno
++)
788 /* supply register stores in target byte order, so swap here */
789 /* FIXME: convert from ASCII hex to raw bytes */
790 LONGEST i
= ascii2hexword (packet
+ (regno
* 8));
791 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
792 store_unsigned_integer (®
, REGISTER_RAW_SIZE (regno
), i
);
793 supply_register (regno
, (char *) ®
);
798 * This is unused by targets like this one that use a
799 * protocol based on GDB's remote protocol.
802 array_fetch_register (int ignored
)
804 array_fetch_registers (0 /* ignored */);
808 * Get all the registers from the targets. They come back in a large array.
811 array_store_registers (int ignored
)
815 char packet
[PBUFSIZ
];
819 debuglogs (1, "array_store_registers()");
821 memset (packet
, 0, PBUFSIZ
);
822 memset (buf
, 0, PBUFSIZ
);
825 /* Unimplemented registers read as all bits zero. */
826 /* FIXME: read bytes from packet */
827 for (regno
= 0; regno
< 41; regno
++)
829 /* supply register stores in target byte order, so swap here */
830 /* FIXME: convert from ASCII hex to raw bytes */
831 i
= (unsigned long) read_register (regno
);
832 hexword2ascii (num
, i
);
833 strcpy (buf
+ (regno
* 8) + 1, num
);
835 *(buf
+ (regno
* 8) + 2) = 0;
836 make_gdb_packet (packet
, buf
);
837 if (array_send_packet (packet
) == 0)
838 error ("Couldn't transmit packet\n");
839 if (array_get_packet (packet
) == 0)
840 error ("Couldn't receive packet\n");
842 registers_changed ();
846 * This is unused by targets like this one that use a
847 * protocol based on GDB's remote protocol.
850 array_store_register (int ignored
)
852 array_store_registers (0 /* ignored */);
855 /* Get ready to modify the registers array. On machines which store
856 individual registers, this doesn't need to do anything. On machines
857 which store all the registers in one fell swoop, this makes sure
858 that registers contains all the registers from the program being
862 array_prepare_to_store (void)
864 /* Do nothing, since we can store individual regs */
868 array_files_info (void)
870 printf ("\tAttached to %s at %d baud.\n",
875 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
876 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
879 array_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
883 char packet
[PBUFSIZ
];
888 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
889 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
892 *p
++ = 'M'; /* The command to write memory */
893 hexword2ascii (num
, memaddr
); /* convert the address */
894 strcpy (p
, num
); /* copy the address */
896 *p
++ = ','; /* add comma delimeter */
897 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
902 *p
++ = ':'; /* add the colon delimeter */
903 for (j
= 0; j
< len
; j
++)
904 { /* copy the data in after converting it */
905 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
906 *p
++ = tohex (myaddr
[j
] & 0xf);
909 make_gdb_packet (packet
, buf
);
910 if (array_send_packet (packet
) == 0)
911 error ("Couldn't transmit packet\n");
912 if (array_get_packet (packet
) == 0)
913 error ("Couldn't receive packet\n");
919 * array_read_inferior_memory -- read LEN bytes from inferior memory
920 * at MEMADDR. Put the result at debugger address MYADDR. Returns
924 array_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
928 char packet
[PBUFSIZ
];
929 int count
; /* Number of bytes read so far. */
930 unsigned long startaddr
; /* Starting address of this pass. */
931 int len_this_pass
; /* Number of bytes to read in this pass. */
933 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
935 /* Note that this code works correctly if startaddr is just less
936 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
937 thing). That is, something like
938 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
939 works--it never adds len To memaddr and gets 0. */
940 /* However, something like
941 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
942 doesn't need to work. Detect it and give up if there's an attempt
944 if (((memaddr
- 1) + len
) < memaddr
)
950 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
952 /* Try to align to 16 byte boundry (why?) */
954 if ((startaddr
% 16) != 0)
956 len_this_pass
-= startaddr
% 16;
958 /* Only transfer bytes we need */
959 if (len_this_pass
> (len
- count
))
961 len_this_pass
= (len
- count
);
963 /* Fetch the bytes */
964 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
966 sprintf (buf
, "m%08lx,%04x", startaddr
, len_this_pass
);
967 make_gdb_packet (packet
, buf
);
968 if (array_send_packet (packet
) == 0)
970 error ("Couldn't transmit packet\n");
972 if (array_get_packet (packet
) == 0)
974 error ("Couldn't receive packet\n");
978 error ("Got no data in the GDB packet\n");
980 /* Pick packet apart and xfer bytes to myaddr */
981 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
982 for (j
= 0; j
< len_this_pass
; j
++)
984 /* extract the byte values */
985 myaddr
[count
++] = from_hex (*(packet
+ (j
* 2))) * 16 + from_hex (*(packet
+ (j
* 2) + 1));
986 debuglogs (5, "myaddr[%d] set to %x\n", count
- 1, myaddr
[count
- 1]);
992 /* Transfer LEN bytes between GDB address MYADDR and target address
993 MEMADDR. If WRITE is non-zero, transfer them to the target,
994 otherwise transfer them from the target. TARGET is unused.
996 Returns the number of bytes transferred. */
999 array_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1000 struct mem_attrib
*attrib
, struct target_ops
*target
)
1003 return array_write_inferior_memory (memaddr
, myaddr
, len
);
1005 return array_read_inferior_memory (memaddr
, myaddr
, len
);
1009 array_kill (char *args
, int from_tty
)
1011 return; /* ignore attempts to kill target system */
1014 /* Clean up when a program exits.
1015 The program actually lives on in the remote processor's RAM, and may be
1016 run again without a download. Don't leave it full of breakpoint
1020 array_mourn_inferior (void)
1022 remove_breakpoints ();
1023 generic_mourn_inferior (); /* Do all the proper things now */
1026 #define MAX_ARRAY_BREAKPOINTS 16
1028 static CORE_ADDR breakaddr
[MAX_ARRAY_BREAKPOINTS
] =
1032 * array_insert_breakpoint -- add a breakpoint
1035 array_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
1039 CORE_ADDR bp_addr
= addr
;
1041 debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr
);
1042 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
1044 for (i
= 0; i
<= MAX_ARRAY_BREAKPOINTS
; i
++)
1046 if (breakaddr
[i
] == 0)
1048 breakaddr
[i
] = addr
;
1049 if (sr_get_debug () > 4)
1050 printf ("Breakpoint at %s\n", paddr_nz (addr
));
1051 array_read_inferior_memory (bp_addr
, shadow
, bp_size
);
1052 printf_monitor ("b 0x%x\n", addr
);
1058 fprintf_unfiltered (gdb_stderr
, "Too many breakpoints (> 16) for monitor\n");
1063 * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1066 array_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
1070 debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr
);
1072 for (i
= 0; i
< MAX_ARRAY_BREAKPOINTS
; i
++)
1074 if (breakaddr
[i
] == addr
)
1077 /* some monitors remove breakpoints based on the address */
1078 printf_monitor ("bd %x\n", i
);
1083 fprintf_unfiltered (gdb_stderr
,
1084 "Can't find breakpoint associated with 0x%s\n",
1092 debuglogs (1, "array_stop()");
1093 printf_monitor ("\003");
1098 * array_command -- put a command string, in args, out to MONITOR.
1099 * Output from MONITOR is placed on the users terminal until the
1100 * expect_prompt is seen. FIXME
1103 monitor_command (char *args
, int fromtty
)
1105 debuglogs (1, "monitor_command (args=%s)", args
);
1107 if (array_desc
== NULL
)
1108 error ("monitor target not open.");
1111 error ("Missing command.");
1113 printf_monitor ("%s\n", args
);
1118 * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1119 * A debug packet whose contents are <data>
1120 * is encapsulated for transmission in the form:
1122 * $ <data> # CSUM1 CSUM2
1124 * <data> must be ASCII alphanumeric and cannot include characters
1125 * '$' or '#'. If <data> starts with two characters followed by
1126 * ':', then the existing stubs interpret this as a sequence number.
1128 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1129 * checksum of <data>, the most significant nibble is sent first.
1130 * the hex digits 0-9,a-f are used.
1134 make_gdb_packet (char *buf
, char *data
)
1137 unsigned char csum
= 0;
1141 debuglogs (3, "make_gdb_packet(%s)\n", data
);
1142 cnt
= strlen (data
);
1144 error ("make_gdb_packet(): to much data\n");
1146 /* start with the packet header */
1150 /* calculate the checksum */
1151 for (i
= 0; i
< cnt
; i
++)
1157 /* terminate the data with a '#' */
1160 /* add the checksum as two ascii digits */
1161 *p
++ = tohex ((csum
>> 4) & 0xf);
1162 *p
++ = tohex (csum
& 0xf);
1163 *p
= 0x0; /* Null terminator on string */
1167 * array_send_packet -- send a GDB packet to the target with error handling. We
1168 * get a '+' (ACK) back if the packet is received and the checksum
1169 * matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1170 * successful transmition, or a 0 for a failure.
1173 array_send_packet (char *packet
)
1181 /* scan the packet to make sure it only contains valid characters.
1182 this may sound silly, but sometimes a garbled packet will hang
1183 the target board. We scan the whole thing, then print the error
1186 for (i
= 0; i
< strlen (packet
); i
++)
1188 debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet
[i
]);
1189 /* legit hex numbers or command */
1190 if ((isxdigit (packet
[i
])) || (isalpha (packet
[i
])))
1196 case '#': /* end of packet */
1197 case '$': /* start of packet */
1199 default: /* bogus character */
1201 debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet
[i
]);
1207 error ("Can't send packet, found %d non-ascii characters", retries
);
1209 /* ok, try to send the packet */
1211 while (retries
++ <= 10)
1213 printf_monitor ("%s", packet
);
1215 /* read until either a timeout occurs (-2) or '+' is read */
1216 while (retries
<= 10)
1218 c
= readchar (-timeout
);
1219 debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c
);
1223 debuglogs (3, "Got Ack\n");
1225 case SERIAL_TIMEOUT
:
1226 debuglogs (3, "Timed out reading serial port\n");
1227 printf_monitor ("@"); /* resync with the monitor */
1228 expect_prompt (1); /* See if we get a expect_prompt */
1229 break; /* Retransmit buffer */
1231 debuglogs (3, "Got NAK\n");
1232 printf_monitor ("@"); /* resync with the monitor */
1233 expect_prompt (1); /* See if we get a expect_prompt */
1236 /* it's probably an old response, or the echo of our command.
1237 * just gobble up the packet and ignore it.
1239 debuglogs (3, "Got a junk packet\n");
1243 c
= readchar (timeout
);
1247 c
= readchar (timeout
);
1249 c
= readchar (timeout
);
1252 debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk
);
1253 continue; /* Now, go look for next packet */
1258 debuglogs (3, "Retransmitting packet \"%s\"\n", packet
);
1259 break; /* Here to retransmit */
1266 * array_get_packet -- get a GDB packet from the target. Basically we read till we
1267 * see a '#', then check the checksum. It returns a 1 if it's gotten a
1268 * packet, or a 0 it the packet wasn't transmitted correctly.
1271 array_get_packet (char *packet
)
1276 unsigned char pktcsum
;
1282 memset (packet
, 1, PBUFSIZ
);
1284 while (retries
<= 10)
1288 c
= readchar (timeout
);
1289 if (c
== SERIAL_TIMEOUT
)
1291 debuglogs (3, "array_get_packet: got time out from serial port.\n");
1293 debuglogs (3, "Waiting for a '$', got a %c\n", c
);
1298 while (retries
<= 10)
1300 c
= readchar (timeout
);
1301 debuglogs (3, "array_get_packet: got a '%c'\n", c
);
1304 case SERIAL_TIMEOUT
:
1305 debuglogs (3, "Timeout in mid-packet, retrying\n");
1308 debuglogs (3, "Saw new packet start in middle of old one\n");
1309 return 0; /* Start a new packet, count retries */
1312 pktcsum
= from_hex (readchar (timeout
)) << 4;
1313 pktcsum
|= from_hex (readchar (timeout
));
1315 debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1316 if (csum
== pktcsum
)
1318 debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet
);
1319 printf_monitor ("@");
1323 debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum
, csum
);
1325 case '*': /* Run length encoding */
1326 debuglogs (5, "Run length encoding in packet\n");
1328 c
= readchar (timeout
);
1330 c
= c
- ' ' + 3; /* Compute repeat count */
1332 if (c
> 0 && c
< 255 && bp
+ c
- 1 < packet
+ PBUFSIZ
- 1)
1334 memset (bp
, *(bp
- 1), c
);
1339 printf_filtered ("Repeat count %d too large for buffer.\n", c
);
1343 if ((!isxdigit (c
)) && (!ispunct (c
)))
1344 debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c
);
1345 if (bp
< packet
+ PBUFSIZ
- 1)
1353 puts_filtered ("Remote packet too long.\n");
1358 return 0; /* exceeded retries */
1362 * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1364 static unsigned long
1365 ascii2hexword (unsigned char *mem
)
1372 for (i
= 0; i
< 8; i
++)
1375 if (mem
[i
] >= 'A' && mem
[i
] <= 'F')
1376 val
= val
+ mem
[i
] - 'A' + 10;
1377 if (mem
[i
] >= 'a' && mem
[i
] <= 'f')
1378 val
= val
+ mem
[i
] - 'a' + 10;
1379 if (mem
[i
] >= '0' && mem
[i
] <= '9')
1380 val
= val
+ mem
[i
] - '0';
1384 debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val
, buf
, mem
);
1389 * ascii2hexword -- convert a hex value to an ascii number represented by 8
1393 hexword2ascii (unsigned char *mem
, unsigned long num
)
1398 debuglogs (4, "hexword2ascii() converting %x ", num
);
1399 for (i
= 7; i
>= 0; i
--)
1401 mem
[i
] = tohex ((num
>> 4) & 0xf);
1402 mem
[i
] = tohex (num
& 0xf);
1406 debuglogs (4, "\tto a %s", mem
);
1409 /* Convert hex digit A to a number. */
1416 debuglogs (4, "from_hex got a 0x%x(%c)\n", a
, a
);
1417 if (a
>= '0' && a
<= '9')
1419 if (a
>= 'a' && a
<= 'f')
1420 return a
- 'a' + 10;
1421 if (a
>= 'A' && a
<= 'F')
1422 return a
- 'A' + 10;
1425 error ("Reply contains invalid hex digit 0x%x", a
);
1429 /* Convert number NIB to a hex digit. */
1436 return 'a' + nib
- 10;
1440 * _initialize_remote_monitors -- setup a few addtitional commands that
1441 * are usually only used by monitors.
1444 _initialize_remote_monitors (void)
1446 /* generic monitor command */
1447 add_com ("monitor", class_obscure
, monitor_command
,
1448 "Send a command to the debug monitor.");
1453 * _initialize_array -- do any special init stuff for the target.
1456 _initialize_array (void)
1459 add_target (&array_ops
);