1 /* Generic support for remote debugging interfaces.
3 Copyright 1993, 1994, 1998 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"
54 void _initialize_sr_support
PARAMS ((void));
56 struct _sr_settings sr_settings
= {
59 remote-bug.c had "with a timeout of 2, we time out waiting for
60 the prompt after an s-record dump."
62 remote.c had (2): This was 5 seconds, which is a long time to
63 sit and wait. Unless this is going though some terminal server
64 or multiplexer or other form of hairy serial connection, I
65 would think 2 seconds would be plenty.
70 NULL
, /* descriptor */
73 struct gr_settings
*gr_settings
= NULL
;
75 static void usage
PARAMS ((char *, char *));
76 static void sr_com
PARAMS ((char *, int));
84 fprintf_unfiltered(gdb_stderr
, "Unrecognized arguments: `%s'.\n", junk
);
86 error ("Usage: target %s [DEVICE [SPEED [DEBUG]]]\n\
87 where DEVICE is the name of a device or HOST:PORT", proto
, proto
);
92 #define CHECKDONE(p, q) \
104 sr_scan_args(proto
, args
)
111 /* if no args, then nothing to do. */
112 if (args
== NULL
|| *args
== '\0')
115 /* scan off white space. */
116 for (p
= args
; isspace(*p
); ++p
) ;;
118 /* find end of device name. */
119 for (q
= p
; *q
!= '\0' && !isspace(*q
); ++q
) ;;
121 /* check for missing or empty device name. */
123 sr_set_device(savestring(p
, q
- p
));
125 /* look for baud rate. */
126 n
= strtol(q
, &p
, 10);
128 /* check for missing or empty baud rate. */
132 /* look for debug value. */
133 n
= strtol(p
, &q
, 10);
135 /* check for missing or empty debug value. */
139 /* scan off remaining white space. */
140 for (p
= q
; isspace(*p
); ++p
) ;;
142 /* if not end of string, then there's unrecognized junk. */
157 gr_open(args
, from_tty
, gr
)
160 struct gr_settings
*gr
;
162 target_preopen(from_tty
);
163 sr_scan_args(gr
->ops
->to_shortname
, args
);
164 unpush_target(gr
->ops
);
168 gr_set_dcache(dcache_init(gr
->readfunc
, gr
->writefunc
));
170 if (sr_get_desc() != NULL
)
173 /* If no args are specified, then we use the device specified by a
174 previous command or "set remotedevice". But if there is no
175 device, better stop now, not dump core. */
177 if (sr_get_device () == NULL
)
178 usage (gr
->ops
->to_shortname
, NULL
);
180 sr_set_desc(SERIAL_OPEN (sr_get_device()));
182 perror_with_name((char *) sr_get_device());
186 if (SERIAL_SETBAUDRATE(sr_get_desc(), baud_rate
) != 0)
188 SERIAL_CLOSE(sr_get_desc());
189 perror_with_name(sr_get_device());
193 SERIAL_RAW (sr_get_desc());
195 /* If there is something sitting in the buffer we might take it as a
196 response to a command, which would be bad. */
197 SERIAL_FLUSH_INPUT (sr_get_desc ());
199 /* default retries */
200 if (sr_get_retries() == 0)
203 /* default clear breakpoint function */
204 if (gr_settings
->clear_all_breakpoints
== NULL
)
205 gr_settings
->clear_all_breakpoints
= remove_breakpoints
;
209 printf_filtered ("Remote debugging using `%s'", sr_get_device ());
211 printf_filtered (" at baud rate of %d",
213 printf_filtered ("\n");
216 push_target(gr
->ops
);
218 gr_clear_all_breakpoints ();
222 /* Read a character from the remote system masking it down to 7 bits
223 and doing all the fancy timeout stuff. */
230 buf
= SERIAL_READCHAR (sr_get_desc(), sr_get_timeout());
232 if (buf
== SERIAL_TIMEOUT
)
233 error ("Timeout reading from remote system.");
235 if (sr_get_debug() > 0)
236 printf_unfiltered ("%c", buf
);
246 buf
= SERIAL_READCHAR (sr_get_desc(), 0);
247 if (buf
== SERIAL_TIMEOUT
)
249 if (sr_get_debug() > 0)
252 printf_unfiltered ("%c", buf
);
254 printf_unfiltered ("<empty character poll>");
260 /* Keep discarding input from the remote system, until STRING is found.
261 Let the user break out immediately. */
271 if (sr_readchar () == *p
)
292 if (SERIAL_WRITE (sr_get_desc(), a
, l
) != 0)
293 perror_with_name ("sr_write: Error writing to remote");
295 if (sr_get_debug() > 0)
296 for (i
= 0; i
< l
; i
++)
297 printf_unfiltered ("%c", a
[i
]);
306 sr_write (s
, strlen (s
));
312 sr_timed_read (buf
, n
)
333 /* Get a hex digit from the remote system & return its value. If
334 ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
337 sr_get_hex_digit (ignore_space
)
345 if (ch
>= '0' && ch
<= '9')
347 else if (ch
>= 'A' && ch
<= 'F')
348 return ch
- 'A' + 10;
349 else if (ch
>= 'a' && ch
<= 'f')
350 return ch
- 'a' + 10;
351 else if (ch
!= ' ' || !ignore_space
)
354 error ("Invalid hex digit from remote system.");
359 /* Get a byte from the remote and put it in *BYT. Accept any number
362 sr_get_hex_byte (byt
)
367 val
= sr_get_hex_digit (1) << 4;
368 val
|= sr_get_hex_digit (0);
372 /* Read a 32-bit hex word from the remote, preceded by a space */
380 for (j
= 0; j
< 8; j
++)
381 val
= (val
<< 4) + sr_get_hex_digit (j
== 0);
385 /* Put a command string, in args, out to the remote. The remote is assumed to
386 be in raw mode, all writing/reading done through desc.
387 Ouput from the remote is placed on the users terminal until the
388 prompt from the remote is seen.
389 FIXME: Can't handle commands that take input. */
392 sr_com (args
, fromtty
)
401 /* Clear all input so only command relative output is displayed */
404 sr_write ("\030", 1);
405 registers_changed ();
413 gr_clear_all_breakpoints();
417 SERIAL_CLOSE (sr_get_desc());
425 takes a program previously attached to and detaches it.
426 We better not have left any breakpoints
427 in the program or it'll die when it hits one.
428 Close the open connection to the remote debugger.
429 Use this when you want to detach and do something else
433 gr_detach(args
, from_tty
)
438 error ("Argument given to \"detach\" when remotely debugging.");
441 gr_clear_all_breakpoints ();
445 puts_filtered ("Ending remote debugging.\n");
452 struct target_ops
*ops
;
455 printf_filtered ("\tAttached to DOS asynctsr\n");
457 printf_filtered ("\tAttached to %s", sr_get_device());
459 printf_filtered ("at %d baud", baud_rate
);
460 printf_filtered ("\n");
465 printf_filtered ("\tand running program %s\n",
466 bfd_get_filename (exec_bfd
));
468 printf_filtered ("\tusing the %s protocol.\n", ops
->to_shortname
);
474 gr_clear_all_breakpoints ();
475 unpush_target (gr_get_ops());
476 generic_mourn_inferior ();
485 /* This is called not only when we first attach, but also when the
486 user types "run" after having attached. */
488 gr_create_inferior (execfile
, args
, env
)
496 error ("Can't pass arguments to remote process.");
498 if (execfile
== 0 || exec_bfd
== 0)
499 error ("No executable file specified");
501 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
505 gr_clear_all_breakpoints ();
507 init_wait_for_inferior ();
510 insert_breakpoints (); /* Needed to get correct instruction in cache */
511 proceed (entry_pt
, -1, 0);
514 /* Given a null terminated list of strings LIST, read the input until we find one of
515 them. Return the index of the string found or -1 on error. '?' means match
516 any single character. Note that with the algorithm we use, the initial
517 character of the string cannot recur in the string, or we will not find some
518 cases of the string in the input. If PASSTHROUGH is non-zero, then
519 pass non-matching data on. */
522 gr_multi_scan (list
, passthrough
)
526 char *swallowed
= NULL
; /* holding area */
527 char *swallowed_p
= swallowed
; /* Current position in swallowed. */
535 /* Look through the strings. Count them. Find the largest one so we can
536 allocate a holding area. */
538 for (max_length
= string_count
= i
= 0;
542 int length
= strlen(list
[i
]);
544 if (length
> max_length
)
548 /* if we have no strings, then something is wrong. */
549 if (string_count
== 0)
552 /* otherwise, we will need a holding area big enough to hold almost two
553 copies of our largest string. */
554 swallowed_p
= swallowed
= alloca(max_length
<< 1);
556 /* and a list of pointers to current scan points. */
557 plist
= (char **) alloca (string_count
* sizeof(*plist
));
560 for (i
= 0; i
< string_count
; ++i
)
563 for (ch
= sr_readchar(); /* loop forever */ ; ch
= sr_readchar())
565 QUIT
; /* Let user quit and leave process running */
568 for (i
= 0; i
< string_count
; ++i
)
570 if (ch
== *plist
[i
] || *plist
[i
] == '?')
573 if (*plist
[i
] == '\0')
589 /* Print out any characters which have been swallowed. */
592 for (p
= swallowed
; p
< swallowed_p
; ++p
)
593 fputc_unfiltered (*p
, gdb_stdout
);
595 fputc_unfiltered (ch
, gdb_stdout
);
598 swallowed_p
= swallowed
;
607 /* Get ready to modify the registers array. On machines which store
608 individual registers, this doesn't need to do anything. On machines
609 which store all the registers in one fell swoop, this makes sure
610 that registers contains all the registers from the program being
614 gr_prepare_to_store ()
616 /* Do nothing, since we assume we can store individual regs */
619 /* Read a word from remote address ADDR and return it.
620 * This goes through the data cache.
626 return dcache_fetch (gr_get_dcache(), addr
);
629 /* Write a word WORD into remote address ADDR.
630 This goes through the data cache. */
633 gr_store_word (addr
, word
)
637 dcache_poke (gr_get_dcache(), addr
, word
);
641 _initialize_sr_support ()
643 /* FIXME-now: if target is open... */
644 add_show_from_set (add_set_cmd ("remotedevice", no_class
,
645 var_filename
, (char *)&sr_settings
.device
,
646 "Set device for remote serial I/O.\n\
647 This device is used as the serial port when debugging using remote\n\
648 targets.", &setlist
),
651 add_com ("remote <command>", class_obscure
, sr_com
,
652 "Send a command to the remote monitor.");
This page took 0.043615 seconds and 4 git commands to generate.