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 (stderr
, "serial_write failed: %s\n", safe_strerror (errno
));
199 * write_monitor -- send raw data to monitor.
202 write_monitor (char data
[], int len
)
204 if (serial_write (array_desc
, data
, len
))
205 fprintf (stderr
, "serial_write failed: %s\n", safe_strerror (errno
));
207 *(data
+ len
+ 1) = '\0';
208 debuglogs (1, "write_monitor(), Sending: \"%s\".", data
);
213 * debuglogs -- deal with debugging info to multiple sources. This takes
214 * two real args, the first one is the level to be compared against
215 * the sr_get_debug() value, the second arg is a printf buffer and args
216 * to be formatted and printed. A CR is added after each string is printed.
219 debuglogs (int level
, char *pattern
,...)
223 unsigned char buf
[PBUFSIZ
];
224 char newbuf
[PBUFSIZ
];
227 va_start (args
, pattern
);
229 if ((level
< 0) || (level
> 100))
231 error ("Bad argument passed to debuglogs(), needs debug level");
235 vsprintf (buf
, pattern
, args
); /* format the string */
237 /* convert some characters so it'll look right in the log */
239 for (i
= 0; buf
[i
] != '\0'; i
++)
242 error ("Debug message too long");
245 case '\n': /* newlines */
249 case '\r': /* carriage returns */
253 case '\033': /* escape */
261 case '\b': /* backspace */
265 default: /* no change */
270 { /* modify control characters */
276 { /* modify control characters */
282 *p
= '\0'; /* terminate the string */
284 if (sr_get_debug () > level
)
285 printf_unfiltered ("%s\n", newbuf
);
287 #ifdef LOG_FILE /* write to the monitor log */
290 fputs (newbuf
, log_file
);
291 fputc ('\n', log_file
);
297 /* readchar -- read a character from the remote system, doing all the fancy
301 readchar (int timeout
)
305 c
= serial_readchar (array_desc
, abs (timeout
));
307 if (sr_get_debug () > 5)
310 debuglogs (5, "readchar: timeout = %d\n", timeout
);
315 putc (c
& 0x7f, log_file
);
321 if (c
== SERIAL_TIMEOUT
)
324 return c
; /* Polls shouldn't generate timeout errors */
325 error ("Timeout reading from remote system.");
327 fputs ("ERROR: Timeout reading from remote system", log_file
);
330 perror_with_name ("readchar");
334 * expect -- scan input from the remote system, until STRING is found.
335 * If DISCARD is non-zero, then discard non-matching input, else print
336 * it out. Let the user break out immediately.
339 expect (char *string
, int discard
)
345 debuglogs (1, "Expecting \"%s\".", string
);
350 c
= readchar (timeout
);
358 debuglogs (4, "Matched");
366 fputc_unfiltered (c
, gdb_stdout
);
373 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
375 The convention for dealing with the expect_prompt is that you
377 o *then* wait for the expect_prompt.
379 Thus the last thing that a procedure does with the serial line
380 will be an expect_prompt(). Exception: array_resume does not
381 wait for the expect_prompt, because the terminal is being handed over
382 to the inferior. However, the next thing which happens after that
383 is a array_wait which does wait for the expect_prompt.
384 Note that this includes abnormal exit, e.g. error(). This is
385 necessary to prevent getting into states from which we can't
388 expect_prompt (int discard
)
390 expect (ARRAY_PROMPT
, discard
);
394 * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
407 if (sr_get_debug () > 5)
408 debuglogs (5, "Ignoring \'%c\'.", ch
);
411 if (sr_get_debug () > 5)
412 debuglogs (5, "Accepting \'%c\'.", ch
);
418 * get_hex_digit -- Get a hex digit from the remote system & return its value.
419 * If ignore is nonzero, ignore spaces, newline & tabs.
422 get_hex_digit (int ignore
)
427 ch
= readchar (timeout
);
430 if (sr_get_debug () > 4)
432 debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch
, ch
);
436 #ifdef LOG_FILE /* write to the monitor log */
439 fputs ("get_hex_digit() got a 0x", log_file
);
440 fputc (ch
, log_file
);
441 fputc ('\n', log_file
);
447 if (ch
>= '0' && ch
<= '9')
449 else if (ch
>= 'A' && ch
<= 'F')
450 return ch
- 'A' + 10;
451 else if (ch
>= 'a' && ch
<= 'f')
452 return ch
- 'a' + 10;
453 else if (ch
== ' ' && ignore
)
458 debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch
);
459 error ("Invalid hex digit from remote system. (0x%x)", ch
);
464 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
465 * Accept any number leading spaces.
468 get_hex_byte (char *byt
)
472 val
= get_hex_digit (1) << 4;
473 debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val
);
475 val
|= get_hex_digit (0);
476 debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val
);
479 debuglogs (4, "get_hex_byte() -- Read a 0x%x", val
);
483 * get_hex_word -- Get N 32-bit words from remote, each preceded by a space,
484 * and put them in registers starting at REGNO.
494 for (i
= 0; i
< 8; i
++)
495 val
= (val
<< 4) + get_hex_digit (i
== 0);
497 debuglogs (4, "get_hex_word() got a 0x%x.", val
);
502 /* This is called not only when we first attach, but also when the
503 user types "run" after having attached. */
505 array_create_inferior (char *execfile
, char *args
, char **env
)
510 error ("Can't pass arguments to remote MONITOR process");
512 if (execfile
== 0 || exec_bfd
== 0)
513 error ("No executable file specified");
515 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
517 /* The "process" (board) is already stopped awaiting our commands, and
518 the program is already downloaded. We just set its PC and go. */
520 clear_proceed_status ();
522 /* Tell wait_for_inferior that we've started a new process. */
523 init_wait_for_inferior ();
525 /* Set up the "saved terminal modes" of the inferior
526 based on what modes we are starting it with. */
527 target_terminal_init ();
529 /* Install inferior's terminal modes. */
530 target_terminal_inferior ();
532 /* insert_step_breakpoint (); FIXME, do we need this? */
535 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
539 * array_open -- open a connection to a remote debugger.
540 * NAME is the filename used for communication.
542 static int baudrate
= 9600;
543 static char dev_name
[100];
546 array_open (char *args
, char *name
, int from_tty
)
548 char packet
[PBUFSIZ
];
551 error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
552 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name
, name
);
557 target_preopen (from_tty
);
558 unpush_target (&array_ops
);
560 tmp_mips_processor_type
= "lsi33k"; /* change the default from r3051 */
561 mips_set_processor_type_command ("lsi33k", 0);
563 strcpy (dev_name
, args
);
564 array_desc
= serial_open (dev_name
);
566 if (array_desc
== NULL
)
567 perror_with_name (dev_name
);
571 if (serial_setbaudrate (array_desc
, baud_rate
))
573 serial_close (array_desc
);
574 perror_with_name (name
);
578 serial_raw (array_desc
);
580 #if defined (LOG_FILE)
581 log_file
= fopen (LOG_FILE
, "w");
582 if (log_file
== NULL
)
583 perror_with_name (LOG_FILE
);
584 fprintf (log_file
, "GDB %s (%s", version
, host_name
);
585 fprintf (log_file
, " --target %s)\n", array_ops
.to_shortname
);
586 fprintf (log_file
, "Remote target %s connected to %s\n\n", array_ops
.to_shortname
, dev_name
);
589 /* see if the target is alive. For a ROM monitor, we can just try to force the
590 expect_prompt to print a few times. For the GDB remote protocol, the application
591 being debugged is sitting at a breakpoint and waiting for GDB to initialize
592 the connection. We force it to give us an empty packet to see if it's alive.
594 debuglogs (3, "Trying to ACK the target's debug stub");
595 /* unless your are on the new hardware, the old board won't initialize
596 because the '@' doesn't flush output like it does on the new ROMS.
598 printf_monitor ("@"); /* ask for the last signal */
599 expect_prompt (1); /* See if we get a expect_prompt */
600 #ifdef TEST_ARRAY /* skip packet for testing */
601 make_gdb_packet (packet
, "?"); /* ask for a bogus packet */
602 if (array_send_packet (packet
) == 0)
603 error ("Couldn't transmit packet\n");
604 printf_monitor ("@\n"); /* force it to flush stdout */
605 expect_prompt (1); /* See if we get a expect_prompt */
607 push_target (&array_ops
);
609 printf ("Remote target %s connected to %s\n", array_ops
.to_shortname
, dev_name
);
613 * array_close -- Close out all files and local state before this
614 * target loses control.
618 array_close (int quitting
)
620 serial_close (array_desc
);
623 debuglogs (1, "array_close (quitting=%d)", quitting
);
625 #if defined (LOG_FILE)
628 if (ferror (log_file
))
629 printf_filtered ("Error writing log file.\n");
630 if (fclose (log_file
) != 0)
631 printf_filtered ("Error closing log file.\n");
637 * array_detach -- terminate the open connection to the remote
638 * debugger. Use this when you want to detach and do something
639 * else with your gdb.
642 array_detach (int from_tty
)
645 debuglogs (1, "array_detach ()");
647 pop_target (); /* calls array_close to do the real work */
649 printf ("Ending remote %s debugging\n", target_shortname
);
653 * array_attach -- attach GDB to the target.
656 array_attach (char *args
, int from_tty
)
659 printf ("Starting remote %s debugging\n", target_shortname
);
661 debuglogs (1, "array_attach (args=%s)", args
);
663 printf_monitor ("go %x\n");
664 /* swallow the echo. */
665 expect ("go %x\n", 1);
669 * array_resume -- Tell the remote machine to resume.
672 array_resume (ptid_t ptid
, int step
, enum target_signal sig
)
674 debuglogs (1, "array_resume (step=%d, sig=%d)", step
, sig
);
678 printf_monitor ("s\n");
682 printf_monitor ("go\n");
689 * array_wait -- Wait until the remote machine stops, then return,
690 * storing status in status just as `wait' would.
693 array_wait (ptid_t ptid
, struct target_waitstatus
*status
)
695 int old_timeout
= timeout
;
698 struct serial
*tty_desc
;
699 serial_ttystate ttystate
;
701 debuglogs (1, "array_wait (), printing extraneous text.");
703 status
->kind
= TARGET_WAITKIND_EXITED
;
704 status
->value
.integer
= 0;
706 timeout
= 0; /* Don't time out -- user program is running. */
708 #if !defined(__GO32__) && !defined(__MSDOS__) && !defined(_WIN32)
709 tty_desc
= serial_fdopen (0);
710 ttystate
= serial_get_tty_state (tty_desc
);
711 serial_raw (tty_desc
);
714 /* poll on the serial port and the keyboard. */
717 c
= readchar (timeout
);
720 if (c
== *(ARRAY_PROMPT
+ i
))
722 if (++i
>= strlen (ARRAY_PROMPT
))
723 { /* matched the prompt */
724 debuglogs (4, "array_wait(), got the expect_prompt.");
729 { /* not the prompt */
732 fputc_unfiltered (c
, gdb_stdout
);
733 gdb_flush (gdb_stdout
);
735 c
= serial_readchar (tty_desc
, timeout
);
738 serial_write (array_desc
, &c
, 1);
739 /* do this so it looks like there's keyboard echo */
740 if (c
== 3) /* exit on Control-C */
743 fputc_unfiltered (c
, gdb_stdout
);
744 gdb_flush (gdb_stdout
);
748 serial_set_tty_state (tty_desc
, ttystate
);
751 debuglogs (4, "array_wait(), got the expect_prompt.");
754 status
->kind
= TARGET_WAITKIND_STOPPED
;
755 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
757 timeout
= old_timeout
;
759 return inferior_ptid
;
763 * array_fetch_registers -- read the remote registers into the
767 array_fetch_registers (int ignored
)
769 char *reg
= alloca (MAX_REGISTER_RAW_SIZE
);
772 char *packet
= alloca (PBUFSIZ
);
774 debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored
);
776 memset (packet
, 0, PBUFSIZ
);
777 make_gdb_packet (packet
, "g");
778 if (array_send_packet (packet
) == 0)
779 error ("Couldn't transmit packet\n");
780 if (array_get_packet (packet
) == 0)
781 error ("Couldn't receive packet\n");
782 /* FIXME: read bytes from packet */
783 debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet
);
784 for (regno
= 0; regno
<= PC_REGNUM
+ 4; regno
++)
786 /* supply register stores in target byte order, so swap here */
787 /* FIXME: convert from ASCII hex to raw bytes */
788 LONGEST i
= ascii2hexword (packet
+ (regno
* 8));
789 debuglogs (5, "Adding register %d = %x\n", regno
, i
);
790 store_unsigned_integer (®
, REGISTER_RAW_SIZE (regno
), i
);
791 supply_register (regno
, (char *) ®
);
796 * This is unused by targets like this one that use a
797 * protocol based on GDB's remote protocol.
800 array_fetch_register (int ignored
)
802 array_fetch_registers (0 /* ignored */);
806 * Get all the registers from the targets. They come back in a large array.
809 array_store_registers (int ignored
)
813 char packet
[PBUFSIZ
];
817 debuglogs (1, "array_store_registers()");
819 memset (packet
, 0, PBUFSIZ
);
820 memset (buf
, 0, PBUFSIZ
);
823 /* Unimplemented registers read as all bits zero. */
824 /* FIXME: read bytes from packet */
825 for (regno
= 0; regno
< 41; regno
++)
827 /* supply register stores in target byte order, so swap here */
828 /* FIXME: convert from ASCII hex to raw bytes */
829 i
= (unsigned long) read_register (regno
);
830 hexword2ascii (num
, i
);
831 strcpy (buf
+ (regno
* 8) + 1, num
);
833 *(buf
+ (regno
* 8) + 2) = 0;
834 make_gdb_packet (packet
, buf
);
835 if (array_send_packet (packet
) == 0)
836 error ("Couldn't transmit packet\n");
837 if (array_get_packet (packet
) == 0)
838 error ("Couldn't receive packet\n");
840 registers_changed ();
844 * This is unused by targets like this one that use a
845 * protocol based on GDB's remote protocol.
848 array_store_register (int ignored
)
850 array_store_registers (0 /* ignored */);
853 /* Get ready to modify the registers array. On machines which store
854 individual registers, this doesn't need to do anything. On machines
855 which store all the registers in one fell swoop, this makes sure
856 that registers contains all the registers from the program being
860 array_prepare_to_store (void)
862 /* Do nothing, since we can store individual regs */
866 array_files_info (void)
868 printf ("\tAttached to %s at %d baud.\n",
873 * array_write_inferior_memory -- Copy LEN bytes of data from debugger
874 * memory at MYADDR to inferior's memory at MEMADDR. Returns length moved.
877 array_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
881 char packet
[PBUFSIZ
];
886 debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
887 memset (buf
, '\0', PBUFSIZ
); /* this also sets the string terminator */
890 *p
++ = 'M'; /* The command to write memory */
891 hexword2ascii (num
, memaddr
); /* convert the address */
892 strcpy (p
, num
); /* copy the address */
894 *p
++ = ','; /* add comma delimeter */
895 hexword2ascii (num
, len
); /* Get the length as a 4 digit number */
900 *p
++ = ':'; /* add the colon delimeter */
901 for (j
= 0; j
< len
; j
++)
902 { /* copy the data in after converting it */
903 *p
++ = tohex ((myaddr
[j
] >> 4) & 0xf);
904 *p
++ = tohex (myaddr
[j
] & 0xf);
907 make_gdb_packet (packet
, buf
);
908 if (array_send_packet (packet
) == 0)
909 error ("Couldn't transmit packet\n");
910 if (array_get_packet (packet
) == 0)
911 error ("Couldn't receive packet\n");
917 * array_read_inferior_memory -- read LEN bytes from inferior memory
918 * at MEMADDR. Put the result at debugger address MYADDR. Returns
922 array_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
926 char packet
[PBUFSIZ
];
927 int count
; /* Number of bytes read so far. */
928 unsigned long startaddr
; /* Starting address of this pass. */
929 int len_this_pass
; /* Number of bytes to read in this pass. */
931 debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr
, myaddr
, len
);
933 /* Note that this code works correctly if startaddr is just less
934 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
935 thing). That is, something like
936 array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
937 works--it never adds len To memaddr and gets 0. */
938 /* However, something like
939 array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
940 doesn't need to work. Detect it and give up if there's an attempt
942 if (((memaddr
- 1) + len
) < memaddr
)
948 for (count
= 0, startaddr
= memaddr
; count
< len
; startaddr
+= len_this_pass
)
950 /* Try to align to 16 byte boundry (why?) */
952 if ((startaddr
% 16) != 0)
954 len_this_pass
-= startaddr
% 16;
956 /* Only transfer bytes we need */
957 if (len_this_pass
> (len
- count
))
959 len_this_pass
= (len
- count
);
961 /* Fetch the bytes */
962 debuglogs (3, "read %d bytes from inferior address %x", len_this_pass
,
964 sprintf (buf
, "m%08lx,%04x", startaddr
, len_this_pass
);
965 make_gdb_packet (packet
, buf
);
966 if (array_send_packet (packet
) == 0)
968 error ("Couldn't transmit packet\n");
970 if (array_get_packet (packet
) == 0)
972 error ("Couldn't receive packet\n");
976 error ("Got no data in the GDB packet\n");
978 /* Pick packet apart and xfer bytes to myaddr */
979 debuglogs (4, "array_read_inferior_memory: Got a \"%s\" back\n", packet
);
980 for (j
= 0; j
< len_this_pass
; j
++)
982 /* extract the byte values */
983 myaddr
[count
++] = from_hex (*(packet
+ (j
* 2))) * 16 + from_hex (*(packet
+ (j
* 2) + 1));
984 debuglogs (5, "myaddr[%d] set to %x\n", count
- 1, myaddr
[count
- 1]);
990 /* Transfer LEN bytes between GDB address MYADDR and target address
991 MEMADDR. If WRITE is non-zero, transfer them to the target,
992 otherwise transfer them from the target. TARGET is unused.
994 Returns the number of bytes transferred. */
997 array_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
998 struct mem_attrib
*attrib
, struct target_ops
*target
)
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
);