1 /* Generic support for remote debugging interfaces.
3 Copyright 1993, 1994 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* This file actually contains two distinct logical "packages". They
22 are packaged together in this one file because they are typically
25 The first package is an addition to the serial package. The
26 addition provides reading and writing with debugging output and
27 timeouts based on user settable variables. These routines are
28 intended to support serial port based remote backends. These
29 functions are prefixed with sr_.
31 The second package is a collection of more or less generic
32 functions for use by remote backends. They support user settable
33 variables for debugging, retries, and the like.
37 * a pass through mode a la kermit or telnet.
39 * ask remote to change his baud rate.
45 #include "gdb_string.h"
49 #include "gdbcore.h" /* for exec_bfd */
50 #include "inferior.h" /* for generic_mourn_inferior */
51 #include "remote-utils.h"
53 struct _sr_settings sr_settings
= {
56 remote-bug.c had "with a timeout of 2, we time out waiting for
57 the prompt after an s-record dump."
59 remote.c had (2): This was 5 seconds, which is a long time to
60 sit and wait. Unless this is going though some terminal server
61 or multiplexer or other form of hairy serial connection, I
62 would think 2 seconds would be plenty.
67 NULL
, /* descriptor */
70 struct gr_settings
*gr_settings
= NULL
;
72 static void usage
PARAMS ((char *, char *));
73 static void sr_com
PARAMS ((char *, int));
81 fprintf_unfiltered(gdb_stderr
, "Unrecognized arguments: `%s'.\n", junk
);
83 error ("Usage: target %s [DEVICE [SPEED [DEBUG]]]\n\
84 where DEVICE is the name of a device or HOST:PORT", proto
, proto
);
89 #define CHECKDONE(p, q) \
101 sr_scan_args(proto
, args
)
108 /* if no args, then nothing to do. */
109 if (args
== NULL
|| *args
== '\0')
112 /* scan off white space. */
113 for (p
= args
; isspace(*p
); ++p
) ;;
115 /* find end of device name. */
116 for (q
= p
; *q
!= '\0' && !isspace(*q
); ++q
) ;;
118 /* check for missing or empty device name. */
120 sr_set_device(savestring(p
, q
- p
));
122 /* look for baud rate. */
123 n
= strtol(q
, &p
, 10);
125 /* check for missing or empty baud rate. */
129 /* look for debug value. */
130 n
= strtol(p
, &q
, 10);
132 /* check for missing or empty debug value. */
136 /* scan off remaining white space. */
137 for (p
= q
; isspace(*p
); ++p
) ;;
139 /* if not end of string, then there's unrecognized junk. */
154 gr_open(args
, from_tty
, gr
)
157 struct gr_settings
*gr
;
159 target_preopen(from_tty
);
160 sr_scan_args(gr
->ops
->to_shortname
, args
);
161 unpush_target(gr
->ops
);
165 gr_set_dcache(dcache_init(gr
->readfunc
, gr
->writefunc
));
167 if (sr_get_desc() != NULL
)
170 /* If no args are specified, then we use the device specified by a
171 previous command or "set remotedevice". But if there is no
172 device, better stop now, not dump core. */
174 if (sr_get_device () == NULL
)
175 usage (gr
->ops
->to_shortname
, NULL
);
177 sr_set_desc(SERIAL_OPEN (sr_get_device()));
179 perror_with_name((char *) sr_get_device());
183 if (SERIAL_SETBAUDRATE(sr_get_desc(), baud_rate
) != 0)
185 SERIAL_CLOSE(sr_get_desc());
186 perror_with_name(sr_get_device());
190 SERIAL_RAW (sr_get_desc());
192 /* If there is something sitting in the buffer we might take it as a
193 response to a command, which would be bad. */
194 SERIAL_FLUSH_INPUT (sr_get_desc ());
196 /* default retries */
197 if (sr_get_retries() == 0)
200 /* default clear breakpoint function */
201 if (gr_settings
->clear_all_breakpoints
== NULL
)
202 gr_settings
->clear_all_breakpoints
= remove_breakpoints
;
206 printf_filtered ("Remote debugging using `%s'", sr_get_device ());
208 printf_filtered (" at baud rate of %d",
210 printf_filtered ("\n");
213 push_target(gr
->ops
);
215 gr_clear_all_breakpoints ();
219 /* Read a character from the remote system masking it down to 7 bits
220 and doing all the fancy timeout stuff. */
227 buf
= SERIAL_READCHAR (sr_get_desc(), sr_get_timeout());
229 if (buf
== SERIAL_TIMEOUT
)
230 error ("Timeout reading from remote system.");
232 if (sr_get_debug() > 0)
233 printf_unfiltered ("%c", buf
);
243 buf
= SERIAL_READCHAR (sr_get_desc(), 0);
244 if (buf
== SERIAL_TIMEOUT
)
246 if (sr_get_debug() > 0)
248 printf_unfiltered ("%c", buf
);
250 printf_unfiltered ("<empty character poll>");
255 /* Keep discarding input from the remote system, until STRING is found.
256 Let the user break out immediately. */
266 if (sr_readchar () == *p
)
287 if (SERIAL_WRITE (sr_get_desc(), a
, l
) != 0)
288 perror_with_name ("sr_write: Error writing to remote");
290 if (sr_get_debug() > 0)
291 for (i
= 0; i
< l
; i
++)
292 printf_unfiltered ("%c", a
[i
]);
301 sr_write (s
, strlen (s
));
307 sr_timed_read (buf
, n
)
328 /* Get a hex digit from the remote system & return its value. If
329 ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
332 sr_get_hex_digit (ignore_space
)
340 if (ch
>= '0' && ch
<= '9')
342 else if (ch
>= 'A' && ch
<= 'F')
343 return ch
- 'A' + 10;
344 else if (ch
>= 'a' && ch
<= 'f')
345 return ch
- 'a' + 10;
346 else if (ch
!= ' ' || !ignore_space
)
349 error ("Invalid hex digit from remote system.");
354 /* Get a byte from the remote and put it in *BYT. Accept any number
357 sr_get_hex_byte (byt
)
362 val
= sr_get_hex_digit (1) << 4;
363 val
|= sr_get_hex_digit (0);
367 /* Read a 32-bit hex word from the remote, preceded by a space */
375 for (j
= 0; j
< 8; j
++)
376 val
= (val
<< 4) + sr_get_hex_digit (j
== 0);
380 /* Put a command string, in args, out to the remote. The remote is assumed to
381 be in raw mode, all writing/reading done through desc.
382 Ouput from the remote is placed on the users terminal until the
383 prompt from the remote is seen.
384 FIXME: Can't handle commands that take input. */
387 sr_com (args
, fromtty
)
396 /* Clear all input so only command relative output is displayed */
399 sr_write ("\030", 1);
400 registers_changed ();
408 gr_clear_all_breakpoints();
412 SERIAL_CLOSE (sr_get_desc());
420 takes a program previously attached to and detaches it.
421 We better not have left any breakpoints
422 in the program or it'll die when it hits one.
423 Close the open connection to the remote debugger.
424 Use this when you want to detach and do something else
428 gr_detach(args
, from_tty
)
433 error ("Argument given to \"detach\" when remotely debugging.");
436 gr_clear_all_breakpoints ();
440 puts_filtered ("Ending remote debugging.\n");
447 struct target_ops
*ops
;
450 printf_filtered ("\tAttached to DOS asynctsr\n");
452 printf_filtered ("\tAttached to %s", sr_get_device());
454 printf_filtered ("at %d baud", baud_rate
);
455 printf_filtered ("\n");
460 printf_filtered ("\tand running program %s\n",
461 bfd_get_filename (exec_bfd
));
463 printf_filtered ("\tusing the %s protocol.\n", ops
->to_shortname
);
469 gr_clear_all_breakpoints ();
470 unpush_target (gr_get_ops());
471 generic_mourn_inferior ();
480 /* This is called not only when we first attach, but also when the
481 user types "run" after having attached. */
483 gr_create_inferior (execfile
, args
, env
)
491 error ("Can't pass arguments to remote process.");
493 if (execfile
== 0 || exec_bfd
== 0)
494 error ("No exec file specified");
496 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
500 gr_clear_all_breakpoints ();
502 init_wait_for_inferior ();
505 insert_breakpoints (); /* Needed to get correct instruction in cache */
506 proceed (entry_pt
, -1, 0);
509 /* Given a null terminated list of strings LIST, read the input until we find one of
510 them. Return the index of the string found or -1 on error. '?' means match
511 any single character. Note that with the algorithm we use, the initial
512 character of the string cannot recur in the string, or we will not find some
513 cases of the string in the input. If PASSTHROUGH is non-zero, then
514 pass non-matching data on. */
517 gr_multi_scan (list
, passthrough
)
521 char *swallowed
= NULL
; /* holding area */
522 char *swallowed_p
= swallowed
; /* Current position in swallowed. */
530 /* Look through the strings. Count them. Find the largest one so we can
531 allocate a holding area. */
533 for (max_length
= string_count
= i
= 0;
537 int length
= strlen(list
[i
]);
539 if (length
> max_length
)
543 /* if we have no strings, then something is wrong. */
544 if (string_count
== 0)
547 /* otherwise, we will need a holding area big enough to hold almost two
548 copies of our largest string. */
549 swallowed_p
= swallowed
= alloca(max_length
<< 1);
551 /* and a list of pointers to current scan points. */
552 plist
= (char **) alloca (string_count
* sizeof(*plist
));
555 for (i
= 0; i
< string_count
; ++i
)
558 for (ch
= sr_readchar(); /* loop forever */ ; ch
= sr_readchar())
560 QUIT
; /* Let user quit and leave process running */
563 for (i
= 0; i
< string_count
; ++i
)
565 if (ch
== *plist
[i
] || *plist
[i
] == '?')
568 if (*plist
[i
] == '\0')
584 /* Print out any characters which have been swallowed. */
587 for (p
= swallowed
; p
< swallowed_p
; ++p
)
588 fputc_unfiltered (*p
, gdb_stdout
);
590 fputc_unfiltered (ch
, gdb_stdout
);
593 swallowed_p
= swallowed
;
602 /* Get ready to modify the registers array. On machines which store
603 individual registers, this doesn't need to do anything. On machines
604 which store all the registers in one fell swoop, this makes sure
605 that registers contains all the registers from the program being
609 gr_prepare_to_store ()
611 /* Do nothing, since we assume we can store individual regs */
614 /* Read a word from remote address ADDR and return it.
615 * This goes through the data cache.
621 return dcache_fetch (gr_get_dcache(), addr
);
624 /* Write a word WORD into remote address ADDR.
625 This goes through the data cache. */
628 gr_store_word (addr
, word
)
632 dcache_poke (gr_get_dcache(), addr
, word
);
636 _initialize_sr_support ()
638 /* FIXME-now: if target is open... */
639 add_show_from_set (add_set_cmd ("remotedevice", no_class
,
640 var_filename
, (char *)&sr_settings
.device
,
641 "Set device for remote serial I/O.\n\
642 This device is used as the serial port when debugging using remote\n\
643 targets.", &setlist
),
646 add_com ("remote <command>", class_obscure
, sr_com
,
647 "Send a command to the remote monitor.");
This page took 0.041188 seconds and 4 git commands to generate.