MAINTAINERS (write after approval): Add myself
[platform/upstream/binutils.git] / gdb / remote.c
1 /* Remote target communications for serial-line targets in custom GDB protocol
2
3    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4    1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330,
21    Boston, MA 02111-1307, USA.  */
22
23 /* See the GDB User Guide for details of the GDB remote protocol. */
24
25 #include "defs.h"
26 #include "gdb_string.h"
27 #include <ctype.h>
28 #include <fcntl.h>
29 #include "inferior.h"
30 #include "bfd.h"
31 #include "symfile.h"
32 #include "target.h"
33 /*#include "terminal.h" */
34 #include "gdbcmd.h"
35 #include "objfiles.h"
36 #include "gdb-stabs.h"
37 #include "gdbthread.h"
38 #include "remote.h"
39 #include "regcache.h"
40 #include "value.h"
41 #include "gdb_assert.h"
42
43 #include <ctype.h>
44 #include <sys/time.h>
45 #ifdef USG
46 #include <sys/types.h>
47 #endif
48
49 #include "event-loop.h"
50 #include "event-top.h"
51 #include "inf-loop.h"
52
53 #include <signal.h>
54 #include "serial.h"
55
56 #include "gdbcore.h" /* for exec_bfd */
57
58 /* Prototypes for local functions */
59 static void cleanup_sigint_signal_handler (void *dummy);
60 static void initialize_sigint_signal_handler (void);
61 static int getpkt_sane (char *buf, long sizeof_buf, int forever);
62
63 static void handle_remote_sigint (int);
64 static void handle_remote_sigint_twice (int);
65 static void async_remote_interrupt (gdb_client_data);
66 void async_remote_interrupt_twice (gdb_client_data);
67
68 static void build_remote_gdbarch_data (void);
69
70 static int remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len);
71
72 static int remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len);
73
74 static void remote_files_info (struct target_ops *ignore);
75
76 static int remote_xfer_memory (CORE_ADDR memaddr, char *myaddr,
77                                int len, int should_write,
78                                struct mem_attrib *attrib,
79                                struct target_ops *target);
80
81 static void remote_prepare_to_store (void);
82
83 static void remote_fetch_registers (int regno);
84
85 static void remote_resume (ptid_t ptid, int step,
86                            enum target_signal siggnal);
87 static void remote_async_resume (ptid_t ptid, int step,
88                                  enum target_signal siggnal);
89 static int remote_start_remote (struct ui_out *uiout, void *dummy);
90
91 static void remote_open (char *name, int from_tty);
92 static void remote_async_open (char *name, int from_tty);
93
94 static void extended_remote_open (char *name, int from_tty);
95 static void extended_remote_async_open (char *name, int from_tty);
96
97 static void remote_open_1 (char *, int, struct target_ops *, int extended_p,
98                            int async_p);
99
100 static void remote_close (int quitting);
101
102 static void remote_store_registers (int regno);
103
104 static void remote_mourn (void);
105 static void remote_async_mourn (void);
106
107 static void extended_remote_restart (void);
108
109 static void extended_remote_mourn (void);
110
111 static void extended_remote_create_inferior (char *, char *, char **);
112 static void extended_remote_async_create_inferior (char *, char *, char **);
113
114 static void remote_mourn_1 (struct target_ops *);
115
116 static void remote_send (char *buf, long sizeof_buf);
117
118 static int readchar (int timeout);
119
120 static ptid_t remote_wait (ptid_t ptid,
121                                  struct target_waitstatus *status);
122 static ptid_t remote_async_wait (ptid_t ptid,
123                                        struct target_waitstatus *status);
124
125 static void remote_kill (void);
126 static void remote_async_kill (void);
127
128 static int tohex (int nib);
129
130 static void remote_detach (char *args, int from_tty);
131 static void remote_async_detach (char *args, int from_tty);
132
133 static void remote_interrupt (int signo);
134
135 static void remote_interrupt_twice (int signo);
136
137 static void interrupt_query (void);
138
139 static void set_thread (int, int);
140
141 static int remote_thread_alive (ptid_t);
142
143 static void get_offsets (void);
144
145 static long read_frame (char *buf, long sizeof_buf);
146
147 static int remote_insert_breakpoint (CORE_ADDR, char *);
148
149 static int remote_remove_breakpoint (CORE_ADDR, char *);
150
151 static int hexnumlen (ULONGEST num);
152
153 static void init_remote_ops (void);
154
155 static void init_extended_remote_ops (void);
156
157 static void init_remote_cisco_ops (void);
158
159 static struct target_ops remote_cisco_ops;
160
161 static void remote_stop (void);
162
163 static int ishex (int ch, int *val);
164
165 static int stubhex (int ch);
166
167 static int remote_query (int /*char */ , char *, char *, int *);
168
169 static int hexnumstr (char *, ULONGEST);
170
171 static int hexnumnstr (char *, ULONGEST, int);
172
173 static CORE_ADDR remote_address_masked (CORE_ADDR);
174
175 static void print_packet (char *);
176
177 static unsigned long crc32 (unsigned char *, int, unsigned int);
178
179 static void compare_sections_command (char *, int);
180
181 static void packet_command (char *, int);
182
183 static int stub_unpack_int (char *buff, int fieldlength);
184
185 static ptid_t remote_current_thread (ptid_t oldptid);
186
187 static void remote_find_new_threads (void);
188
189 static void record_currthread (int currthread);
190
191 static int fromhex (int a);
192
193 static int hex2bin (const char *hex, char *bin, int count);
194
195 static int bin2hex (const char *bin, char *hex, int count);
196
197 static int putpkt_binary (char *buf, int cnt);
198
199 static void check_binary_download (CORE_ADDR addr);
200
201 struct packet_config;
202
203 static void show_packet_config_cmd (struct packet_config *config);
204
205 static void update_packet_config (struct packet_config *config);
206
207 void _initialize_remote (void);
208
209 /* Description of the remote protocol.  Strictly speaking, when the
210    target is open()ed, remote.c should create a per-target description
211    of the remote protocol using that target's architecture.
212    Unfortunatly, the target stack doesn't include local state.  For
213    the moment keep the information in the target's architecture
214    object.  Sigh..  */
215
216 struct packet_reg
217 {
218   long offset; /* Offset into G packet.  */
219   long regnum; /* GDB's internal register number.  */
220   LONGEST pnum; /* Remote protocol register number.  */
221   int in_g_packet; /* Always part of G packet.  */
222   /* long size in bytes;  == REGISTER_RAW_SIZE (regnum); at present.  */
223   /* char *name; == REGISTER_NAME (regnum); at present.  */
224 };
225
226 struct remote_state
227 {
228   /* Description of the remote protocol registers.  */
229   long sizeof_g_packet;
230
231   /* Description of the remote protocol registers indexed by REGNUM
232      (making an array of NUM_REGS + NUM_PSEUDO_REGS in size).  */
233   struct packet_reg *regs;
234
235   /* This is the size (in chars) of the first response to the ``g''
236      packet.  It is used as a heuristic when determining the maximum
237      size of memory-read and memory-write packets.  A target will
238      typically only reserve a buffer large enough to hold the ``g''
239      packet.  The size does not include packet overhead (headers and
240      trailers). */
241   long actual_register_packet_size;
242
243   /* This is the maximum size (in chars) of a non read/write packet.
244      It is also used as a cap on the size of read/write packets. */
245   long remote_packet_size;
246 };
247
248
249 /* Handle for retreving the remote protocol data from gdbarch.  */
250 static struct gdbarch_data *remote_gdbarch_data_handle;
251
252 static struct remote_state *
253 get_remote_state (void)
254 {
255   return gdbarch_data (current_gdbarch, remote_gdbarch_data_handle);
256 }
257
258 static void *
259 init_remote_state (struct gdbarch *gdbarch)
260 {
261   int regnum;
262   struct remote_state *rs = xmalloc (sizeof (struct remote_state));
263
264   /* Start out by having the remote protocol mimic the existing
265      behavour - just copy in the description of the register cache.  */
266   rs->sizeof_g_packet = DEPRECATED_REGISTER_BYTES; /* OK */
267
268   /* Assume a 1:1 regnum<->pnum table.  */
269   rs->regs = xcalloc (NUM_REGS + NUM_PSEUDO_REGS, sizeof (struct packet_reg));
270   for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
271     {
272       struct packet_reg *r = &rs->regs[regnum];
273       r->pnum = regnum;
274       r->regnum = regnum;
275       r->offset = REGISTER_BYTE (regnum);
276       r->in_g_packet = (regnum < NUM_REGS);
277       /* ...size = REGISTER_RAW_SIZE (regnum); */
278       /* ...name = REGISTER_NAME (regnum); */
279     }
280
281   /* Default maximum number of characters in a packet body. Many
282      remote stubs have a hardwired buffer size of 400 bytes
283      (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used
284      as the maximum packet-size to ensure that the packet and an extra
285      NUL character can always fit in the buffer.  This stops GDB
286      trashing stubs that try to squeeze an extra NUL into what is
287      already a full buffer (As of 1999-12-04 that was most stubs. */
288   rs->remote_packet_size = 400 - 1;
289
290   /* Should rs->sizeof_g_packet needs more space than the
291      default, adjust the size accordingly. Remember that each byte is
292      encoded as two characters. 32 is the overhead for the packet
293      header / footer. NOTE: cagney/1999-10-26: I suspect that 8
294      (``$NN:G...#NN'') is a better guess, the below has been padded a
295      little. */
296   if (rs->sizeof_g_packet > ((rs->remote_packet_size - 32) / 2))
297     rs->remote_packet_size = (rs->sizeof_g_packet * 2 + 32);
298   
299   /* This one is filled in when a ``g'' packet is received. */
300   rs->actual_register_packet_size = 0;
301
302   return rs;
303 }
304
305 static void
306 free_remote_state (struct gdbarch *gdbarch, void *pointer)
307 {
308   struct remote_state *data = pointer;
309   xfree (data->regs);
310   xfree (data);
311 }
312
313 static struct packet_reg *
314 packet_reg_from_regnum (struct remote_state *rs, long regnum)
315 {
316   if (regnum < 0 && regnum >= NUM_REGS + NUM_PSEUDO_REGS)
317     return NULL;
318   else
319     {
320       struct packet_reg *r = &rs->regs[regnum];
321       gdb_assert (r->regnum == regnum);
322       return r;
323     }
324 }
325
326 static struct packet_reg *
327 packet_reg_from_pnum (struct remote_state *rs, LONGEST pnum)
328 {
329   int i;
330   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
331     {
332       struct packet_reg *r = &rs->regs[i];
333       if (r->pnum == pnum)
334         return r;
335     }
336   return NULL;
337 }
338
339 /* FIXME: graces/2002-08-08: These variables should eventually be
340    bound to an instance of the target object (as in gdbarch-tdep()),
341    when such a thing exists.  */
342
343 /* This is set to the data address of the access causing the target
344    to stop for a watchpoint.  */
345 static CORE_ADDR remote_watch_data_address;
346
347 /* This is non-zero if taregt stopped for a watchpoint. */
348 static int remote_stopped_by_watchpoint_p;
349
350
351 static struct target_ops remote_ops;
352
353 static struct target_ops extended_remote_ops;
354
355 /* Temporary target ops. Just like the remote_ops and
356    extended_remote_ops, but with asynchronous support. */
357 static struct target_ops remote_async_ops;
358
359 static struct target_ops extended_async_remote_ops;
360
361 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
362    ``forever'' still use the normal timeout mechanism.  This is
363    currently used by the ASYNC code to guarentee that target reads
364    during the initial connect always time-out.  Once getpkt has been
365    modified to return a timeout indication and, in turn
366    remote_wait()/wait_for_inferior() have gained a timeout parameter
367    this can go away. */
368 static int wait_forever_enabled_p = 1;
369
370
371 /* This variable chooses whether to send a ^C or a break when the user
372    requests program interruption.  Although ^C is usually what remote
373    systems expect, and that is the default here, sometimes a break is
374    preferable instead.  */
375
376 static int remote_break;
377
378 /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
379    remote_open knows that we don't have a file open when the program
380    starts.  */
381 static struct serial *remote_desc = NULL;
382
383 /* This is set by the target (thru the 'S' message)
384    to denote that the target is in kernel mode.  */
385 static int cisco_kernel_mode = 0;
386
387 /* This variable sets the number of bits in an address that are to be
388    sent in a memory ("M" or "m") packet.  Normally, after stripping
389    leading zeros, the entire address would be sent. This variable
390    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
391    initial implementation of remote.c restricted the address sent in
392    memory packets to ``host::sizeof long'' bytes - (typically 32
393    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
394    address was never sent.  Since fixing this bug may cause a break in
395    some remote targets this variable is principly provided to
396    facilitate backward compatibility. */
397
398 static int remote_address_size;
399
400 /* Tempoary to track who currently owns the terminal.  See
401    target_async_terminal_* for more details.  */
402
403 static int remote_async_terminal_ours_p;
404
405 \f
406 /* User configurable variables for the number of characters in a
407    memory read/write packet.  MIN ((rs->remote_packet_size),
408    rs->sizeof_g_packet) is the default.  Some targets need smaller
409    values (fifo overruns, et.al.)  and some users need larger values
410    (speed up transfers).  The variables ``preferred_*'' (the user
411    request), ``current_*'' (what was actually set) and ``forced_*''
412    (Positive - a soft limit, negative - a hard limit). */
413
414 struct memory_packet_config
415 {
416   char *name;
417   long size;
418   int fixed_p;
419 };
420
421 /* Compute the current size of a read/write packet.  Since this makes
422    use of ``actual_register_packet_size'' the computation is dynamic.  */
423
424 static long
425 get_memory_packet_size (struct memory_packet_config *config)
426 {
427   struct remote_state *rs = get_remote_state ();
428   /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
429      law?) that some hosts don't cope very well with large alloca()
430      calls.  Eventually the alloca() code will be replaced by calls to
431      xmalloc() and make_cleanups() allowing this restriction to either
432      be lifted or removed. */
433 #ifndef MAX_REMOTE_PACKET_SIZE
434 #define MAX_REMOTE_PACKET_SIZE 16384
435 #endif
436   /* NOTE: 16 is just chosen at random. */
437 #ifndef MIN_REMOTE_PACKET_SIZE
438 #define MIN_REMOTE_PACKET_SIZE 16
439 #endif
440   long what_they_get;
441   if (config->fixed_p)
442     {
443       if (config->size <= 0)
444         what_they_get = MAX_REMOTE_PACKET_SIZE;
445       else
446         what_they_get = config->size;
447     }
448   else
449     {
450       what_they_get = (rs->remote_packet_size);
451       /* Limit the packet to the size specified by the user. */
452       if (config->size > 0
453           && what_they_get > config->size)
454         what_they_get = config->size;
455       /* Limit it to the size of the targets ``g'' response. */
456       if ((rs->actual_register_packet_size) > 0
457           && what_they_get > (rs->actual_register_packet_size))
458         what_they_get = (rs->actual_register_packet_size);
459     }
460   if (what_they_get > MAX_REMOTE_PACKET_SIZE)
461     what_they_get = MAX_REMOTE_PACKET_SIZE;
462   if (what_they_get < MIN_REMOTE_PACKET_SIZE)
463     what_they_get = MIN_REMOTE_PACKET_SIZE;
464   return what_they_get;
465 }
466
467 /* Update the size of a read/write packet. If they user wants
468    something really big then do a sanity check. */
469
470 static void
471 set_memory_packet_size (char *args, struct memory_packet_config *config)
472 {
473   int fixed_p = config->fixed_p;
474   long size = config->size;
475   if (args == NULL)
476     error ("Argument required (integer, `fixed' or `limited').");
477   else if (strcmp (args, "hard") == 0
478       || strcmp (args, "fixed") == 0)
479     fixed_p = 1;
480   else if (strcmp (args, "soft") == 0
481            || strcmp (args, "limit") == 0)
482     fixed_p = 0;
483   else
484     {
485       char *end;
486       size = strtoul (args, &end, 0);
487       if (args == end)
488         error ("Invalid %s (bad syntax).", config->name);
489 #if 0
490       /* Instead of explicitly capping the size of a packet to
491          MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
492          instead allowed to set the size to something arbitrarily
493          large. */
494       if (size > MAX_REMOTE_PACKET_SIZE)
495         error ("Invalid %s (too large).", config->name);
496 #endif
497     }
498   /* Extra checks? */
499   if (fixed_p && !config->fixed_p)
500     {
501       if (! query ("The target may not be able to correctly handle a %s\n"
502                    "of %ld bytes. Change the packet size? ",
503                    config->name, size))
504         error ("Packet size not changed.");
505     }
506   /* Update the config. */
507   config->fixed_p = fixed_p;
508   config->size = size;
509 }
510
511 static void
512 show_memory_packet_size (struct memory_packet_config *config)
513 {
514   printf_filtered ("The %s is %ld. ", config->name, config->size);
515   if (config->fixed_p)
516     printf_filtered ("Packets are fixed at %ld bytes.\n",
517                      get_memory_packet_size (config));
518   else
519     printf_filtered ("Packets are limited to %ld bytes.\n",
520                      get_memory_packet_size (config));
521 }
522
523 static struct memory_packet_config memory_write_packet_config =
524 {
525   "memory-write-packet-size",
526 };
527
528 static void
529 set_memory_write_packet_size (char *args, int from_tty)
530 {
531   set_memory_packet_size (args, &memory_write_packet_config);
532 }
533
534 static void
535 show_memory_write_packet_size (char *args, int from_tty)
536 {
537   show_memory_packet_size (&memory_write_packet_config);
538 }
539
540 static long
541 get_memory_write_packet_size (void)
542 {
543   return get_memory_packet_size (&memory_write_packet_config);
544 }
545
546 static struct memory_packet_config memory_read_packet_config =
547 {
548   "memory-read-packet-size",
549 };
550
551 static void
552 set_memory_read_packet_size (char *args, int from_tty)
553 {
554   set_memory_packet_size (args, &memory_read_packet_config);
555 }
556
557 static void
558 show_memory_read_packet_size (char *args, int from_tty)
559 {
560   show_memory_packet_size (&memory_read_packet_config);
561 }
562
563 static long
564 get_memory_read_packet_size (void)
565 {
566   struct remote_state *rs = get_remote_state ();
567   long size = get_memory_packet_size (&memory_read_packet_config);
568   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
569      extra buffer size argument before the memory read size can be
570      increased beyond (rs->remote_packet_size). */
571   if (size > (rs->remote_packet_size))
572     size = (rs->remote_packet_size);
573   return size;
574 }
575
576 \f
577 /* Generic configuration support for packets the stub optionally
578    supports. Allows the user to specify the use of the packet as well
579    as allowing GDB to auto-detect support in the remote stub. */
580
581 enum packet_support
582   {
583     PACKET_SUPPORT_UNKNOWN = 0,
584     PACKET_ENABLE,
585     PACKET_DISABLE
586   };
587
588 struct packet_config
589   {
590     char *name;
591     char *title;
592     enum auto_boolean detect;
593     enum packet_support support;
594   };
595
596 /* Analyze a packet's return value and update the packet config
597    accordingly. */
598
599 enum packet_result
600 {
601   PACKET_ERROR,
602   PACKET_OK,
603   PACKET_UNKNOWN
604 };
605
606 static void
607 update_packet_config (struct packet_config *config)
608 {
609   switch (config->detect)
610     {
611     case AUTO_BOOLEAN_TRUE:
612       config->support = PACKET_ENABLE;
613       break;
614     case AUTO_BOOLEAN_FALSE:
615       config->support = PACKET_DISABLE;
616       break;
617     case AUTO_BOOLEAN_AUTO:
618       config->support = PACKET_SUPPORT_UNKNOWN;
619       break;
620     }
621 }
622
623 static void
624 show_packet_config_cmd (struct packet_config *config)
625 {
626   char *support = "internal-error";
627   switch (config->support)
628     {
629     case PACKET_ENABLE:
630       support = "enabled";
631       break;
632     case PACKET_DISABLE:
633       support = "disabled";
634       break;
635     case PACKET_SUPPORT_UNKNOWN:
636       support = "unknown";
637       break;
638     }
639   switch (config->detect)
640     {
641     case AUTO_BOOLEAN_AUTO:
642       printf_filtered ("Support for remote protocol `%s' (%s) packet is auto-detected, currently %s.\n",
643                        config->name, config->title, support);
644       break;
645     case AUTO_BOOLEAN_TRUE:
646     case AUTO_BOOLEAN_FALSE:
647       printf_filtered ("Support for remote protocol `%s' (%s) packet is currently %s.\n",
648                        config->name, config->title, support);
649       break;
650     }
651 }
652
653 static void
654 add_packet_config_cmd (struct packet_config *config,
655                        char *name,
656                        char *title,
657                        cmd_sfunc_ftype *set_func,
658                        cmd_sfunc_ftype *show_func,
659                        struct cmd_list_element **set_remote_list,
660                        struct cmd_list_element **show_remote_list,
661                        int legacy)
662 {
663   struct cmd_list_element *set_cmd;
664   struct cmd_list_element *show_cmd;
665   char *set_doc;
666   char *show_doc;
667   char *cmd_name;
668   config->name = name;
669   config->title = title;
670   config->detect = AUTO_BOOLEAN_AUTO;
671   config->support = PACKET_SUPPORT_UNKNOWN;
672   xasprintf (&set_doc, "Set use of remote protocol `%s' (%s) packet",
673              name, title);
674   xasprintf (&show_doc, "Show current use of remote protocol `%s' (%s) packet",
675              name, title);
676   /* set/show TITLE-packet {auto,on,off} */
677   xasprintf (&cmd_name, "%s-packet", title);
678   add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
679                                 &config->detect, set_doc, show_doc,
680                                 set_func, show_func,
681                                 set_remote_list, show_remote_list);
682   /* set/show remote NAME-packet {auto,on,off} -- legacy */
683   if (legacy)
684     {
685       char *legacy_name;
686       xasprintf (&legacy_name, "%s-packet", name);
687       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
688                      set_remote_list);
689       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
690                      show_remote_list);
691     }
692 }
693
694 static enum packet_result
695 packet_ok (const char *buf, struct packet_config *config)
696 {
697   if (buf[0] != '\0')
698     {
699       /* The stub recognized the packet request.  Check that the
700          operation succeeded. */
701       switch (config->support)
702         {
703         case PACKET_SUPPORT_UNKNOWN:
704           if (remote_debug)
705             fprintf_unfiltered (gdb_stdlog,
706                                     "Packet %s (%s) is supported\n",
707                                     config->name, config->title);
708           config->support = PACKET_ENABLE;
709           break;
710         case PACKET_DISABLE:
711           internal_error (__FILE__, __LINE__,
712                           "packet_ok: attempt to use a disabled packet");
713           break;
714         case PACKET_ENABLE:
715           break;
716         }
717       if (buf[0] == 'O' && buf[1] == 'K' && buf[2] == '\0')
718         /* "OK" - definitly OK. */
719         return PACKET_OK;
720       if (buf[0] == 'E'
721           && isxdigit (buf[1]) && isxdigit (buf[2])
722           && buf[3] == '\0')
723         /* "Enn"  - definitly an error. */
724         return PACKET_ERROR;
725       /* The packet may or may not be OK.  Just assume it is */
726       return PACKET_OK;
727     }
728   else
729     {
730       /* The stub does not support the packet. */
731       switch (config->support)
732         {
733         case PACKET_ENABLE:
734           if (config->detect == AUTO_BOOLEAN_AUTO)
735             /* If the stub previously indicated that the packet was
736                supported then there is a protocol error.. */
737             error ("Protocol error: %s (%s) conflicting enabled responses.",
738                    config->name, config->title);
739           else
740             /* The user set it wrong. */
741             error ("Enabled packet %s (%s) not recognized by stub",
742                    config->name, config->title);
743           break;
744         case PACKET_SUPPORT_UNKNOWN:
745           if (remote_debug)
746             fprintf_unfiltered (gdb_stdlog,
747                                 "Packet %s (%s) is NOT supported\n",
748                                 config->name, config->title);
749           config->support = PACKET_DISABLE;
750           break;
751         case PACKET_DISABLE:
752           break;
753         }
754       return PACKET_UNKNOWN;
755     }
756 }
757
758 /* Should we try the 'qSymbol' (target symbol lookup service) request? */
759 static struct packet_config remote_protocol_qSymbol;
760
761 static void
762 set_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
763                                   struct cmd_list_element *c)
764 {
765   update_packet_config (&remote_protocol_qSymbol);
766 }
767
768 static void
769 show_remote_protocol_qSymbol_packet_cmd (char *args, int from_tty,
770                                          struct cmd_list_element *c)
771 {
772   show_packet_config_cmd (&remote_protocol_qSymbol);
773 }
774
775 /* Should we try the 'e' (step over range) request? */
776 static struct packet_config remote_protocol_e;
777
778 static void
779 set_remote_protocol_e_packet_cmd (char *args, int from_tty,
780                                   struct cmd_list_element *c)
781 {
782   update_packet_config (&remote_protocol_e);
783 }
784
785 static void
786 show_remote_protocol_e_packet_cmd (char *args, int from_tty,
787                                    struct cmd_list_element *c)
788 {
789   show_packet_config_cmd (&remote_protocol_e);
790 }
791   
792
793 /* Should we try the 'E' (step over range / w signal #) request? */
794 static struct packet_config remote_protocol_E;
795
796 static void
797 set_remote_protocol_E_packet_cmd (char *args, int from_tty,
798                                   struct cmd_list_element *c)
799 {
800   update_packet_config (&remote_protocol_E);
801 }
802
803 static void
804 show_remote_protocol_E_packet_cmd (char *args, int from_tty,
805                                    struct cmd_list_element *c)
806 {
807   show_packet_config_cmd (&remote_protocol_E);
808 }
809   
810
811 /* Should we try the 'P' (set register) request?  */
812
813 static struct packet_config remote_protocol_P;
814
815 static void
816 set_remote_protocol_P_packet_cmd (char *args, int from_tty,
817                                   struct cmd_list_element *c)
818 {
819   update_packet_config (&remote_protocol_P);
820 }
821
822 static void
823 show_remote_protocol_P_packet_cmd (char *args, int from_tty,
824                                    struct cmd_list_element *c)
825 {
826   show_packet_config_cmd (&remote_protocol_P);
827 }
828
829 /* Should we try one of the 'Z' requests?  */
830
831 enum Z_packet_type
832 {
833   Z_PACKET_SOFTWARE_BP,
834   Z_PACKET_HARDWARE_BP,
835   Z_PACKET_WRITE_WP,
836   Z_PACKET_READ_WP,
837   Z_PACKET_ACCESS_WP,
838   NR_Z_PACKET_TYPES
839 };
840
841 static struct packet_config remote_protocol_Z[NR_Z_PACKET_TYPES];
842
843 /* FIXME: Instead of having all these boiler plate functions, the
844    command callback should include a context argument. */
845
846 static void
847 set_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
848                                               struct cmd_list_element *c)
849 {
850   update_packet_config (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
851 }
852
853 static void
854 show_remote_protocol_Z_software_bp_packet_cmd (char *args, int from_tty,
855                                                struct cmd_list_element *c)
856 {
857   show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP]);
858 }
859
860 static void
861 set_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
862                                               struct cmd_list_element *c)
863 {
864   update_packet_config (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
865 }
866
867 static void
868 show_remote_protocol_Z_hardware_bp_packet_cmd (char *args, int from_tty,
869                                                struct cmd_list_element *c)
870 {
871   show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP]);
872 }
873
874 static void
875 set_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
876                                               struct cmd_list_element *c)
877 {
878   update_packet_config (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
879 }
880
881 static void
882 show_remote_protocol_Z_write_wp_packet_cmd (char *args, int from_tty,
883                                             struct cmd_list_element *c)
884 {
885   show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP]);
886 }
887
888 static void
889 set_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
890                                               struct cmd_list_element *c)
891 {
892   update_packet_config (&remote_protocol_Z[Z_PACKET_READ_WP]);
893 }
894
895 static void
896 show_remote_protocol_Z_read_wp_packet_cmd (char *args, int from_tty,
897                                            struct cmd_list_element *c)
898 {
899   show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP]);
900 }
901
902 static void
903 set_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
904                                               struct cmd_list_element *c)
905 {
906   update_packet_config (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
907 }
908
909 static void
910 show_remote_protocol_Z_access_wp_packet_cmd (char *args, int from_tty,
911                                              struct cmd_list_element *c)
912 {
913   show_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP]);
914 }
915
916 /* For compatibility with older distributions.  Provide a ``set remote
917    Z-packet ...'' command that updates all the Z packet types. */
918
919 static enum auto_boolean remote_Z_packet_detect;
920
921 static void
922 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
923                                   struct cmd_list_element *c)
924 {
925   int i;
926   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
927     {
928       remote_protocol_Z[i].detect = remote_Z_packet_detect;
929       update_packet_config (&remote_protocol_Z[i]);
930     }
931 }
932
933 static void
934 show_remote_protocol_Z_packet_cmd (char *args, int from_tty,
935                                    struct cmd_list_element *c)
936 {
937   int i;
938   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
939     {
940       show_packet_config_cmd (&remote_protocol_Z[i]);
941     }
942 }
943
944 /* Should we try the 'X' (remote binary download) packet?
945
946    This variable (available to the user via "set remote X-packet")
947    dictates whether downloads are sent in binary (via the 'X' packet).
948    We assume that the stub can, and attempt to do it. This will be
949    cleared if the stub does not understand it. This switch is still
950    needed, though in cases when the packet is supported in the stub,
951    but the connection does not allow it (i.e., 7-bit serial connection
952    only). */
953
954 static struct packet_config remote_protocol_binary_download;
955
956 /* Should we try the 'ThreadInfo' query packet?
957
958    This variable (NOT available to the user: auto-detect only!)
959    determines whether GDB will use the new, simpler "ThreadInfo"
960    query or the older, more complex syntax for thread queries.
961    This is an auto-detect variable (set to true at each connect, 
962    and set to false when the target fails to recognize it).  */
963
964 static int use_threadinfo_query;
965 static int use_threadextra_query;
966
967 static void
968 set_remote_protocol_binary_download_cmd (char *args,
969                                          int from_tty,
970                                          struct cmd_list_element *c)
971 {
972   update_packet_config (&remote_protocol_binary_download);
973 }
974
975 static void
976 show_remote_protocol_binary_download_cmd (char *args, int from_tty,
977                                           struct cmd_list_element *c)
978 {
979   show_packet_config_cmd (&remote_protocol_binary_download);
980 }
981
982
983 /* Tokens for use by the asynchronous signal handlers for SIGINT */
984 static void *sigint_remote_twice_token;
985 static void *sigint_remote_token;
986
987 /* These are pointers to hook functions that may be set in order to
988    modify resume/wait behavior for a particular architecture.  */
989
990 void (*target_resume_hook) (void);
991 void (*target_wait_loop_hook) (void);
992 \f
993
994
995 /* These are the threads which we last sent to the remote system.
996    -1 for all or -2 for not sent yet.  */
997 static int general_thread;
998 static int continue_thread;
999
1000 /* Call this function as a result of
1001    1) A halt indication (T packet) containing a thread id
1002    2) A direct query of currthread
1003    3) Successful execution of set thread
1004  */
1005
1006 static void
1007 record_currthread (int currthread)
1008 {
1009   general_thread = currthread;
1010
1011   /* If this is a new thread, add it to GDB's thread list.
1012      If we leave it up to WFI to do this, bad things will happen.  */
1013   if (!in_thread_list (pid_to_ptid (currthread)))
1014     {
1015       add_thread (pid_to_ptid (currthread));
1016       ui_out_text (uiout, "[New ");
1017       ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread)));
1018       ui_out_text (uiout, "]\n");
1019     }
1020 }
1021
1022 #define MAGIC_NULL_PID 42000
1023
1024 static void
1025 set_thread (int th, int gen)
1026 {
1027   struct remote_state *rs = get_remote_state ();
1028   char *buf = alloca (rs->remote_packet_size);
1029   int state = gen ? general_thread : continue_thread;
1030
1031   if (state == th)
1032     return;
1033
1034   buf[0] = 'H';
1035   buf[1] = gen ? 'g' : 'c';
1036   if (th == MAGIC_NULL_PID)
1037     {
1038       buf[2] = '0';
1039       buf[3] = '\0';
1040     }
1041   else if (th < 0)
1042     sprintf (&buf[2], "-%x", -th);
1043   else
1044     sprintf (&buf[2], "%x", th);
1045   putpkt (buf);
1046   getpkt (buf, (rs->remote_packet_size), 0);
1047   if (gen)
1048     general_thread = th;
1049   else
1050     continue_thread = th;
1051 }
1052 \f
1053 /*  Return nonzero if the thread TH is still alive on the remote system.  */
1054
1055 static int
1056 remote_thread_alive (ptid_t ptid)
1057 {
1058   int tid = PIDGET (ptid);
1059   char buf[16];
1060
1061   if (tid < 0)
1062     sprintf (buf, "T-%08x", -tid);
1063   else
1064     sprintf (buf, "T%08x", tid);
1065   putpkt (buf);
1066   getpkt (buf, sizeof (buf), 0);
1067   return (buf[0] == 'O' && buf[1] == 'K');
1068 }
1069
1070 /* About these extended threadlist and threadinfo packets.  They are
1071    variable length packets but, the fields within them are often fixed
1072    length.  They are redundent enough to send over UDP as is the
1073    remote protocol in general.  There is a matching unit test module
1074    in libstub.  */
1075
1076 #define OPAQUETHREADBYTES 8
1077
1078 /* a 64 bit opaque identifier */
1079 typedef unsigned char threadref[OPAQUETHREADBYTES];
1080
1081 /* WARNING: This threadref data structure comes from the remote O.S., libstub
1082    protocol encoding, and remote.c. it is not particularly changable */
1083
1084 /* Right now, the internal structure is int. We want it to be bigger.
1085    Plan to fix this.
1086  */
1087
1088 typedef int gdb_threadref;      /* internal GDB thread reference */
1089
1090 /* gdb_ext_thread_info is an internal GDB data structure which is
1091    equivalint to the reply of the remote threadinfo packet */
1092
1093 struct gdb_ext_thread_info
1094   {
1095     threadref threadid;         /* External form of thread reference */
1096     int active;                 /* Has state interesting to GDB? , regs, stack */
1097     char display[256];          /* Brief state display, name, blocked/syspended */
1098     char shortname[32];         /* To be used to name threads */
1099     char more_display[256];     /* Long info, statistics, queue depth, whatever */
1100   };
1101
1102 /* The volume of remote transfers can be limited by submitting
1103    a mask containing bits specifying the desired information.
1104    Use a union of these values as the 'selection' parameter to
1105    get_thread_info. FIXME: Make these TAG names more thread specific.
1106  */
1107
1108 #define TAG_THREADID 1
1109 #define TAG_EXISTS 2
1110 #define TAG_DISPLAY 4
1111 #define TAG_THREADNAME 8
1112 #define TAG_MOREDISPLAY 16
1113
1114 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES*2)
1115
1116 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1117
1118 static char *unpack_nibble (char *buf, int *val);
1119
1120 static char *pack_nibble (char *buf, int nibble);
1121
1122 static char *pack_hex_byte (char *pkt, int /*unsigned char */ byte);
1123
1124 static char *unpack_byte (char *buf, int *value);
1125
1126 static char *pack_int (char *buf, int value);
1127
1128 static char *unpack_int (char *buf, int *value);
1129
1130 static char *unpack_string (char *src, char *dest, int length);
1131
1132 static char *pack_threadid (char *pkt, threadref * id);
1133
1134 static char *unpack_threadid (char *inbuf, threadref * id);
1135
1136 void int_to_threadref (threadref * id, int value);
1137
1138 static int threadref_to_int (threadref * ref);
1139
1140 static void copy_threadref (threadref * dest, threadref * src);
1141
1142 static int threadmatch (threadref * dest, threadref * src);
1143
1144 static char *pack_threadinfo_request (char *pkt, int mode, threadref * id);
1145
1146 static int remote_unpack_thread_info_response (char *pkt,
1147                                                threadref * expectedref,
1148                                                struct gdb_ext_thread_info
1149                                                *info);
1150
1151
1152 static int remote_get_threadinfo (threadref * threadid, int fieldset,   /*TAG mask */
1153                                   struct gdb_ext_thread_info *info);
1154
1155 static int adapt_remote_get_threadinfo (gdb_threadref * ref,
1156                                         int selection,
1157                                         struct gdb_ext_thread_info *info);
1158
1159 static char *pack_threadlist_request (char *pkt, int startflag,
1160                                       int threadcount,
1161                                       threadref * nextthread);
1162
1163 static int parse_threadlist_response (char *pkt,
1164                                       int result_limit,
1165                                       threadref * original_echo,
1166                                       threadref * resultlist, int *doneflag);
1167
1168 static int remote_get_threadlist (int startflag,
1169                                   threadref * nextthread,
1170                                   int result_limit,
1171                                   int *done,
1172                                   int *result_count, threadref * threadlist);
1173
1174 typedef int (*rmt_thread_action) (threadref * ref, void *context);
1175
1176 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1177                                        void *context, int looplimit);
1178
1179 static int remote_newthread_step (threadref * ref, void *context);
1180
1181 /* encode 64 bits in 16 chars of hex */
1182
1183 static const char hexchars[] = "0123456789abcdef";
1184
1185 static int
1186 ishex (int ch, int *val)
1187 {
1188   if ((ch >= 'a') && (ch <= 'f'))
1189     {
1190       *val = ch - 'a' + 10;
1191       return 1;
1192     }
1193   if ((ch >= 'A') && (ch <= 'F'))
1194     {
1195       *val = ch - 'A' + 10;
1196       return 1;
1197     }
1198   if ((ch >= '0') && (ch <= '9'))
1199     {
1200       *val = ch - '0';
1201       return 1;
1202     }
1203   return 0;
1204 }
1205
1206 static int
1207 stubhex (int ch)
1208 {
1209   if (ch >= 'a' && ch <= 'f')
1210     return ch - 'a' + 10;
1211   if (ch >= '0' && ch <= '9')
1212     return ch - '0';
1213   if (ch >= 'A' && ch <= 'F')
1214     return ch - 'A' + 10;
1215   return -1;
1216 }
1217
1218 static int
1219 stub_unpack_int (char *buff, int fieldlength)
1220 {
1221   int nibble;
1222   int retval = 0;
1223
1224   while (fieldlength)
1225     {
1226       nibble = stubhex (*buff++);
1227       retval |= nibble;
1228       fieldlength--;
1229       if (fieldlength)
1230         retval = retval << 4;
1231     }
1232   return retval;
1233 }
1234
1235 char *
1236 unpack_varlen_hex (char *buff,  /* packet to parse */
1237                    ULONGEST *result)
1238 {
1239   int nibble;
1240   int retval = 0;
1241
1242   while (ishex (*buff, &nibble))
1243     {
1244       buff++;
1245       retval = retval << 4;
1246       retval |= nibble & 0x0f;
1247     }
1248   *result = retval;
1249   return buff;
1250 }
1251
1252 static char *
1253 unpack_nibble (char *buf, int *val)
1254 {
1255   ishex (*buf++, val);
1256   return buf;
1257 }
1258
1259 static char *
1260 pack_nibble (char *buf, int nibble)
1261 {
1262   *buf++ = hexchars[(nibble & 0x0f)];
1263   return buf;
1264 }
1265
1266 static char *
1267 pack_hex_byte (char *pkt, int byte)
1268 {
1269   *pkt++ = hexchars[(byte >> 4) & 0xf];
1270   *pkt++ = hexchars[(byte & 0xf)];
1271   return pkt;
1272 }
1273
1274 static char *
1275 unpack_byte (char *buf, int *value)
1276 {
1277   *value = stub_unpack_int (buf, 2);
1278   return buf + 2;
1279 }
1280
1281 static char *
1282 pack_int (char *buf, int value)
1283 {
1284   buf = pack_hex_byte (buf, (value >> 24) & 0xff);
1285   buf = pack_hex_byte (buf, (value >> 16) & 0xff);
1286   buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
1287   buf = pack_hex_byte (buf, (value & 0xff));
1288   return buf;
1289 }
1290
1291 static char *
1292 unpack_int (char *buf, int *value)
1293 {
1294   *value = stub_unpack_int (buf, 8);
1295   return buf + 8;
1296 }
1297
1298 #if 0                           /* currently unused, uncomment when needed */
1299 static char *pack_string (char *pkt, char *string);
1300
1301 static char *
1302 pack_string (char *pkt, char *string)
1303 {
1304   char ch;
1305   int len;
1306
1307   len = strlen (string);
1308   if (len > 200)
1309     len = 200;                  /* Bigger than most GDB packets, junk??? */
1310   pkt = pack_hex_byte (pkt, len);
1311   while (len-- > 0)
1312     {
1313       ch = *string++;
1314       if ((ch == '\0') || (ch == '#'))
1315         ch = '*';               /* Protect encapsulation */
1316       *pkt++ = ch;
1317     }
1318   return pkt;
1319 }
1320 #endif /* 0 (unused) */
1321
1322 static char *
1323 unpack_string (char *src, char *dest, int length)
1324 {
1325   while (length--)
1326     *dest++ = *src++;
1327   *dest = '\0';
1328   return src;
1329 }
1330
1331 static char *
1332 pack_threadid (char *pkt, threadref *id)
1333 {
1334   char *limit;
1335   unsigned char *altid;
1336
1337   altid = (unsigned char *) id;
1338   limit = pkt + BUF_THREAD_ID_SIZE;
1339   while (pkt < limit)
1340     pkt = pack_hex_byte (pkt, *altid++);
1341   return pkt;
1342 }
1343
1344
1345 static char *
1346 unpack_threadid (char *inbuf, threadref *id)
1347 {
1348   char *altref;
1349   char *limit = inbuf + BUF_THREAD_ID_SIZE;
1350   int x, y;
1351
1352   altref = (char *) id;
1353
1354   while (inbuf < limit)
1355     {
1356       x = stubhex (*inbuf++);
1357       y = stubhex (*inbuf++);
1358       *altref++ = (x << 4) | y;
1359     }
1360   return inbuf;
1361 }
1362
1363 /* Externally, threadrefs are 64 bits but internally, they are still
1364    ints. This is due to a mismatch of specifications.  We would like
1365    to use 64bit thread references internally.  This is an adapter
1366    function.  */
1367
1368 void
1369 int_to_threadref (threadref *id, int value)
1370 {
1371   unsigned char *scan;
1372
1373   scan = (unsigned char *) id;
1374   {
1375     int i = 4;
1376     while (i--)
1377       *scan++ = 0;
1378   }
1379   *scan++ = (value >> 24) & 0xff;
1380   *scan++ = (value >> 16) & 0xff;
1381   *scan++ = (value >> 8) & 0xff;
1382   *scan++ = (value & 0xff);
1383 }
1384
1385 static int
1386 threadref_to_int (threadref *ref)
1387 {
1388   int i, value = 0;
1389   unsigned char *scan;
1390
1391   scan = (char *) ref;
1392   scan += 4;
1393   i = 4;
1394   while (i-- > 0)
1395     value = (value << 8) | ((*scan++) & 0xff);
1396   return value;
1397 }
1398
1399 static void
1400 copy_threadref (threadref *dest, threadref *src)
1401 {
1402   int i;
1403   unsigned char *csrc, *cdest;
1404
1405   csrc = (unsigned char *) src;
1406   cdest = (unsigned char *) dest;
1407   i = 8;
1408   while (i--)
1409     *cdest++ = *csrc++;
1410 }
1411
1412 static int
1413 threadmatch (threadref *dest, threadref *src)
1414 {
1415   /* things are broken right now, so just assume we got a match */
1416 #if 0
1417   unsigned char *srcp, *destp;
1418   int i, result;
1419   srcp = (char *) src;
1420   destp = (char *) dest;
1421
1422   result = 1;
1423   while (i-- > 0)
1424     result &= (*srcp++ == *destp++) ? 1 : 0;
1425   return result;
1426 #endif
1427   return 1;
1428 }
1429
1430 /*
1431    threadid:1,        # always request threadid
1432    context_exists:2,
1433    display:4,
1434    unique_name:8,
1435    more_display:16
1436  */
1437
1438 /* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
1439
1440 static char *
1441 pack_threadinfo_request (char *pkt, int mode, threadref *id)
1442 {
1443   *pkt++ = 'q';                 /* Info Query */
1444   *pkt++ = 'P';                 /* process or thread info */
1445   pkt = pack_int (pkt, mode);   /* mode */
1446   pkt = pack_threadid (pkt, id);        /* threadid */
1447   *pkt = '\0';                  /* terminate */
1448   return pkt;
1449 }
1450
1451 /* These values tag the fields in a thread info response packet */
1452 /* Tagging the fields allows us to request specific fields and to
1453    add more fields as time goes by */
1454
1455 #define TAG_THREADID 1          /* Echo the thread identifier */
1456 #define TAG_EXISTS 2            /* Is this process defined enough to
1457                                    fetch registers and its stack */
1458 #define TAG_DISPLAY 4           /* A short thing maybe to put on a window */
1459 #define TAG_THREADNAME 8        /* string, maps 1-to-1 with a thread is */
1460 #define TAG_MOREDISPLAY 16      /* Whatever the kernel wants to say about 
1461                                    the process */
1462
1463 static int
1464 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
1465                                     struct gdb_ext_thread_info *info)
1466 {
1467   struct remote_state *rs = get_remote_state ();
1468   int mask, length;
1469   unsigned int tag;
1470   threadref ref;
1471   char *limit = pkt + (rs->remote_packet_size); /* plausable parsing limit */
1472   int retval = 1;
1473
1474   /* info->threadid = 0; FIXME: implement zero_threadref */
1475   info->active = 0;
1476   info->display[0] = '\0';
1477   info->shortname[0] = '\0';
1478   info->more_display[0] = '\0';
1479
1480   /* Assume the characters indicating the packet type have been stripped */
1481   pkt = unpack_int (pkt, &mask);        /* arg mask */
1482   pkt = unpack_threadid (pkt, &ref);
1483
1484   if (mask == 0)
1485     warning ("Incomplete response to threadinfo request\n");
1486   if (!threadmatch (&ref, expectedref))
1487     {                           /* This is an answer to a different request */
1488       warning ("ERROR RMT Thread info mismatch\n");
1489       return 0;
1490     }
1491   copy_threadref (&info->threadid, &ref);
1492
1493   /* Loop on tagged fields , try to bail if somthing goes wrong */
1494
1495   while ((pkt < limit) && mask && *pkt)         /* packets are terminated with nulls */
1496     {
1497       pkt = unpack_int (pkt, &tag);     /* tag */
1498       pkt = unpack_byte (pkt, &length);         /* length */
1499       if (!(tag & mask))        /* tags out of synch with mask */
1500         {
1501           warning ("ERROR RMT: threadinfo tag mismatch\n");
1502           retval = 0;
1503           break;
1504         }
1505       if (tag == TAG_THREADID)
1506         {
1507           if (length != 16)
1508             {
1509               warning ("ERROR RMT: length of threadid is not 16\n");
1510               retval = 0;
1511               break;
1512             }
1513           pkt = unpack_threadid (pkt, &ref);
1514           mask = mask & ~TAG_THREADID;
1515           continue;
1516         }
1517       if (tag == TAG_EXISTS)
1518         {
1519           info->active = stub_unpack_int (pkt, length);
1520           pkt += length;
1521           mask = mask & ~(TAG_EXISTS);
1522           if (length > 8)
1523             {
1524               warning ("ERROR RMT: 'exists' length too long\n");
1525               retval = 0;
1526               break;
1527             }
1528           continue;
1529         }
1530       if (tag == TAG_THREADNAME)
1531         {
1532           pkt = unpack_string (pkt, &info->shortname[0], length);
1533           mask = mask & ~TAG_THREADNAME;
1534           continue;
1535         }
1536       if (tag == TAG_DISPLAY)
1537         {
1538           pkt = unpack_string (pkt, &info->display[0], length);
1539           mask = mask & ~TAG_DISPLAY;
1540           continue;
1541         }
1542       if (tag == TAG_MOREDISPLAY)
1543         {
1544           pkt = unpack_string (pkt, &info->more_display[0], length);
1545           mask = mask & ~TAG_MOREDISPLAY;
1546           continue;
1547         }
1548       warning ("ERROR RMT: unknown thread info tag\n");
1549       break;                    /* Not a tag we know about */
1550     }
1551   return retval;
1552 }
1553
1554 static int
1555 remote_get_threadinfo (threadref *threadid, int fieldset,       /* TAG mask */
1556                        struct gdb_ext_thread_info *info)
1557 {
1558   struct remote_state *rs = get_remote_state ();
1559   int result;
1560   char *threadinfo_pkt = alloca (rs->remote_packet_size);
1561
1562   pack_threadinfo_request (threadinfo_pkt, fieldset, threadid);
1563   putpkt (threadinfo_pkt);
1564   getpkt (threadinfo_pkt, (rs->remote_packet_size), 0);
1565   result = remote_unpack_thread_info_response (threadinfo_pkt + 2, threadid,
1566                                                info);
1567   return result;
1568 }
1569
1570 /* Unfortunately, 61 bit thread-ids are bigger than the internal
1571    representation of a threadid.  */
1572
1573 static int
1574 adapt_remote_get_threadinfo (gdb_threadref *ref, int selection,
1575                              struct gdb_ext_thread_info *info)
1576 {
1577   threadref lclref;
1578
1579   int_to_threadref (&lclref, *ref);
1580   return remote_get_threadinfo (&lclref, selection, info);
1581 }
1582
1583 /*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
1584
1585 static char *
1586 pack_threadlist_request (char *pkt, int startflag, int threadcount,
1587                          threadref *nextthread)
1588 {
1589   *pkt++ = 'q';                 /* info query packet */
1590   *pkt++ = 'L';                 /* Process LIST or threadLIST request */
1591   pkt = pack_nibble (pkt, startflag);   /* initflag 1 bytes */
1592   pkt = pack_hex_byte (pkt, threadcount);       /* threadcount 2 bytes */
1593   pkt = pack_threadid (pkt, nextthread);        /* 64 bit thread identifier */
1594   *pkt = '\0';
1595   return pkt;
1596 }
1597
1598 /* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
1599
1600 static int
1601 parse_threadlist_response (char *pkt, int result_limit,
1602                            threadref *original_echo, threadref *resultlist,
1603                            int *doneflag)
1604 {
1605   struct remote_state *rs = get_remote_state ();
1606   char *limit;
1607   int count, resultcount, done;
1608
1609   resultcount = 0;
1610   /* Assume the 'q' and 'M chars have been stripped.  */
1611   limit = pkt + ((rs->remote_packet_size) - BUF_THREAD_ID_SIZE);                /* done parse past here */
1612   pkt = unpack_byte (pkt, &count);      /* count field */
1613   pkt = unpack_nibble (pkt, &done);
1614   /* The first threadid is the argument threadid.  */
1615   pkt = unpack_threadid (pkt, original_echo);   /* should match query packet */
1616   while ((count-- > 0) && (pkt < limit))
1617     {
1618       pkt = unpack_threadid (pkt, resultlist++);
1619       if (resultcount++ >= result_limit)
1620         break;
1621     }
1622   if (doneflag)
1623     *doneflag = done;
1624   return resultcount;
1625 }
1626
1627 static int
1628 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
1629                        int *done, int *result_count, threadref *threadlist)
1630 {
1631   struct remote_state *rs = get_remote_state ();
1632   static threadref echo_nextthread;
1633   char *threadlist_packet = alloca (rs->remote_packet_size);
1634   char *t_response = alloca (rs->remote_packet_size);
1635   int result = 1;
1636
1637   /* Trancate result limit to be smaller than the packet size */
1638   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10) >= (rs->remote_packet_size))
1639     result_limit = ((rs->remote_packet_size) / BUF_THREAD_ID_SIZE) - 2;
1640
1641   pack_threadlist_request (threadlist_packet,
1642                            startflag, result_limit, nextthread);
1643   putpkt (threadlist_packet);
1644   getpkt (t_response, (rs->remote_packet_size), 0);
1645
1646   *result_count =
1647     parse_threadlist_response (t_response + 2, result_limit, &echo_nextthread,
1648                                threadlist, done);
1649
1650   if (!threadmatch (&echo_nextthread, nextthread))
1651     {
1652       /* FIXME: This is a good reason to drop the packet */
1653       /* Possably, there is a duplicate response */
1654       /* Possabilities :
1655          retransmit immediatly - race conditions
1656          retransmit after timeout - yes
1657          exit
1658          wait for packet, then exit
1659        */
1660       warning ("HMM: threadlist did not echo arg thread, dropping it\n");
1661       return 0;                 /* I choose simply exiting */
1662     }
1663   if (*result_count <= 0)
1664     {
1665       if (*done != 1)
1666         {
1667           warning ("RMT ERROR : failed to get remote thread list\n");
1668           result = 0;
1669         }
1670       return result;            /* break; */
1671     }
1672   if (*result_count > result_limit)
1673     {
1674       *result_count = 0;
1675       warning ("RMT ERROR: threadlist response longer than requested\n");
1676       return 0;
1677     }
1678   return result;
1679 }
1680
1681 /* This is the interface between remote and threads, remotes upper interface */
1682
1683 /* remote_find_new_threads retrieves the thread list and for each
1684    thread in the list, looks up the thread in GDB's internal list,
1685    ading the thread if it does not already exist.  This involves
1686    getting partial thread lists from the remote target so, polling the
1687    quit_flag is required.  */
1688
1689
1690 /* About this many threadisds fit in a packet. */
1691
1692 #define MAXTHREADLISTRESULTS 32
1693
1694 static int
1695 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
1696                             int looplimit)
1697 {
1698   int done, i, result_count;
1699   int startflag = 1;
1700   int result = 1;
1701   int loopcount = 0;
1702   static threadref nextthread;
1703   static threadref resultthreadlist[MAXTHREADLISTRESULTS];
1704
1705   done = 0;
1706   while (!done)
1707     {
1708       if (loopcount++ > looplimit)
1709         {
1710           result = 0;
1711           warning ("Remote fetch threadlist -infinite loop-\n");
1712           break;
1713         }
1714       if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
1715                                   &done, &result_count, resultthreadlist))
1716         {
1717           result = 0;
1718           break;
1719         }
1720       /* clear for later iterations */
1721       startflag = 0;
1722       /* Setup to resume next batch of thread references, set nextthread.  */
1723       if (result_count >= 1)
1724         copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
1725       i = 0;
1726       while (result_count--)
1727         if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
1728           break;
1729     }
1730   return result;
1731 }
1732
1733 static int
1734 remote_newthread_step (threadref *ref, void *context)
1735 {
1736   ptid_t ptid;
1737
1738   ptid = pid_to_ptid (threadref_to_int (ref));
1739
1740   if (!in_thread_list (ptid))
1741     add_thread (ptid);
1742   return 1;                     /* continue iterator */
1743 }
1744
1745 #define CRAZY_MAX_THREADS 1000
1746
1747 static ptid_t
1748 remote_current_thread (ptid_t oldpid)
1749 {
1750   struct remote_state *rs = get_remote_state ();
1751   char *buf = alloca (rs->remote_packet_size);
1752
1753   putpkt ("qC");
1754   getpkt (buf, (rs->remote_packet_size), 0);
1755   if (buf[0] == 'Q' && buf[1] == 'C')
1756     return pid_to_ptid (strtol (&buf[2], NULL, 16));
1757   else
1758     return oldpid;
1759 }
1760
1761 /* Find new threads for info threads command.  
1762  * Original version, using John Metzler's thread protocol.  
1763  */
1764
1765 static void
1766 remote_find_new_threads (void)
1767 {
1768   remote_threadlist_iterator (remote_newthread_step, 0,
1769                               CRAZY_MAX_THREADS);
1770   if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */
1771     inferior_ptid = remote_current_thread (inferior_ptid);
1772 }
1773
1774 /*
1775  * Find all threads for info threads command.
1776  * Uses new thread protocol contributed by Cisco.
1777  * Falls back and attempts to use the older method (above)
1778  * if the target doesn't respond to the new method.
1779  */
1780
1781 static void
1782 remote_threads_info (void)
1783 {
1784   struct remote_state *rs = get_remote_state ();
1785   char *buf = alloca (rs->remote_packet_size);
1786   char *bufp;
1787   int tid;
1788
1789   if (remote_desc == 0)         /* paranoia */
1790     error ("Command can only be used when connected to the remote target.");
1791
1792   if (use_threadinfo_query)
1793     {
1794       putpkt ("qfThreadInfo");
1795       bufp = buf;
1796       getpkt (bufp, (rs->remote_packet_size), 0);
1797       if (bufp[0] != '\0')              /* q packet recognized */
1798         {       
1799           while (*bufp++ == 'm')        /* reply contains one or more TID */
1800             {
1801               do
1802                 {
1803                   tid = strtol (bufp, &bufp, 16);
1804                   if (tid != 0 && !in_thread_list (pid_to_ptid (tid)))
1805                     add_thread (pid_to_ptid (tid));
1806                 }
1807               while (*bufp++ == ',');   /* comma-separated list */
1808               putpkt ("qsThreadInfo");
1809               bufp = buf;
1810               getpkt (bufp, (rs->remote_packet_size), 0);
1811             }
1812           return;       /* done */
1813         }
1814     }
1815
1816   /* Else fall back to old method based on jmetzler protocol. */
1817   use_threadinfo_query = 0;
1818   remote_find_new_threads ();
1819   return;
1820 }
1821
1822 /* 
1823  * Collect a descriptive string about the given thread.
1824  * The target may say anything it wants to about the thread
1825  * (typically info about its blocked / runnable state, name, etc.).
1826  * This string will appear in the info threads display.
1827  * 
1828  * Optional: targets are not required to implement this function.
1829  */
1830
1831 static char *
1832 remote_threads_extra_info (struct thread_info *tp)
1833 {
1834   struct remote_state *rs = get_remote_state ();
1835   int result;
1836   int set;
1837   threadref id;
1838   struct gdb_ext_thread_info threadinfo;
1839   static char display_buf[100]; /* arbitrary... */
1840   char *bufp = alloca (rs->remote_packet_size);
1841   int n = 0;                    /* position in display_buf */
1842
1843   if (remote_desc == 0)         /* paranoia */
1844     internal_error (__FILE__, __LINE__,
1845                     "remote_threads_extra_info");
1846
1847   if (use_threadextra_query)
1848     {
1849       sprintf (bufp, "qThreadExtraInfo,%x", PIDGET (tp->ptid));
1850       putpkt (bufp);
1851       getpkt (bufp, (rs->remote_packet_size), 0);
1852       if (bufp[0] != 0)
1853         {
1854           n = min (strlen (bufp) / 2, sizeof (display_buf));
1855           result = hex2bin (bufp, display_buf, n);
1856           display_buf [result] = '\0';
1857           return display_buf;
1858         }
1859     }
1860
1861   /* If the above query fails, fall back to the old method.  */
1862   use_threadextra_query = 0;
1863   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
1864     | TAG_MOREDISPLAY | TAG_DISPLAY;
1865   int_to_threadref (&id, PIDGET (tp->ptid));
1866   if (remote_get_threadinfo (&id, set, &threadinfo))
1867     if (threadinfo.active)
1868       {
1869         if (*threadinfo.shortname)
1870           n += sprintf(&display_buf[0], " Name: %s,", threadinfo.shortname);
1871         if (*threadinfo.display)
1872           n += sprintf(&display_buf[n], " State: %s,", threadinfo.display);
1873         if (*threadinfo.more_display)
1874           n += sprintf(&display_buf[n], " Priority: %s",
1875                        threadinfo.more_display);
1876
1877         if (n > 0)
1878           {
1879             /* for purely cosmetic reasons, clear up trailing commas */
1880             if (',' == display_buf[n-1])
1881               display_buf[n-1] = ' ';
1882             return display_buf;
1883           }
1884       }
1885   return NULL;
1886 }
1887
1888 \f
1889
1890 /*  Restart the remote side; this is an extended protocol operation.  */
1891
1892 static void
1893 extended_remote_restart (void)
1894 {
1895   struct remote_state *rs = get_remote_state ();
1896   char *buf = alloca (rs->remote_packet_size);
1897
1898   /* Send the restart command; for reasons I don't understand the
1899      remote side really expects a number after the "R".  */
1900   buf[0] = 'R';
1901   sprintf (&buf[1], "%x", 0);
1902   putpkt (buf);
1903
1904   /* Now query for status so this looks just like we restarted
1905      gdbserver from scratch.  */
1906   putpkt ("?");
1907   getpkt (buf, (rs->remote_packet_size), 0);
1908 }
1909 \f
1910 /* Clean up connection to a remote debugger.  */
1911
1912 /* ARGSUSED */
1913 static void
1914 remote_close (int quitting)
1915 {
1916   if (remote_desc)
1917     serial_close (remote_desc);
1918   remote_desc = NULL;
1919 }
1920
1921 /* Query the remote side for the text, data and bss offsets. */
1922
1923 static void
1924 get_offsets (void)
1925 {
1926   struct remote_state *rs = get_remote_state ();
1927   char *buf = alloca (rs->remote_packet_size);
1928   char *ptr;
1929   int lose;
1930   CORE_ADDR text_addr, data_addr, bss_addr;
1931   struct section_offsets *offs;
1932
1933   putpkt ("qOffsets");
1934
1935   getpkt (buf, (rs->remote_packet_size), 0);
1936
1937   if (buf[0] == '\000')
1938     return;                     /* Return silently.  Stub doesn't support
1939                                    this command. */
1940   if (buf[0] == 'E')
1941     {
1942       warning ("Remote failure reply: %s", buf);
1943       return;
1944     }
1945
1946   /* Pick up each field in turn.  This used to be done with scanf, but
1947      scanf will make trouble if CORE_ADDR size doesn't match
1948      conversion directives correctly.  The following code will work
1949      with any size of CORE_ADDR.  */
1950   text_addr = data_addr = bss_addr = 0;
1951   ptr = buf;
1952   lose = 0;
1953
1954   if (strncmp (ptr, "Text=", 5) == 0)
1955     {
1956       ptr += 5;
1957       /* Don't use strtol, could lose on big values.  */
1958       while (*ptr && *ptr != ';')
1959         text_addr = (text_addr << 4) + fromhex (*ptr++);
1960     }
1961   else
1962     lose = 1;
1963
1964   if (!lose && strncmp (ptr, ";Data=", 6) == 0)
1965     {
1966       ptr += 6;
1967       while (*ptr && *ptr != ';')
1968         data_addr = (data_addr << 4) + fromhex (*ptr++);
1969     }
1970   else
1971     lose = 1;
1972
1973   if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
1974     {
1975       ptr += 5;
1976       while (*ptr && *ptr != ';')
1977         bss_addr = (bss_addr << 4) + fromhex (*ptr++);
1978     }
1979   else
1980     lose = 1;
1981
1982   if (lose)
1983     error ("Malformed response to offset query, %s", buf);
1984
1985   if (symfile_objfile == NULL)
1986     return;
1987
1988   offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
1989   memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
1990
1991   offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
1992
1993   /* This is a temporary kludge to force data and bss to use the same offsets
1994      because that's what nlmconv does now.  The real solution requires changes
1995      to the stub and remote.c that I don't have time to do right now.  */
1996
1997   offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
1998   offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
1999
2000   objfile_relocate (symfile_objfile, offs);
2001 }
2002
2003 /*
2004  * Cisco version of section offsets:
2005  *
2006  * Instead of having GDB query the target for the section offsets,
2007  * Cisco lets the target volunteer the information!  It's also in
2008  * a different format, so here are the functions that will decode
2009  * a section offset packet from a Cisco target.
2010  */
2011
2012 /* 
2013  * Function: remote_cisco_section_offsets
2014  *
2015  * Returns:  zero for success, non-zero for failure 
2016  */
2017
2018 static int
2019 remote_cisco_section_offsets (bfd_vma text_addr,
2020                               bfd_vma data_addr,
2021                               bfd_vma bss_addr,
2022                               bfd_signed_vma *text_offs,
2023                               bfd_signed_vma *data_offs,
2024                               bfd_signed_vma *bss_offs)
2025 {
2026   bfd_vma text_base, data_base, bss_base;
2027   struct minimal_symbol *start;
2028   asection *sect;
2029   bfd *abfd;
2030   int len;
2031
2032   if (symfile_objfile == NULL)
2033     return -1;                  /* no can do nothin' */
2034
2035   start = lookup_minimal_symbol ("_start", NULL, NULL);
2036   if (start == NULL)
2037     return -1;                  /* Can't find "_start" symbol */
2038
2039   data_base = bss_base = 0;
2040   text_base = SYMBOL_VALUE_ADDRESS (start);
2041
2042   abfd = symfile_objfile->obfd;
2043   for (sect = abfd->sections;
2044        sect != 0;
2045        sect = sect->next)
2046     {
2047       const char *p = bfd_get_section_name (abfd, sect);
2048       len = strlen (p);
2049       if (strcmp (p + len - 4, "data") == 0)    /* ends in "data" */
2050         if (data_base == 0 ||
2051             data_base > bfd_get_section_vma (abfd, sect))
2052           data_base = bfd_get_section_vma (abfd, sect);
2053       if (strcmp (p + len - 3, "bss") == 0)     /* ends in "bss" */
2054         if (bss_base == 0 ||
2055             bss_base > bfd_get_section_vma (abfd, sect))
2056           bss_base = bfd_get_section_vma (abfd, sect);
2057     }
2058   *text_offs = text_addr - text_base;
2059   *data_offs = data_addr - data_base;
2060   *bss_offs = bss_addr - bss_base;
2061   if (remote_debug)
2062     {
2063       char tmp[128];
2064
2065       sprintf (tmp, "VMA:          text = 0x");
2066       sprintf_vma (tmp + strlen (tmp), text_addr);
2067       sprintf (tmp + strlen (tmp), " data = 0x");
2068       sprintf_vma (tmp + strlen (tmp), data_addr);
2069       sprintf (tmp + strlen (tmp), " bss = 0x");
2070       sprintf_vma (tmp + strlen (tmp), bss_addr);
2071       fprintf_filtered (gdb_stdlog, tmp);
2072       fprintf_filtered (gdb_stdlog,
2073                         "Reloc offset: text = 0x%s data = 0x%s bss = 0x%s\n",
2074                         paddr_nz (*text_offs),
2075                         paddr_nz (*data_offs),
2076                         paddr_nz (*bss_offs));
2077     }
2078
2079   return 0;
2080 }
2081
2082 /*
2083  * Function: remote_cisco_objfile_relocate
2084  *
2085  * Relocate the symbol file for a remote target. 
2086  */
2087
2088 void
2089 remote_cisco_objfile_relocate (bfd_signed_vma text_off, bfd_signed_vma data_off,
2090                                bfd_signed_vma bss_off)
2091 {
2092   struct section_offsets *offs;
2093
2094   if (text_off != 0 || data_off != 0 || bss_off != 0)
2095     {
2096       /* FIXME: This code assumes gdb-stabs.h is being used; it's
2097          broken for xcoff, dwarf, sdb-coff, etc.  But there is no
2098          simple canonical representation for this stuff.  */
2099
2100       offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS);
2101       memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS);
2102
2103       offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_off;
2104       offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_off;
2105       offs->offsets[SECT_OFF_BSS (symfile_objfile)] = bss_off;
2106
2107       /* First call the standard objfile_relocate.  */
2108       objfile_relocate (symfile_objfile, offs);
2109
2110       /* Now we need to fix up the section entries already attached to
2111          the exec target.  These entries will control memory transfers
2112          from the exec file.  */
2113
2114       exec_set_section_offsets (text_off, data_off, bss_off);
2115     }
2116 }
2117
2118 /* Stub for catch_errors.  */
2119
2120 static int
2121 remote_start_remote_dummy (struct ui_out *uiout, void *dummy)
2122 {
2123   start_remote ();              /* Initialize gdb process mechanisms */
2124   /* NOTE: Return something >=0.  A -ve value is reserved for
2125      catch_exceptions.  */
2126   return 1;
2127 }
2128
2129 static int
2130 remote_start_remote (struct ui_out *uiout, void *dummy)
2131 {
2132   immediate_quit++;             /* Allow user to interrupt it */
2133
2134   /* Ack any packet which the remote side has already sent.  */
2135   serial_write (remote_desc, "+", 1);
2136
2137   /* Let the stub know that we want it to return the thread.  */
2138   set_thread (-1, 0);
2139
2140   inferior_ptid = remote_current_thread (inferior_ptid);
2141
2142   get_offsets ();               /* Get text, data & bss offsets */
2143
2144   putpkt ("?");                 /* initiate a query from remote machine */
2145   immediate_quit--;
2146
2147   /* NOTE: See comment above in remote_start_remote_dummy().  This
2148      function returns something >=0.  */
2149   return remote_start_remote_dummy (uiout, dummy);
2150 }
2151
2152 /* Open a connection to a remote debugger.
2153    NAME is the filename used for communication.  */
2154
2155 static void
2156 remote_open (char *name, int from_tty)
2157 {
2158   remote_open_1 (name, from_tty, &remote_ops, 0, 0);
2159 }
2160
2161 /* Just like remote_open, but with asynchronous support. */
2162 static void
2163 remote_async_open (char *name, int from_tty)
2164 {
2165   remote_open_1 (name, from_tty, &remote_async_ops, 0, 1);
2166 }
2167
2168 /* Open a connection to a remote debugger using the extended
2169    remote gdb protocol.  NAME is the filename used for communication.  */
2170
2171 static void
2172 extended_remote_open (char *name, int from_tty)
2173 {
2174   remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */,
2175                  0 /* async_p */);
2176 }
2177
2178 /* Just like extended_remote_open, but with asynchronous support. */
2179 static void
2180 extended_remote_async_open (char *name, int from_tty)
2181 {
2182   remote_open_1 (name, from_tty, &extended_async_remote_ops,
2183                  1 /*extended_p */, 1 /* async_p */);
2184 }
2185
2186 /* Generic code for opening a connection to a remote target.  */
2187
2188 static void
2189 init_all_packet_configs (void)
2190 {
2191   int i;
2192   update_packet_config (&remote_protocol_e);
2193   update_packet_config (&remote_protocol_E);
2194   update_packet_config (&remote_protocol_P);
2195   update_packet_config (&remote_protocol_qSymbol);
2196   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2197     update_packet_config (&remote_protocol_Z[i]);
2198   /* Force remote_write_bytes to check whether target supports binary
2199      downloading. */
2200   update_packet_config (&remote_protocol_binary_download);
2201 }
2202
2203 /* Symbol look-up. */
2204
2205 static void
2206 remote_check_symbols (struct objfile *objfile)
2207 {
2208   struct remote_state *rs = get_remote_state ();
2209   char *msg, *reply, *tmp;
2210   struct minimal_symbol *sym;
2211   int end;
2212
2213   if (remote_protocol_qSymbol.support == PACKET_DISABLE)
2214     return;
2215
2216   msg   = alloca (rs->remote_packet_size);
2217   reply = alloca (rs->remote_packet_size);
2218
2219   /* Invite target to request symbol lookups. */
2220
2221   putpkt ("qSymbol::");
2222   getpkt (reply, (rs->remote_packet_size), 0);
2223   packet_ok (reply, &remote_protocol_qSymbol);
2224
2225   while (strncmp (reply, "qSymbol:", 8) == 0)
2226     {
2227       tmp = &reply[8];
2228       end = hex2bin (tmp, msg, strlen (tmp) / 2);
2229       msg[end] = '\0';
2230       sym = lookup_minimal_symbol (msg, NULL, NULL);
2231       if (sym == NULL)
2232         sprintf (msg, "qSymbol::%s", &reply[8]);
2233       else
2234         sprintf (msg, "qSymbol:%s:%s", 
2235                  paddr_nz (SYMBOL_VALUE_ADDRESS (sym)),
2236                  &reply[8]);
2237       putpkt (msg);
2238       getpkt (reply, (rs->remote_packet_size), 0);
2239     }
2240 }
2241
2242 static struct serial *
2243 remote_serial_open (char *name)
2244 {
2245   static int udp_warning = 0;
2246
2247   /* FIXME: Parsing NAME here is a hack.  But we want to warn here instead
2248      of in ser-tcp.c, because it is the remote protocol assuming that the
2249      serial connection is reliable and not the serial connection promising
2250      to be.  */
2251   if (!udp_warning && strncmp (name, "udp:", 4) == 0)
2252     {
2253       warning ("The remote protocol may be unreliable over UDP.");
2254       warning ("Some events may be lost, rendering further debugging "
2255                "impossible.");
2256       udp_warning = 1;
2257     }
2258
2259   return serial_open (name);
2260 }
2261
2262 static void
2263 remote_open_1 (char *name, int from_tty, struct target_ops *target,
2264                int extended_p, int async_p)
2265 {
2266   int ex;
2267   struct remote_state *rs = get_remote_state ();
2268   if (name == 0)
2269     error ("To open a remote debug connection, you need to specify what\n"
2270            "serial device is attached to the remote system\n"
2271            "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
2272
2273   /* See FIXME above */
2274   if (!async_p)
2275     wait_forever_enabled_p = 1;
2276
2277   target_preopen (from_tty);
2278
2279   unpush_target (target);
2280
2281   remote_desc = remote_serial_open (name);
2282   if (!remote_desc)
2283     perror_with_name (name);
2284
2285   if (baud_rate != -1)
2286     {
2287       if (serial_setbaudrate (remote_desc, baud_rate))
2288         {
2289           serial_close (remote_desc);
2290           perror_with_name (name);
2291         }
2292     }
2293
2294   serial_raw (remote_desc);
2295
2296   /* If there is something sitting in the buffer we might take it as a
2297      response to a command, which would be bad.  */
2298   serial_flush_input (remote_desc);
2299
2300   if (from_tty)
2301     {
2302       puts_filtered ("Remote debugging using ");
2303       puts_filtered (name);
2304       puts_filtered ("\n");
2305     }
2306   push_target (target);         /* Switch to using remote target now */
2307
2308   init_all_packet_configs ();
2309   
2310   general_thread = -2;
2311   continue_thread = -2;
2312
2313   /* Probe for ability to use "ThreadInfo" query, as required.  */
2314   use_threadinfo_query = 1;
2315   use_threadextra_query = 1;
2316
2317   /* Without this, some commands which require an active target (such
2318      as kill) won't work.  This variable serves (at least) double duty
2319      as both the pid of the target process (if it has such), and as a
2320      flag indicating that a target is active.  These functions should
2321      be split out into seperate variables, especially since GDB will
2322      someday have a notion of debugging several processes.  */
2323
2324   inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
2325
2326   if (async_p)
2327     {
2328       /* With this target we start out by owning the terminal. */
2329       remote_async_terminal_ours_p = 1;
2330
2331       /* FIXME: cagney/1999-09-23: During the initial connection it is
2332          assumed that the target is already ready and able to respond to
2333          requests. Unfortunately remote_start_remote() eventually calls
2334          wait_for_inferior() with no timeout.  wait_forever_enabled_p gets
2335          around this. Eventually a mechanism that allows
2336          wait_for_inferior() to expect/get timeouts will be
2337          implemented. */
2338       wait_forever_enabled_p = 0;
2339     }
2340
2341 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2342   /* First delete any symbols previously loaded from shared libraries. */
2343   no_shared_libraries (NULL, 0);
2344 #endif
2345
2346   /* Start the remote connection.  If error() or QUIT, discard this
2347      target (we'd otherwise be in an inconsistent state) and then
2348      propogate the error on up the exception chain.  This ensures that
2349      the caller doesn't stumble along blindly assuming that the
2350      function succeeded.  The CLI doesn't have this problem but other
2351      UI's, such as MI do.
2352
2353      FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
2354      this function should return an error indication letting the
2355      caller restore the previous state.  Unfortunatly the command
2356      ``target remote'' is directly wired to this function making that
2357      impossible.  On a positive note, the CLI side of this problem has
2358      been fixed - the function set_cmd_context() makes it possible for
2359      all the ``target ....'' commands to share a common callback
2360      function.  See cli-dump.c.  */
2361   ex = catch_exceptions (uiout,
2362                          remote_start_remote, NULL,
2363                          "Couldn't establish connection to remote"
2364                          " target\n",
2365                          RETURN_MASK_ALL);
2366   if (ex < 0)
2367     {
2368       pop_target ();
2369       if (async_p)
2370         wait_forever_enabled_p = 1;
2371       throw_exception (ex);
2372     }
2373
2374   if (async_p)
2375     wait_forever_enabled_p = 1;
2376
2377   if (extended_p)
2378     {
2379       /* Tell the remote that we are using the extended protocol.  */
2380       char *buf = alloca (rs->remote_packet_size);
2381       putpkt ("!");
2382       getpkt (buf, (rs->remote_packet_size), 0);
2383     }
2384 #ifdef SOLIB_CREATE_INFERIOR_HOOK
2385   /* FIXME: need a master target_open vector from which all 
2386      remote_opens can be called, so that stuff like this can 
2387      go there.  Failing that, the following code must be copied
2388      to the open function for any remote target that wants to 
2389      support svr4 shared libraries.  */
2390
2391   /* Set up to detect and load shared libraries. */
2392   if (exec_bfd)         /* No use without an exec file. */
2393     {
2394       SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid));
2395       remote_check_symbols (symfile_objfile);
2396     }
2397 #endif
2398 }
2399
2400 /* This takes a program previously attached to and detaches it.  After
2401    this is done, GDB can be used to debug some other program.  We
2402    better not have left any breakpoints in the target program or it'll
2403    die when it hits one.  */
2404
2405 static void
2406 remote_detach (char *args, int from_tty)
2407 {
2408   struct remote_state *rs = get_remote_state ();
2409   char *buf = alloca (rs->remote_packet_size);
2410
2411   if (args)
2412     error ("Argument given to \"detach\" when remotely debugging.");
2413
2414   /* Tell the remote target to detach.  */
2415   strcpy (buf, "D");
2416   remote_send (buf, (rs->remote_packet_size));
2417
2418   target_mourn_inferior ();
2419   if (from_tty)
2420     puts_filtered ("Ending remote debugging.\n");
2421
2422 }
2423
2424 /* Same as remote_detach, but with async support. */
2425 static void
2426 remote_async_detach (char *args, int from_tty)
2427 {
2428   struct remote_state *rs = get_remote_state ();
2429   char *buf = alloca (rs->remote_packet_size);
2430
2431   if (args)
2432     error ("Argument given to \"detach\" when remotely debugging.");
2433
2434   /* Tell the remote target to detach.  */
2435   strcpy (buf, "D");
2436   remote_send (buf, (rs->remote_packet_size));
2437
2438   /* Unregister the file descriptor from the event loop. */
2439   if (target_is_async_p ())
2440     serial_async (remote_desc, NULL, 0);
2441
2442   target_mourn_inferior ();
2443   if (from_tty)
2444     puts_filtered ("Ending remote debugging.\n");
2445 }
2446
2447 /* Convert hex digit A to a number.  */
2448
2449 static int
2450 fromhex (int a)
2451 {
2452   if (a >= '0' && a <= '9')
2453     return a - '0';
2454   else if (a >= 'a' && a <= 'f')
2455     return a - 'a' + 10;
2456   else if (a >= 'A' && a <= 'F')
2457     return a - 'A' + 10;
2458   else
2459     error ("Reply contains invalid hex digit %d", a);
2460 }
2461
2462 static int
2463 hex2bin (const char *hex, char *bin, int count)
2464 {
2465   int i;
2466
2467   for (i = 0; i < count; i++)
2468     {
2469       if (hex[0] == 0 || hex[1] == 0)
2470         {
2471           /* Hex string is short, or of uneven length.
2472              Return the count that has been converted so far. */
2473           return i;
2474         }
2475       *bin++ = fromhex (hex[0]) * 16 + fromhex (hex[1]);
2476       hex += 2;
2477     }
2478   return i;
2479 }
2480
2481 /* Convert number NIB to a hex digit.  */
2482
2483 static int
2484 tohex (int nib)
2485 {
2486   if (nib < 10)
2487     return '0' + nib;
2488   else
2489     return 'a' + nib - 10;
2490 }
2491
2492 static int
2493 bin2hex (const char *bin, char *hex, int count)
2494 {
2495   int i;
2496   /* May use a length, or a nul-terminated string as input. */
2497   if (count == 0)
2498     count = strlen (bin);
2499
2500   for (i = 0; i < count; i++)
2501     {
2502       *hex++ = tohex ((*bin >> 4) & 0xf);
2503       *hex++ = tohex (*bin++ & 0xf);
2504     }
2505   *hex = 0;
2506   return i;
2507 }
2508 \f
2509 /* Tell the remote machine to resume.  */
2510
2511 static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
2512
2513 static int last_sent_step;
2514
2515 static void
2516 remote_resume (ptid_t ptid, int step, enum target_signal siggnal)
2517 {
2518   struct remote_state *rs = get_remote_state ();
2519   char *buf = alloca (rs->remote_packet_size);
2520   int pid = PIDGET (ptid);
2521   char *p;
2522
2523   if (pid == -1)
2524     set_thread (0, 0);          /* run any thread */
2525   else
2526     set_thread (pid, 0);        /* run this thread */
2527
2528   last_sent_signal = siggnal;
2529   last_sent_step = step;
2530
2531   /* A hook for when we need to do something at the last moment before
2532      resumption.  */
2533   if (target_resume_hook)
2534     (*target_resume_hook) ();
2535
2536
2537   /* The s/S/c/C packets do not return status.  So if the target does
2538      not support the S or C packets, the debug agent returns an empty
2539      string which is detected in remote_wait().  This protocol defect
2540      is fixed in the e/E packets. */
2541
2542   if (step && step_range_end)
2543     {
2544       /* If the target does not support the 'E' packet, we try the 'S'
2545          packet.  Ideally we would fall back to the 'e' packet if that
2546          too is not supported.  But that would require another copy of
2547          the code to issue the 'e' packet (and fall back to 's' if not
2548          supported) in remote_wait().  */
2549       
2550       if (siggnal != TARGET_SIGNAL_0)
2551         {
2552           if (remote_protocol_E.support != PACKET_DISABLE)
2553             {
2554               p = buf;
2555               *p++ = 'E';
2556               *p++ = tohex (((int) siggnal >> 4) & 0xf);
2557               *p++ = tohex (((int) siggnal) & 0xf);
2558               *p++ = ',';
2559               p += hexnumstr (p, (ULONGEST) step_range_start);
2560               *p++ = ',';
2561               p += hexnumstr (p, (ULONGEST) step_range_end);
2562               *p++ = 0;
2563
2564               putpkt (buf);
2565               getpkt (buf, (rs->remote_packet_size), 0);
2566
2567               if (packet_ok (buf, &remote_protocol_E) == PACKET_OK)
2568                 return;
2569             }
2570         }
2571       else
2572         {
2573           if (remote_protocol_e.support != PACKET_DISABLE)
2574             {
2575               p = buf;
2576               *p++ = 'e';
2577               p += hexnumstr (p, (ULONGEST) step_range_start);
2578               *p++ = ',';
2579               p += hexnumstr (p, (ULONGEST) step_range_end);
2580               *p++ = 0;
2581
2582               putpkt (buf);
2583               getpkt (buf, (rs->remote_packet_size), 0);
2584
2585               if (packet_ok (buf, &remote_protocol_e) == PACKET_OK)
2586                 return;
2587             }
2588         }
2589     }
2590
2591   if (siggnal != TARGET_SIGNAL_0)
2592     {
2593       buf[0] = step ? 'S' : 'C';
2594       buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2595       buf[2] = tohex (((int) siggnal) & 0xf);
2596       buf[3] = '\0';
2597     }
2598   else
2599     strcpy (buf, step ? "s" : "c");
2600
2601   putpkt (buf);
2602 }
2603
2604 /* Same as remote_resume, but with async support. */
2605 static void
2606 remote_async_resume (ptid_t ptid, int step, enum target_signal siggnal)
2607 {
2608   struct remote_state *rs = get_remote_state ();
2609   char *buf = alloca (rs->remote_packet_size);
2610   int pid = PIDGET (ptid);
2611   char *p;
2612
2613   if (pid == -1)
2614     set_thread (0, 0);          /* run any thread */
2615   else
2616     set_thread (pid, 0);        /* run this thread */
2617
2618   last_sent_signal = siggnal;
2619   last_sent_step = step;
2620
2621   /* A hook for when we need to do something at the last moment before
2622      resumption.  */
2623   if (target_resume_hook)
2624     (*target_resume_hook) ();
2625
2626   /* The s/S/c/C packets do not return status.  So if the target does
2627      not support the S or C packets, the debug agent returns an empty
2628      string which is detected in remote_wait().  This protocol defect
2629      is fixed in the e/E packets. */
2630
2631   if (step && step_range_end)
2632     {
2633       /* If the target does not support the 'E' packet, we try the 'S'
2634          packet.  Ideally we would fall back to the 'e' packet if that
2635          too is not supported.  But that would require another copy of
2636          the code to issue the 'e' packet (and fall back to 's' if not
2637          supported) in remote_wait().  */
2638       
2639       if (siggnal != TARGET_SIGNAL_0)
2640         {
2641           if (remote_protocol_E.support != PACKET_DISABLE)
2642             {
2643               p = buf;
2644               *p++ = 'E';
2645               *p++ = tohex (((int) siggnal >> 4) & 0xf);
2646               *p++ = tohex (((int) siggnal) & 0xf);
2647               *p++ = ',';
2648               p += hexnumstr (p, (ULONGEST) step_range_start);
2649               *p++ = ',';
2650               p += hexnumstr (p, (ULONGEST) step_range_end);
2651               *p++ = 0;
2652
2653               putpkt (buf);
2654               getpkt (buf, (rs->remote_packet_size), 0);
2655
2656               if (packet_ok (buf, &remote_protocol_E) == PACKET_OK)
2657                 goto register_event_loop;
2658             }
2659         }
2660       else
2661         {
2662           if (remote_protocol_e.support != PACKET_DISABLE)
2663             {
2664               p = buf;
2665               *p++ = 'e';
2666               p += hexnumstr (p, (ULONGEST) step_range_start);
2667               *p++ = ',';
2668               p += hexnumstr (p, (ULONGEST) step_range_end);
2669               *p++ = 0;
2670
2671               putpkt (buf);
2672               getpkt (buf, (rs->remote_packet_size), 0);
2673
2674               if (packet_ok (buf, &remote_protocol_e) == PACKET_OK)
2675                 goto register_event_loop;
2676             }
2677         }
2678     }
2679
2680   if (siggnal != TARGET_SIGNAL_0)
2681     {
2682       buf[0] = step ? 'S' : 'C';
2683       buf[1] = tohex (((int) siggnal >> 4) & 0xf);
2684       buf[2] = tohex ((int) siggnal & 0xf);
2685       buf[3] = '\0';
2686     }
2687   else
2688     strcpy (buf, step ? "s" : "c");
2689   
2690   putpkt (buf);
2691
2692 register_event_loop:
2693   /* We are about to start executing the inferior, let's register it
2694      with the event loop. NOTE: this is the one place where all the
2695      execution commands end up. We could alternatively do this in each
2696      of the execution commands in infcmd.c.*/
2697   /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
2698      into infcmd.c in order to allow inferior function calls to work
2699      NOT asynchronously. */
2700   if (event_loop_p && target_can_async_p ())
2701     target_async (inferior_event_handler, 0);
2702   /* Tell the world that the target is now executing. */
2703   /* FIXME: cagney/1999-09-23: Is it the targets responsibility to set
2704      this?  Instead, should the client of target just assume (for
2705      async targets) that the target is going to start executing?  Is
2706      this information already found in the continuation block?  */
2707   if (target_is_async_p ())
2708     target_executing = 1;
2709 }
2710 \f
2711
2712 /* Set up the signal handler for SIGINT, while the target is
2713    executing, ovewriting the 'regular' SIGINT signal handler. */
2714 static void
2715 initialize_sigint_signal_handler (void)
2716 {
2717   sigint_remote_token =
2718     create_async_signal_handler (async_remote_interrupt, NULL);
2719   signal (SIGINT, handle_remote_sigint);
2720 }
2721
2722 /* Signal handler for SIGINT, while the target is executing. */
2723 static void
2724 handle_remote_sigint (int sig)
2725 {
2726   signal (sig, handle_remote_sigint_twice);
2727   sigint_remote_twice_token =
2728     create_async_signal_handler (async_remote_interrupt_twice, NULL);
2729   mark_async_signal_handler_wrapper (sigint_remote_token);
2730 }
2731
2732 /* Signal handler for SIGINT, installed after SIGINT has already been
2733    sent once.  It will take effect the second time that the user sends
2734    a ^C. */
2735 static void
2736 handle_remote_sigint_twice (int sig)
2737 {
2738   signal (sig, handle_sigint);
2739   sigint_remote_twice_token =
2740     create_async_signal_handler (inferior_event_handler_wrapper, NULL);
2741   mark_async_signal_handler_wrapper (sigint_remote_twice_token);
2742 }
2743
2744 /* Perform the real interruption of the target execution, in response
2745    to a ^C. */
2746 static void
2747 async_remote_interrupt (gdb_client_data arg)
2748 {
2749   if (remote_debug)
2750     fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2751
2752   target_stop ();
2753 }
2754
2755 /* Perform interrupt, if the first attempt did not succeed. Just give
2756    up on the target alltogether. */
2757 void
2758 async_remote_interrupt_twice (gdb_client_data arg)
2759 {
2760   if (remote_debug)
2761     fprintf_unfiltered (gdb_stdlog, "remote_interrupt_twice called\n");
2762   /* Do something only if the target was not killed by the previous
2763      cntl-C. */
2764   if (target_executing)
2765     {
2766       interrupt_query ();
2767       signal (SIGINT, handle_remote_sigint);
2768     }
2769 }
2770
2771 /* Reinstall the usual SIGINT handlers, after the target has
2772    stopped. */
2773 static void
2774 cleanup_sigint_signal_handler (void *dummy)
2775 {
2776   signal (SIGINT, handle_sigint);
2777   if (sigint_remote_twice_token)
2778     delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_twice_token);
2779   if (sigint_remote_token)
2780     delete_async_signal_handler ((struct async_signal_handler **) & sigint_remote_token);
2781 }
2782
2783 /* Send ^C to target to halt it.  Target will respond, and send us a
2784    packet.  */
2785 static void (*ofunc) (int);
2786
2787 /* The command line interface's stop routine. This function is installed
2788    as a signal handler for SIGINT. The first time a user requests a
2789    stop, we call remote_stop to send a break or ^C. If there is no
2790    response from the target (it didn't stop when the user requested it),
2791    we ask the user if he'd like to detach from the target. */
2792 static void
2793 remote_interrupt (int signo)
2794 {
2795   /* If this doesn't work, try more severe steps. */
2796   signal (signo, remote_interrupt_twice);
2797
2798   if (remote_debug)
2799     fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
2800
2801   target_stop ();
2802 }
2803
2804 /* The user typed ^C twice.  */
2805
2806 static void
2807 remote_interrupt_twice (int signo)
2808 {
2809   signal (signo, ofunc);
2810   interrupt_query ();
2811   signal (signo, remote_interrupt);
2812 }
2813
2814 /* This is the generic stop called via the target vector. When a target
2815    interrupt is requested, either by the command line or the GUI, we
2816    will eventually end up here. */
2817 static void
2818 remote_stop (void)
2819 {
2820   /* Send a break or a ^C, depending on user preference.  */
2821   if (remote_debug)
2822     fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
2823
2824   if (remote_break)
2825     serial_send_break (remote_desc);
2826   else
2827     serial_write (remote_desc, "\003", 1);
2828 }
2829
2830 /* Ask the user what to do when an interrupt is received.  */
2831
2832 static void
2833 interrupt_query (void)
2834 {
2835   target_terminal_ours ();
2836
2837   if (query ("Interrupted while waiting for the program.\n\
2838 Give up (and stop debugging it)? "))
2839     {
2840       target_mourn_inferior ();
2841       throw_exception (RETURN_QUIT);
2842     }
2843
2844   target_terminal_inferior ();
2845 }
2846
2847 /* Enable/disable target terminal ownership.  Most targets can use
2848    terminal groups to control terminal ownership.  Remote targets are
2849    different in that explicit transfer of ownership to/from GDB/target
2850    is required. */
2851
2852 static void
2853 remote_async_terminal_inferior (void)
2854 {
2855   /* FIXME: cagney/1999-09-27: Shouldn't need to test for
2856      sync_execution here.  This function should only be called when
2857      GDB is resuming the inferior in the forground.  A background
2858      resume (``run&'') should leave GDB in control of the terminal and
2859      consequently should not call this code. */
2860   if (!sync_execution)
2861     return;
2862   /* FIXME: cagney/1999-09-27: Closely related to the above.  Make
2863      calls target_terminal_*() idenpotent. The event-loop GDB talking
2864      to an asynchronous target with a synchronous command calls this
2865      function from both event-top.c and infrun.c/infcmd.c.  Once GDB
2866      stops trying to transfer the terminal to the target when it
2867      shouldn't this guard can go away.  */
2868   if (!remote_async_terminal_ours_p)
2869     return;
2870   delete_file_handler (input_fd);
2871   remote_async_terminal_ours_p = 0;
2872   initialize_sigint_signal_handler ();
2873   /* NOTE: At this point we could also register our selves as the
2874      recipient of all input.  Any characters typed could then be
2875      passed on down to the target. */
2876 }
2877
2878 static void
2879 remote_async_terminal_ours (void)
2880 {
2881   /* See FIXME in remote_async_terminal_inferior. */
2882   if (!sync_execution)
2883     return;
2884   /* See FIXME in remote_async_terminal_inferior. */
2885   if (remote_async_terminal_ours_p)
2886     return;
2887   cleanup_sigint_signal_handler (NULL);
2888   add_file_handler (input_fd, stdin_event_handler, 0);
2889   remote_async_terminal_ours_p = 1;
2890 }
2891
2892 /* If nonzero, ignore the next kill.  */
2893
2894 int kill_kludge;
2895
2896 void
2897 remote_console_output (char *msg)
2898 {
2899   char *p;
2900
2901   for (p = msg; p[0] && p[1]; p += 2)
2902     {
2903       char tb[2];
2904       char c = fromhex (p[0]) * 16 + fromhex (p[1]);
2905       tb[0] = c;
2906       tb[1] = 0;
2907       fputs_unfiltered (tb, gdb_stdtarg);
2908     }
2909   gdb_flush (gdb_stdtarg);
2910 }
2911
2912 /* Wait until the remote machine stops, then return,
2913    storing status in STATUS just as `wait' would.
2914    Returns "pid", which in the case of a multi-threaded 
2915    remote OS, is the thread-id.  */
2916
2917 static ptid_t
2918 remote_wait (ptid_t ptid, struct target_waitstatus *status)
2919 {
2920   struct remote_state *rs = get_remote_state ();
2921   unsigned char *buf = alloca (rs->remote_packet_size);
2922   ULONGEST thread_num = -1;
2923   ULONGEST addr;
2924
2925   status->kind = TARGET_WAITKIND_EXITED;
2926   status->value.integer = 0;
2927
2928   while (1)
2929     {
2930       unsigned char *p;
2931
2932       ofunc = signal (SIGINT, remote_interrupt);
2933       getpkt (buf, (rs->remote_packet_size), 1);
2934       signal (SIGINT, ofunc);
2935
2936       /* This is a hook for when we need to do something (perhaps the
2937          collection of trace data) every time the target stops.  */
2938       if (target_wait_loop_hook)
2939         (*target_wait_loop_hook) ();
2940
2941       remote_stopped_by_watchpoint_p = 0;
2942
2943       switch (buf[0])
2944         {
2945         case 'E':               /* Error of some sort */
2946           warning ("Remote failure reply: %s", buf);
2947           continue;
2948         case 'T':               /* Status with PC, SP, FP, ... */
2949           {
2950             int i;
2951             char regs[MAX_REGISTER_SIZE];
2952
2953             /* Expedited reply, containing Signal, {regno, reg} repeat */
2954             /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
2955                ss = signal number
2956                n... = register number
2957                r... = register contents
2958              */
2959             p = &buf[3];        /* after Txx */
2960
2961             while (*p)
2962               {
2963                 unsigned char *p1;
2964                 char *p_temp;
2965                 int fieldsize;
2966                 LONGEST pnum = 0;
2967
2968                 /* If the packet contains a register number save it in pnum
2969                    and set p1 to point to the character following it. 
2970                    Otherwise p1 points to p.  */
2971
2972                 /* If this packet is an awatch packet, don't parse the 'a'
2973                    as a register number.  */
2974
2975                 if (strncmp (p, "awatch", strlen("awatch")) != 0)
2976                   {
2977                     /* Read the ``P'' register number.  */
2978                     pnum = strtol (p, &p_temp, 16);
2979                     p1 = (unsigned char *) p_temp;
2980                   }
2981                 else 
2982                   p1 = p;
2983
2984                 if (p1 == p)    /* No register number present here */
2985                   {
2986                     p1 = (unsigned char *) strchr (p, ':');
2987                     if (p1 == NULL)
2988                       warning ("Malformed packet(a) (missing colon): %s\n\
2989 Packet: '%s'\n",
2990                                p, buf);
2991                     if (strncmp (p, "thread", p1 - p) == 0)
2992                       {
2993                         p_temp = unpack_varlen_hex (++p1, &thread_num);
2994                         record_currthread (thread_num);
2995                         p = (unsigned char *) p_temp;
2996                       }
2997                     else if ((strncmp (p, "watch", p1 - p) == 0)
2998                              || (strncmp (p, "rwatch", p1 - p) == 0)
2999                              || (strncmp (p, "awatch", p1 - p) == 0))
3000                       {
3001                         remote_stopped_by_watchpoint_p = 1;
3002                         p = unpack_varlen_hex (++p1, &addr);
3003                         remote_watch_data_address = (CORE_ADDR)addr;
3004                       }
3005                     else
3006                       {
3007                         /* Silently skip unknown optional info.  */
3008                         p_temp = strchr (p1 + 1, ';');
3009                         if (p_temp)
3010                           p = (unsigned char *) p_temp;
3011                       }
3012                   }
3013                 else
3014                   {
3015                     struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
3016                     p = p1;
3017
3018                     if (*p++ != ':')
3019                       warning ("Malformed packet(b) (missing colon): %s\n\
3020 Packet: '%s'\n",
3021                                p, buf);
3022
3023                     if (reg == NULL)
3024                       warning ("Remote sent bad register number %s: %s\n\
3025 Packet: '%s'\n",
3026                                phex_nz (pnum, 0), p, buf);
3027
3028                     fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum));
3029                     p += 2 * fieldsize;
3030                     if (fieldsize < REGISTER_RAW_SIZE (reg->regnum))
3031                       warning ("Remote reply is too short: %s", buf);
3032                     supply_register (reg->regnum, regs);
3033                   }
3034
3035                 if (*p++ != ';')
3036                   {
3037                     warning ("Remote register badly formatted: %s", buf);
3038                     warning ("            here: %s", p);
3039                   }
3040               }
3041           }
3042           /* fall through */
3043         case 'S':               /* Old style status, just signal only */
3044           status->kind = TARGET_WAITKIND_STOPPED;
3045           status->value.sig = (enum target_signal)
3046             (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3047
3048           if (buf[3] == 'p')
3049             {
3050               /* Export Cisco kernel mode as a convenience variable
3051                  (so that it can be used in the GDB prompt if desired). */
3052
3053               if (cisco_kernel_mode == 1)
3054                 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
3055                                  value_from_string ("PDEBUG-"));
3056               cisco_kernel_mode = 0;
3057               thread_num = strtol ((const char *) &buf[4], NULL, 16);
3058               record_currthread (thread_num);
3059             }
3060           else if (buf[3] == 'k')
3061             {
3062               /* Export Cisco kernel mode as a convenience variable
3063                  (so that it can be used in the GDB prompt if desired). */
3064
3065               if (cisco_kernel_mode == 1)
3066                 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
3067                                  value_from_string ("KDEBUG-"));
3068               cisco_kernel_mode = 1;
3069             }
3070           goto got_status;
3071         case 'N':               /* Cisco special: status and offsets */
3072           {
3073             bfd_vma text_addr, data_addr, bss_addr;
3074             bfd_signed_vma text_off, data_off, bss_off;
3075             unsigned char *p1;
3076
3077             status->kind = TARGET_WAITKIND_STOPPED;
3078             status->value.sig = (enum target_signal)
3079               (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3080
3081             if (symfile_objfile == NULL)
3082               {
3083                 warning ("Relocation packet received with no symbol file.  \
3084 Packet Dropped");
3085                 goto got_status;
3086               }
3087
3088             /* Relocate object file.  Buffer format is NAATT;DD;BB
3089              * where AA is the signal number, TT is the new text
3090              * address, DD * is the new data address, and BB is the
3091              * new bss address.  */
3092
3093             p = &buf[3];
3094             text_addr = strtoul (p, (char **) &p1, 16);
3095             if (p1 == p || *p1 != ';')
3096               warning ("Malformed relocation packet: Packet '%s'", buf);
3097             p = p1 + 1;
3098             data_addr = strtoul (p, (char **) &p1, 16);
3099             if (p1 == p || *p1 != ';')
3100               warning ("Malformed relocation packet: Packet '%s'", buf);
3101             p = p1 + 1;
3102             bss_addr = strtoul (p, (char **) &p1, 16);
3103             if (p1 == p)
3104               warning ("Malformed relocation packet: Packet '%s'", buf);
3105
3106             if (remote_cisco_section_offsets (text_addr, data_addr, bss_addr,
3107                                               &text_off, &data_off, &bss_off)
3108                 == 0)
3109               if (text_off != 0 || data_off != 0 || bss_off != 0)
3110                 remote_cisco_objfile_relocate (text_off, data_off, bss_off);
3111
3112             goto got_status;
3113           }
3114         case 'W':               /* Target exited */
3115           {
3116             /* The remote process exited.  */
3117             status->kind = TARGET_WAITKIND_EXITED;
3118             status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3119             goto got_status;
3120           }
3121         case 'X':
3122           status->kind = TARGET_WAITKIND_SIGNALLED;
3123           status->value.sig = (enum target_signal)
3124             (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3125           kill_kludge = 1;
3126
3127           goto got_status;
3128         case 'O':               /* Console output */
3129           remote_console_output (buf + 1);
3130           continue;
3131         case '\0':
3132           if (last_sent_signal != TARGET_SIGNAL_0)
3133             {
3134               /* Zero length reply means that we tried 'S' or 'C' and
3135                  the remote system doesn't support it.  */
3136               target_terminal_ours_for_output ();
3137               printf_filtered
3138                 ("Can't send signals to this remote system.  %s not sent.\n",
3139                  target_signal_to_name (last_sent_signal));
3140               last_sent_signal = TARGET_SIGNAL_0;
3141               target_terminal_inferior ();
3142
3143               strcpy ((char *) buf, last_sent_step ? "s" : "c");
3144               putpkt ((char *) buf);
3145               continue;
3146             }
3147           /* else fallthrough */
3148         default:
3149           warning ("Invalid remote reply: %s", buf);
3150           continue;
3151         }
3152     }
3153 got_status:
3154   if (thread_num != -1)
3155     {
3156       return pid_to_ptid (thread_num);
3157     }
3158   return inferior_ptid;
3159 }
3160
3161 /* Async version of remote_wait. */
3162 static ptid_t
3163 remote_async_wait (ptid_t ptid, struct target_waitstatus *status)
3164 {
3165   struct remote_state *rs = get_remote_state ();
3166   unsigned char *buf = alloca (rs->remote_packet_size);
3167   ULONGEST thread_num = -1;
3168   ULONGEST addr;
3169
3170   status->kind = TARGET_WAITKIND_EXITED;
3171   status->value.integer = 0;
3172
3173   remote_stopped_by_watchpoint_p = 0;
3174
3175   while (1)
3176     {
3177       unsigned char *p;
3178
3179       if (!target_is_async_p ())
3180         ofunc = signal (SIGINT, remote_interrupt);
3181       /* FIXME: cagney/1999-09-27: If we're in async mode we should
3182          _never_ wait for ever -> test on target_is_async_p().
3183          However, before we do that we need to ensure that the caller
3184          knows how to take the target into/out of async mode. */
3185       getpkt (buf, (rs->remote_packet_size), wait_forever_enabled_p);
3186       if (!target_is_async_p ())
3187         signal (SIGINT, ofunc);
3188
3189       /* This is a hook for when we need to do something (perhaps the
3190          collection of trace data) every time the target stops.  */
3191       if (target_wait_loop_hook)
3192         (*target_wait_loop_hook) ();
3193
3194       switch (buf[0])
3195         {
3196         case 'E':               /* Error of some sort */
3197           warning ("Remote failure reply: %s", buf);
3198           continue;
3199         case 'T':               /* Status with PC, SP, FP, ... */
3200           {
3201             int i;
3202             char regs[MAX_REGISTER_SIZE];
3203
3204             /* Expedited reply, containing Signal, {regno, reg} repeat */
3205             /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
3206                ss = signal number
3207                n... = register number
3208                r... = register contents
3209              */
3210             p = &buf[3];        /* after Txx */
3211
3212             while (*p)
3213               {
3214                 unsigned char *p1;
3215                 char *p_temp;
3216                 int fieldsize;
3217                 long pnum = 0;
3218
3219                 /* If the packet contains a register number, save it in pnum
3220                    and set p1 to point to the character following it. 
3221                    Otherwise p1 points to p.  */
3222
3223                 /* If this packet is an awatch packet, don't parse the 'a'
3224                    as a register number.  */
3225                 
3226                 if (!strncmp (p, "awatch", strlen ("awatch")) != 0)
3227                   {
3228                     /* Read the register number.  */
3229                     pnum = strtol (p, &p_temp, 16);
3230                     p1 = (unsigned char *) p_temp;
3231                   }
3232                 else 
3233                   p1 = p;
3234
3235                 if (p1 == p)    /* No register number present here */
3236                   {
3237                     p1 = (unsigned char *) strchr (p, ':');
3238                     if (p1 == NULL)
3239                       warning ("Malformed packet(a) (missing colon): %s\n\
3240 Packet: '%s'\n",
3241                                p, buf);
3242                     if (strncmp (p, "thread", p1 - p) == 0)
3243                       {
3244                         p_temp = unpack_varlen_hex (++p1, &thread_num);
3245                         record_currthread (thread_num);
3246                         p = (unsigned char *) p_temp;
3247                       }
3248                     else if ((strncmp (p, "watch", p1 - p) == 0)
3249                              || (strncmp (p, "rwatch", p1 - p) == 0)
3250                              || (strncmp (p, "awatch", p1 - p) == 0))
3251                       {
3252                         remote_stopped_by_watchpoint_p = 1;
3253                         p = unpack_varlen_hex (++p1, &addr);
3254                         remote_watch_data_address = (CORE_ADDR)addr;
3255                       }
3256                     else
3257                       {
3258                         /* Silently skip unknown optional info.  */
3259                         p_temp = (unsigned char *) strchr (p1 + 1, ';');
3260                         if (p_temp)
3261                           p = p_temp;
3262                       }
3263                   }
3264                 
3265                 else
3266                   {
3267                     struct packet_reg *reg = packet_reg_from_pnum (rs, pnum);
3268                     p = p1;
3269                     if (*p++ != ':')
3270                       warning ("Malformed packet(b) (missing colon): %s\n\
3271 Packet: '%s'\n",
3272                                p, buf);
3273
3274                     if (reg == NULL)
3275                       warning ("Remote sent bad register number %ld: %s\n\
3276 Packet: '%s'\n",
3277                                pnum, p, buf);
3278
3279                     fieldsize = hex2bin (p, regs, REGISTER_RAW_SIZE (reg->regnum));
3280                     p += 2 * fieldsize;
3281                     if (fieldsize < REGISTER_RAW_SIZE (reg->regnum))
3282                       warning ("Remote reply is too short: %s", buf);
3283                     supply_register (reg->regnum, regs);
3284                   }
3285
3286                 if (*p++ != ';')
3287                   {
3288                     warning ("Remote register badly formatted: %s", buf);
3289                     warning ("            here: %s", p);
3290                   }
3291               }
3292           }
3293           /* fall through */
3294         case 'S':               /* Old style status, just signal only */
3295           status->kind = TARGET_WAITKIND_STOPPED;
3296           status->value.sig = (enum target_signal)
3297             (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3298
3299           if (buf[3] == 'p')
3300             {
3301               /* Export Cisco kernel mode as a convenience variable
3302                  (so that it can be used in the GDB prompt if desired). */
3303
3304               if (cisco_kernel_mode == 1)
3305                 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
3306                                  value_from_string ("PDEBUG-"));
3307               cisco_kernel_mode = 0;
3308               thread_num = strtol ((const char *) &buf[4], NULL, 16);
3309               record_currthread (thread_num);
3310             }
3311           else if (buf[3] == 'k')
3312             {
3313               /* Export Cisco kernel mode as a convenience variable
3314                  (so that it can be used in the GDB prompt if desired). */
3315
3316               if (cisco_kernel_mode == 1)
3317                 set_internalvar (lookup_internalvar ("cisco_kernel_mode"),
3318                                  value_from_string ("KDEBUG-"));
3319               cisco_kernel_mode = 1;
3320             }
3321           goto got_status;
3322         case 'N':               /* Cisco special: status and offsets */
3323           {
3324             bfd_vma text_addr, data_addr, bss_addr;
3325             bfd_signed_vma text_off, data_off, bss_off;
3326             unsigned char *p1;
3327
3328             status->kind = TARGET_WAITKIND_STOPPED;
3329             status->value.sig = (enum target_signal)
3330               (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3331
3332             if (symfile_objfile == NULL)
3333               {
3334                 warning ("Relocation packet recieved with no symbol file.  \
3335 Packet Dropped");
3336                 goto got_status;
3337               }
3338
3339             /* Relocate object file.  Buffer format is NAATT;DD;BB
3340              * where AA is the signal number, TT is the new text
3341              * address, DD * is the new data address, and BB is the
3342              * new bss address.  */
3343
3344             p = &buf[3];
3345             text_addr = strtoul (p, (char **) &p1, 16);
3346             if (p1 == p || *p1 != ';')
3347               warning ("Malformed relocation packet: Packet '%s'", buf);
3348             p = p1 + 1;
3349             data_addr = strtoul (p, (char **) &p1, 16);
3350             if (p1 == p || *p1 != ';')
3351               warning ("Malformed relocation packet: Packet '%s'", buf);
3352             p = p1 + 1;
3353             bss_addr = strtoul (p, (char **) &p1, 16);
3354             if (p1 == p)
3355               warning ("Malformed relocation packet: Packet '%s'", buf);
3356
3357             if (remote_cisco_section_offsets (text_addr, data_addr, bss_addr,
3358                                               &text_off, &data_off, &bss_off)
3359                 == 0)
3360               if (text_off != 0 || data_off != 0 || bss_off != 0)
3361                 remote_cisco_objfile_relocate (text_off, data_off, bss_off);
3362
3363             goto got_status;
3364           }
3365         case 'W':               /* Target exited */
3366           {
3367             /* The remote process exited.  */
3368             status->kind = TARGET_WAITKIND_EXITED;
3369             status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
3370             goto got_status;
3371           }
3372         case 'X':
3373           status->kind = TARGET_WAITKIND_SIGNALLED;
3374           status->value.sig = (enum target_signal)
3375             (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
3376           kill_kludge = 1;
3377
3378           goto got_status;
3379         case 'O':               /* Console output */
3380           remote_console_output (buf + 1);
3381           /* Return immediately to the event loop. The event loop will
3382              still be waiting on the inferior afterwards. */
3383           status->kind = TARGET_WAITKIND_IGNORE;
3384           goto got_status;
3385         case '\0':
3386           if (last_sent_signal != TARGET_SIGNAL_0)
3387             {
3388               /* Zero length reply means that we tried 'S' or 'C' and
3389                  the remote system doesn't support it.  */
3390               target_terminal_ours_for_output ();
3391               printf_filtered
3392                 ("Can't send signals to this remote system.  %s not sent.\n",
3393                  target_signal_to_name (last_sent_signal));
3394               last_sent_signal = TARGET_SIGNAL_0;
3395               target_terminal_inferior ();
3396
3397               strcpy ((char *) buf, last_sent_step ? "s" : "c");
3398               putpkt ((char *) buf);
3399               continue;
3400             }
3401           /* else fallthrough */
3402         default:
3403           warning ("Invalid remote reply: %s", buf);
3404           continue;
3405         }
3406     }
3407 got_status:
3408   if (thread_num != -1)
3409     {
3410       return pid_to_ptid (thread_num);
3411     }
3412   return inferior_ptid;
3413 }
3414
3415 /* Number of bytes of registers this stub implements.  */
3416
3417 static int register_bytes_found;
3418
3419 /* Read the remote registers into the block REGS.  */
3420 /* Currently we just read all the registers, so we don't use regnum.  */
3421
3422 /* ARGSUSED */
3423 static void
3424 remote_fetch_registers (int regnum)
3425 {
3426   struct remote_state *rs = get_remote_state ();
3427   char *buf = alloca (rs->remote_packet_size);
3428   int i;
3429   char *p;
3430   char *regs = alloca (rs->sizeof_g_packet);
3431
3432   set_thread (PIDGET (inferior_ptid), 1);
3433
3434   if (regnum >= 0)
3435     {
3436       struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3437       gdb_assert (reg != NULL);
3438       if (!reg->in_g_packet)
3439         internal_error (__FILE__, __LINE__,
3440                         "Attempt to fetch a non G-packet register when this "
3441                         "remote.c does not support the p-packet.");
3442     }
3443
3444   sprintf (buf, "g");
3445   remote_send (buf, (rs->remote_packet_size));
3446
3447   /* Save the size of the packet sent to us by the target.  Its used
3448      as a heuristic when determining the max size of packets that the
3449      target can safely receive. */
3450   if ((rs->actual_register_packet_size) == 0)
3451     (rs->actual_register_packet_size) = strlen (buf);
3452
3453   /* Unimplemented registers read as all bits zero.  */
3454   memset (regs, 0, rs->sizeof_g_packet);
3455
3456   /* We can get out of synch in various cases.  If the first character
3457      in the buffer is not a hex character, assume that has happened
3458      and try to fetch another packet to read.  */
3459   while ((buf[0] < '0' || buf[0] > '9')
3460          && (buf[0] < 'a' || buf[0] > 'f')
3461          && buf[0] != 'x')      /* New: unavailable register value */
3462     {
3463       if (remote_debug)
3464         fprintf_unfiltered (gdb_stdlog,
3465                             "Bad register packet; fetching a new packet\n");
3466       getpkt (buf, (rs->remote_packet_size), 0);
3467     }
3468
3469   /* Reply describes registers byte by byte, each byte encoded as two
3470      hex characters.  Suck them all up, then supply them to the
3471      register cacheing/storage mechanism.  */
3472
3473   p = buf;
3474   for (i = 0; i < rs->sizeof_g_packet; i++)
3475     {
3476       if (p[0] == 0)
3477         break;
3478       if (p[1] == 0)
3479         {
3480           warning ("Remote reply is of odd length: %s", buf);
3481           /* Don't change register_bytes_found in this case, and don't
3482              print a second warning.  */
3483           goto supply_them;
3484         }
3485       if (p[0] == 'x' && p[1] == 'x')
3486         regs[i] = 0;            /* 'x' */
3487       else
3488         regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
3489       p += 2;
3490     }
3491
3492   if (i != register_bytes_found)
3493     {
3494       register_bytes_found = i;
3495       if (REGISTER_BYTES_OK_P ()
3496           && !REGISTER_BYTES_OK (i))
3497         warning ("Remote reply is too short: %s", buf);
3498     }
3499
3500  supply_them:
3501   {
3502     int i;
3503     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3504       {
3505         struct packet_reg *r = &rs->regs[i];
3506         if (r->in_g_packet)
3507           {
3508             supply_register (r->regnum, regs + r->offset);
3509             if (buf[r->offset * 2] == 'x')
3510               set_register_cached (i, -1);
3511           }
3512       }
3513   }
3514 }
3515
3516 /* Prepare to store registers.  Since we may send them all (using a
3517    'G' request), we have to read out the ones we don't want to change
3518    first.  */
3519
3520 static void
3521 remote_prepare_to_store (void)
3522 {
3523   /* Make sure the entire registers array is valid.  */
3524   switch (remote_protocol_P.support)
3525     {
3526     case PACKET_DISABLE:
3527     case PACKET_SUPPORT_UNKNOWN:
3528       /* NOTE: This isn't rs->sizeof_g_packet because here, we are
3529          forcing the register cache to read its and not the target
3530          registers.  */
3531       deprecated_read_register_bytes (0, (char *) NULL,
3532                                       DEPRECATED_REGISTER_BYTES); /* OK */
3533       break;
3534     case PACKET_ENABLE:
3535       break;
3536     }
3537 }
3538
3539 /* Helper: Attempt to store REGNUM using the P packet.  Return fail IFF
3540    packet was not recognized. */
3541
3542 static int
3543 store_register_using_P (int regnum)
3544 {
3545   struct remote_state *rs = get_remote_state ();
3546   struct packet_reg *reg = packet_reg_from_regnum (rs, regnum);
3547   /* Try storing a single register.  */
3548   char *buf = alloca (rs->remote_packet_size);
3549   char regp[MAX_REGISTER_SIZE];
3550   char *p;
3551   int i;
3552
3553   sprintf (buf, "P%s=", phex_nz (reg->pnum, 0));
3554   p = buf + strlen (buf);
3555   regcache_collect (reg->regnum, regp);
3556   bin2hex (regp, p, REGISTER_RAW_SIZE (reg->regnum));
3557   remote_send (buf, rs->remote_packet_size);
3558
3559   return buf[0] != '\0';
3560 }
3561
3562
3563 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
3564    of the register cache buffer.  FIXME: ignores errors.  */
3565
3566 static void
3567 remote_store_registers (int regnum)
3568 {
3569   struct remote_state *rs = get_remote_state ();
3570   char *buf;
3571   char *regs;
3572   int i;
3573   char *p;
3574
3575   set_thread (PIDGET (inferior_ptid), 1);
3576
3577   if (regnum >= 0)
3578     {
3579       switch (remote_protocol_P.support)
3580         {
3581         case PACKET_DISABLE:
3582           break;
3583         case PACKET_ENABLE:
3584           if (store_register_using_P (regnum))
3585             return;
3586           else
3587             error ("Protocol error: P packet not recognized by stub");
3588         case PACKET_SUPPORT_UNKNOWN:
3589           if (store_register_using_P (regnum))
3590             {
3591               /* The stub recognized the 'P' packet.  Remember this.  */
3592               remote_protocol_P.support = PACKET_ENABLE;
3593               return;
3594             }
3595           else
3596             {
3597               /* The stub does not support the 'P' packet.  Use 'G'
3598                  instead, and don't try using 'P' in the future (it
3599                  will just waste our time).  */
3600               remote_protocol_P.support = PACKET_DISABLE;
3601               break;
3602             }
3603         }
3604     }
3605
3606   /* Extract all the registers in the regcache copying them into a
3607      local buffer.  */
3608   {
3609     int i;
3610     regs = alloca (rs->sizeof_g_packet);
3611     memset (regs, rs->sizeof_g_packet, 0);
3612     for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
3613       {
3614         struct packet_reg *r = &rs->regs[i];
3615         if (r->in_g_packet)
3616           regcache_collect (r->regnum, regs + r->offset);
3617       }
3618   }
3619
3620   /* Command describes registers byte by byte,
3621      each byte encoded as two hex characters.  */
3622   buf = alloca (rs->remote_packet_size);
3623   p = buf;
3624   *p++ = 'G';
3625   /* remote_prepare_to_store insures that register_bytes_found gets set.  */
3626   bin2hex (regs, p, register_bytes_found);
3627   remote_send (buf, (rs->remote_packet_size));
3628 }
3629 \f
3630
3631 /* Return the number of hex digits in num.  */
3632
3633 static int
3634 hexnumlen (ULONGEST num)
3635 {
3636   int i;
3637
3638   for (i = 0; num != 0; i++)
3639     num >>= 4;
3640
3641   return max (i, 1);
3642 }
3643
3644 /* Set BUF to the minimum number of hex digits representing NUM.  */
3645
3646 static int
3647 hexnumstr (char *buf, ULONGEST num)
3648 {
3649   int len = hexnumlen (num);
3650   return hexnumnstr (buf, num, len);
3651 }
3652
3653
3654 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters.  */
3655
3656 static int
3657 hexnumnstr (char *buf, ULONGEST num, int width)
3658 {
3659   int i;
3660
3661   buf[width] = '\0';
3662
3663   for (i = width - 1; i >= 0; i--)
3664     {
3665       buf[i] = "0123456789abcdef"[(num & 0xf)];
3666       num >>= 4;
3667     }
3668
3669   return width;
3670 }
3671
3672 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
3673
3674 static CORE_ADDR
3675 remote_address_masked (CORE_ADDR addr)
3676 {
3677   if (remote_address_size > 0
3678       && remote_address_size < (sizeof (ULONGEST) * 8))
3679     {
3680       /* Only create a mask when that mask can safely be constructed
3681          in a ULONGEST variable. */
3682       ULONGEST mask = 1;
3683       mask = (mask << remote_address_size) - 1;
3684       addr &= mask;
3685     }
3686   return addr;
3687 }
3688
3689 /* Determine whether the remote target supports binary downloading.
3690    This is accomplished by sending a no-op memory write of zero length
3691    to the target at the specified address. It does not suffice to send
3692    the whole packet, since many stubs strip the eighth bit and subsequently
3693    compute a wrong checksum, which causes real havoc with remote_write_bytes.
3694
3695    NOTE: This can still lose if the serial line is not eight-bit
3696    clean. In cases like this, the user should clear "remote
3697    X-packet". */
3698
3699 static void
3700 check_binary_download (CORE_ADDR addr)
3701 {
3702   struct remote_state *rs = get_remote_state ();
3703   switch (remote_protocol_binary_download.support)
3704     {
3705     case PACKET_DISABLE:
3706       break;
3707     case PACKET_ENABLE:
3708       break;
3709     case PACKET_SUPPORT_UNKNOWN:
3710       {
3711         char *buf = alloca (rs->remote_packet_size);
3712         char *p;
3713         
3714         p = buf;
3715         *p++ = 'X';
3716         p += hexnumstr (p, (ULONGEST) addr);
3717         *p++ = ',';
3718         p += hexnumstr (p, (ULONGEST) 0);
3719         *p++ = ':';
3720         *p = '\0';
3721         
3722         putpkt_binary (buf, (int) (p - buf));
3723         getpkt (buf, (rs->remote_packet_size), 0);
3724
3725         if (buf[0] == '\0')
3726           {
3727             if (remote_debug)
3728               fprintf_unfiltered (gdb_stdlog,
3729                                   "binary downloading NOT suppported by target\n");
3730             remote_protocol_binary_download.support = PACKET_DISABLE;
3731           }
3732         else
3733           {
3734             if (remote_debug)
3735               fprintf_unfiltered (gdb_stdlog,
3736                                   "binary downloading suppported by target\n");
3737             remote_protocol_binary_download.support = PACKET_ENABLE;
3738           }
3739         break;
3740       }
3741     }
3742 }
3743
3744 /* Write memory data directly to the remote machine.
3745    This does not inform the data cache; the data cache uses this.
3746    MEMADDR is the address in the remote memory space.
3747    MYADDR is the address of the buffer in our space.
3748    LEN is the number of bytes.
3749
3750    Returns number of bytes transferred, or 0 (setting errno) for
3751    error.  Only transfer a single packet. */
3752
3753 static int
3754 remote_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3755 {
3756   unsigned char *buf;
3757   int max_buf_size;             /* Max size of packet output buffer */
3758   unsigned char *p;
3759   unsigned char *plen;
3760   long sizeof_buf;
3761   int plenlen;
3762   int todo;
3763   int nr_bytes;
3764
3765   /* Verify that the target can support a binary download */
3766   check_binary_download (memaddr);
3767
3768   /* Determine the max packet size. */
3769   max_buf_size = get_memory_write_packet_size ();
3770   sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3771   buf = alloca (sizeof_buf);
3772
3773   /* Subtract header overhead from max payload size -  $M<memaddr>,<len>:#nn */
3774   max_buf_size -= 2 + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 4;
3775
3776   /* construct "M"<memaddr>","<len>":" */
3777   /* sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo); */
3778   p = buf;
3779
3780   /* Append [XM].  Compute a best guess of the number of bytes
3781      actually transfered. */
3782   switch (remote_protocol_binary_download.support)
3783     {
3784     case PACKET_ENABLE:
3785       *p++ = 'X';
3786       /* Best guess at number of bytes that will fit. */
3787       todo = min (len, max_buf_size);
3788       break;
3789     case PACKET_DISABLE:
3790       *p++ = 'M';
3791       /* num bytes that will fit */
3792       todo = min (len, max_buf_size / 2);
3793       break;
3794     case PACKET_SUPPORT_UNKNOWN:
3795       internal_error (__FILE__, __LINE__,
3796                       "remote_write_bytes: bad internal state");
3797     default:
3798       internal_error (__FILE__, __LINE__, "bad switch");
3799     }
3800   
3801   /* Append <memaddr> */
3802   memaddr = remote_address_masked (memaddr);
3803   p += hexnumstr (p, (ULONGEST) memaddr);
3804   *p++ = ',';
3805   
3806   /* Append <len>.  Retain the location/size of <len>.  It may
3807      need to be adjusted once the packet body has been created. */
3808   plen = p;
3809   plenlen = hexnumstr (p, (ULONGEST) todo);
3810   p += plenlen;
3811   *p++ = ':';
3812   *p = '\0';
3813   
3814   /* Append the packet body. */
3815   switch (remote_protocol_binary_download.support)
3816     {
3817     case PACKET_ENABLE:
3818       /* Binary mode.  Send target system values byte by byte, in
3819          increasing byte addresses.  Only escape certain critical
3820          characters.  */
3821       for (nr_bytes = 0;
3822            (nr_bytes < todo) && (p - buf) < (max_buf_size - 2);
3823            nr_bytes++)
3824         {
3825           switch (myaddr[nr_bytes] & 0xff)
3826             {
3827             case '$':
3828             case '#':
3829             case 0x7d:
3830               /* These must be escaped */
3831               *p++ = 0x7d;
3832               *p++ = (myaddr[nr_bytes] & 0xff) ^ 0x20;
3833               break;
3834             default:
3835               *p++ = myaddr[nr_bytes] & 0xff;
3836               break;
3837             }
3838         }
3839       if (nr_bytes < todo)
3840         {
3841           /* Escape chars have filled up the buffer prematurely, 
3842              and we have actually sent fewer bytes than planned.
3843              Fix-up the length field of the packet.  Use the same
3844              number of characters as before.  */
3845           
3846           plen += hexnumnstr (plen, (ULONGEST) nr_bytes, plenlen);
3847           *plen = ':';  /* overwrite \0 from hexnumnstr() */
3848         }
3849       break;
3850     case PACKET_DISABLE:
3851       /* Normal mode: Send target system values byte by byte, in
3852          increasing byte addresses.  Each byte is encoded as a two hex
3853          value.  */
3854       nr_bytes = bin2hex (myaddr, p, todo);
3855       p += 2 * nr_bytes;
3856       break;
3857     case PACKET_SUPPORT_UNKNOWN:
3858       internal_error (__FILE__, __LINE__,
3859                       "remote_write_bytes: bad internal state");
3860     default:
3861       internal_error (__FILE__, __LINE__, "bad switch");
3862     }
3863   
3864   putpkt_binary (buf, (int) (p - buf));
3865   getpkt (buf, sizeof_buf, 0);
3866   
3867   if (buf[0] == 'E')
3868     {
3869       /* There is no correspondance between what the remote protocol
3870          uses for errors and errno codes.  We would like a cleaner way
3871          of representing errors (big enough to include errno codes,
3872          bfd_error codes, and others).  But for now just return EIO.  */
3873       errno = EIO;
3874       return 0;
3875     }
3876   
3877   /* Return NR_BYTES, not TODO, in case escape chars caused us to send fewer
3878      bytes than we'd planned.  */
3879   return nr_bytes;
3880 }
3881
3882 /* Read memory data directly from the remote machine.
3883    This does not use the data cache; the data cache uses this.
3884    MEMADDR is the address in the remote memory space.
3885    MYADDR is the address of the buffer in our space.
3886    LEN is the number of bytes.
3887
3888    Returns number of bytes transferred, or 0 for error.  */
3889
3890 /* NOTE: cagney/1999-10-18: This function (and its siblings in other
3891    remote targets) shouldn't attempt to read the entire buffer.
3892    Instead it should read a single packet worth of data and then
3893    return the byte size of that packet to the caller.  The caller (its
3894    caller and its callers caller ;-) already contains code for
3895    handling partial reads. */
3896
3897 static int
3898 remote_read_bytes (CORE_ADDR memaddr, char *myaddr, int len)
3899 {
3900   char *buf;
3901   int max_buf_size;             /* Max size of packet output buffer */
3902   long sizeof_buf;
3903   int origlen;
3904
3905   /* Create a buffer big enough for this packet. */
3906   max_buf_size = get_memory_read_packet_size ();
3907   sizeof_buf = max_buf_size + 1; /* Space for trailing NUL */
3908   buf = alloca (sizeof_buf);
3909
3910   origlen = len;
3911   while (len > 0)
3912     {
3913       char *p;
3914       int todo;
3915       int i;
3916
3917       todo = min (len, max_buf_size / 2);       /* num bytes that will fit */
3918
3919       /* construct "m"<memaddr>","<len>" */
3920       /* sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo); */
3921       memaddr = remote_address_masked (memaddr);
3922       p = buf;
3923       *p++ = 'm';
3924       p += hexnumstr (p, (ULONGEST) memaddr);
3925       *p++ = ',';
3926       p += hexnumstr (p, (ULONGEST) todo);
3927       *p = '\0';
3928
3929       putpkt (buf);
3930       getpkt (buf, sizeof_buf, 0);
3931
3932       if (buf[0] == 'E'
3933           && isxdigit (buf[1]) && isxdigit (buf[2])
3934           && buf[3] == '\0')
3935         {
3936           /* There is no correspondance between what the remote protocol uses
3937              for errors and errno codes.  We would like a cleaner way of
3938              representing errors (big enough to include errno codes, bfd_error
3939              codes, and others).  But for now just return EIO.  */
3940           errno = EIO;
3941           return 0;
3942         }
3943
3944       /* Reply describes memory byte by byte,
3945          each byte encoded as two hex characters.  */
3946
3947       p = buf;
3948       if ((i = hex2bin (p, myaddr, todo)) < todo)
3949         {
3950           /* Reply is short.  This means that we were able to read
3951              only part of what we wanted to. */
3952           return i + (origlen - len);
3953         }
3954       myaddr += todo;
3955       memaddr += todo;
3956       len -= todo;
3957     }
3958   return origlen;
3959 }
3960 \f
3961 /* Read or write LEN bytes from inferior memory at MEMADDR,
3962    transferring to or from debugger address BUFFER.  Write to inferior if
3963    SHOULD_WRITE is nonzero.  Returns length of data written or read; 0
3964    for error.  TARGET is unused.  */
3965
3966 /* ARGSUSED */
3967 static int
3968 remote_xfer_memory (CORE_ADDR mem_addr, char *buffer, int mem_len,
3969                     int should_write, struct mem_attrib *attrib,
3970                     struct target_ops *target)
3971 {
3972   CORE_ADDR targ_addr;
3973   int targ_len;
3974   int res;
3975
3976   /* Should this be the selected frame?  */
3977   gdbarch_remote_translate_xfer_address (current_gdbarch, current_regcache,
3978                                          mem_addr, mem_len,
3979                                          &targ_addr, &targ_len);
3980   if (targ_len <= 0)
3981     return 0;
3982
3983   if (should_write)
3984     res = remote_write_bytes (targ_addr, buffer, targ_len);
3985   else
3986     res = remote_read_bytes (targ_addr, buffer, targ_len);
3987
3988   return res;
3989 }
3990
3991
3992 #if 0
3993 /* Enable after 4.12.  */
3994
3995 void
3996 remote_search (int len, char *data, char *mask, CORE_ADDR startaddr,
3997                int increment, CORE_ADDR lorange, CORE_ADDR hirange,
3998                CORE_ADDR *addr_found, char *data_found)
3999 {
4000   if (increment == -4 && len == 4)
4001     {
4002       long mask_long, data_long;
4003       long data_found_long;
4004       CORE_ADDR addr_we_found;
4005       char *buf = alloca (rs->remote_packet_size);
4006       long returned_long[2];
4007       char *p;
4008
4009       mask_long = extract_unsigned_integer (mask, len);
4010       data_long = extract_unsigned_integer (data, len);
4011       sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long);
4012       putpkt (buf);
4013       getpkt (buf, (rs->remote_packet_size), 0);
4014       if (buf[0] == '\0')
4015         {
4016           /* The stub doesn't support the 't' request.  We might want to
4017              remember this fact, but on the other hand the stub could be
4018              switched on us.  Maybe we should remember it only until
4019              the next "target remote".  */
4020           generic_search (len, data, mask, startaddr, increment, lorange,
4021                           hirange, addr_found, data_found);
4022           return;
4023         }
4024
4025       if (buf[0] == 'E')
4026         /* There is no correspondance between what the remote protocol uses
4027            for errors and errno codes.  We would like a cleaner way of
4028            representing errors (big enough to include errno codes, bfd_error
4029            codes, and others).  But for now just use EIO.  */
4030         memory_error (EIO, startaddr);
4031       p = buf;
4032       addr_we_found = 0;
4033       while (*p != '\0' && *p != ',')
4034         addr_we_found = (addr_we_found << 4) + fromhex (*p++);
4035       if (*p == '\0')
4036         error ("Protocol error: short return for search");
4037
4038       data_found_long = 0;
4039       while (*p != '\0' && *p != ',')
4040         data_found_long = (data_found_long << 4) + fromhex (*p++);
4041       /* Ignore anything after this comma, for future extensions.  */
4042
4043       if (addr_we_found < lorange || addr_we_found >= hirange)
4044         {
4045           *addr_found = 0;
4046           return;
4047         }
4048
4049       *addr_found = addr_we_found;
4050       *data_found = store_unsigned_integer (data_we_found, len);
4051       return;
4052     }
4053   generic_search (len, data, mask, startaddr, increment, lorange,
4054                   hirange, addr_found, data_found);
4055 }
4056 #endif /* 0 */
4057 \f
4058 static void
4059 remote_files_info (struct target_ops *ignore)
4060 {
4061   puts_filtered ("Debugging a target over a serial line.\n");
4062 }
4063 \f
4064 /* Stuff for dealing with the packets which are part of this protocol.
4065    See comment at top of file for details.  */
4066
4067 /* Read a single character from the remote end, masking it down to 7 bits. */
4068
4069 static int
4070 readchar (int timeout)
4071 {
4072   int ch;
4073
4074   ch = serial_readchar (remote_desc, timeout);
4075
4076   if (ch >= 0)
4077     return (ch & 0x7f);
4078
4079   switch ((enum serial_rc) ch)
4080     {
4081     case SERIAL_EOF:
4082       target_mourn_inferior ();
4083       error ("Remote connection closed");
4084       /* no return */
4085     case SERIAL_ERROR:
4086       perror_with_name ("Remote communication error");
4087       /* no return */
4088     case SERIAL_TIMEOUT:
4089       break;
4090     }
4091   return ch;
4092 }
4093
4094 /* Send the command in BUF to the remote machine, and read the reply
4095    into BUF.  Report an error if we get an error reply.  */
4096
4097 static void
4098 remote_send (char *buf,
4099              long sizeof_buf)
4100 {
4101   putpkt (buf);
4102   getpkt (buf, sizeof_buf, 0);
4103
4104   if (buf[0] == 'E')
4105     error ("Remote failure reply: %s", buf);
4106 }
4107
4108 /* Display a null-terminated packet on stdout, for debugging, using C
4109    string notation.  */
4110
4111 static void
4112 print_packet (char *buf)
4113 {
4114   puts_filtered ("\"");
4115   fputstr_filtered (buf, '"', gdb_stdout);
4116   puts_filtered ("\"");
4117 }
4118
4119 int
4120 putpkt (char *buf)
4121 {
4122   return putpkt_binary (buf, strlen (buf));
4123 }
4124
4125 /* Send a packet to the remote machine, with error checking.  The data
4126    of the packet is in BUF.  The string in BUF can be at most  (rs->remote_packet_size) - 5
4127    to account for the $, # and checksum, and for a possible /0 if we are
4128    debugging (remote_debug) and want to print the sent packet as a string */
4129
4130 static int
4131 putpkt_binary (char *buf, int cnt)
4132 {
4133   struct remote_state *rs = get_remote_state ();
4134   int i;
4135   unsigned char csum = 0;
4136   char *buf2 = alloca (cnt + 6);
4137   long sizeof_junkbuf = (rs->remote_packet_size);
4138   char *junkbuf = alloca (sizeof_junkbuf);
4139
4140   int ch;
4141   int tcount = 0;
4142   char *p;
4143
4144   /* Copy the packet into buffer BUF2, encapsulating it
4145      and giving it a checksum.  */
4146
4147   p = buf2;
4148   *p++ = '$';
4149
4150   for (i = 0; i < cnt; i++)
4151     {
4152       csum += buf[i];
4153       *p++ = buf[i];
4154     }
4155   *p++ = '#';
4156   *p++ = tohex ((csum >> 4) & 0xf);
4157   *p++ = tohex (csum & 0xf);
4158
4159   /* Send it over and over until we get a positive ack.  */
4160
4161   while (1)
4162     {
4163       int started_error_output = 0;
4164
4165       if (remote_debug)
4166         {
4167           *p = '\0';
4168           fprintf_unfiltered (gdb_stdlog, "Sending packet: ");
4169           fputstrn_unfiltered (buf2, p - buf2, 0, gdb_stdlog);
4170           fprintf_unfiltered (gdb_stdlog, "...");
4171           gdb_flush (gdb_stdlog);
4172         }
4173       if (serial_write (remote_desc, buf2, p - buf2))
4174         perror_with_name ("putpkt: write failed");
4175
4176       /* read until either a timeout occurs (-2) or '+' is read */
4177       while (1)
4178         {
4179           ch = readchar (remote_timeout);
4180
4181           if (remote_debug)
4182             {
4183               switch (ch)
4184                 {
4185                 case '+':
4186                 case '-':
4187                 case SERIAL_TIMEOUT:
4188                 case '$':
4189                   if (started_error_output)
4190                     {
4191                       putchar_unfiltered ('\n');
4192                       started_error_output = 0;
4193                     }
4194                 }
4195             }
4196
4197           switch (ch)
4198             {
4199             case '+':
4200               if (remote_debug)
4201                 fprintf_unfiltered (gdb_stdlog, "Ack\n");
4202               return 1;
4203             case '-':
4204               if (remote_debug)
4205                 fprintf_unfiltered (gdb_stdlog, "Nak\n");
4206             case SERIAL_TIMEOUT:
4207               tcount++;
4208               if (tcount > 3)
4209                 return 0;
4210               break;            /* Retransmit buffer */
4211             case '$':
4212               {
4213                 if (remote_debug)
4214                   fprintf_unfiltered (gdb_stdlog, "Packet instead of Ack, ignoring it\n");
4215                 /* It's probably an old response, and we're out of sync.
4216                    Just gobble up the packet and ignore it.  */
4217                 read_frame (junkbuf, sizeof_junkbuf);
4218                 continue;       /* Now, go look for + */
4219               }
4220             default:
4221               if (remote_debug)
4222                 {
4223                   if (!started_error_output)
4224                     {
4225                       started_error_output = 1;
4226                       fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
4227                     }
4228                   fputc_unfiltered (ch & 0177, gdb_stdlog);
4229                 }
4230               continue;
4231             }
4232           break;                /* Here to retransmit */
4233         }
4234
4235 #if 0
4236       /* This is wrong.  If doing a long backtrace, the user should be
4237          able to get out next time we call QUIT, without anything as
4238          violent as interrupt_query.  If we want to provide a way out of
4239          here without getting to the next QUIT, it should be based on
4240          hitting ^C twice as in remote_wait.  */
4241       if (quit_flag)
4242         {
4243           quit_flag = 0;
4244           interrupt_query ();
4245         }
4246 #endif
4247     }
4248 }
4249
4250 static int remote_cisco_mode;
4251
4252 /* Come here after finding the start of the frame.  Collect the rest
4253    into BUF, verifying the checksum, length, and handling run-length
4254    compression.  No more than sizeof_buf-1 characters are read so that
4255    the buffer can be NUL terminated.
4256
4257    Returns -1 on error, number of characters in buffer (ignoring the
4258    trailing NULL) on success. (could be extended to return one of the
4259    SERIAL status indications). */
4260
4261 static long
4262 read_frame (char *buf,
4263             long sizeof_buf)
4264 {
4265   unsigned char csum;
4266   long bc;
4267   int c;
4268
4269   csum = 0;
4270   bc = 0;
4271
4272   while (1)
4273     {
4274       /* ASSERT (bc < sizeof_buf - 1) - space for trailing NUL */
4275       c = readchar (remote_timeout);
4276       switch (c)
4277         {
4278         case SERIAL_TIMEOUT:
4279           if (remote_debug)
4280             fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
4281           return -1;
4282         case '$':
4283           if (remote_debug)
4284             fputs_filtered ("Saw new packet start in middle of old one\n",
4285                             gdb_stdlog);
4286           return -1;            /* Start a new packet, count retries */
4287         case '#':
4288           {
4289             unsigned char pktcsum;
4290             int check_0 = 0;
4291             int check_1 = 0;
4292
4293             buf[bc] = '\0';
4294
4295             check_0 = readchar (remote_timeout);
4296             if (check_0 >= 0)
4297               check_1 = readchar (remote_timeout);
4298             
4299             if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
4300               {
4301                 if (remote_debug)
4302                   fputs_filtered ("Timeout in checksum, retrying\n", gdb_stdlog);
4303                 return -1;
4304               }
4305             else if (check_0 < 0 || check_1 < 0)
4306               {
4307                 if (remote_debug)
4308                   fputs_filtered ("Communication error in checksum\n", gdb_stdlog);
4309                 return -1;
4310               }
4311
4312             pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
4313             if (csum == pktcsum)
4314               return bc;
4315
4316             if (remote_debug)
4317               {
4318                 fprintf_filtered (gdb_stdlog,
4319                               "Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
4320                                   pktcsum, csum);
4321                 fputs_filtered (buf, gdb_stdlog);
4322                 fputs_filtered ("\n", gdb_stdlog);
4323               }
4324             /* Number of characters in buffer ignoring trailing
4325                NUL. */
4326             return -1;
4327           }
4328         case '*':               /* Run length encoding */
4329           {
4330             int repeat;
4331             csum += c;
4332
4333             if (remote_cisco_mode == 0)
4334               {
4335                 c = readchar (remote_timeout);
4336                 csum += c;
4337                 repeat = c - ' ' + 3;   /* Compute repeat count */
4338               }
4339             else 
4340               { 
4341                 /* Cisco's run-length encoding variant uses two 
4342                    hex chars to represent the repeat count. */
4343
4344                 c = readchar (remote_timeout);
4345                 csum += c;
4346                 repeat  = fromhex (c) << 4;
4347                 c = readchar (remote_timeout);
4348                 csum += c;
4349                 repeat += fromhex (c);
4350               }
4351
4352             /* The character before ``*'' is repeated. */
4353
4354             if (repeat > 0 && repeat <= 255 
4355                 && bc > 0
4356                 && bc + repeat - 1 < sizeof_buf - 1)
4357               {
4358                 memset (&buf[bc], buf[bc - 1], repeat);
4359                 bc += repeat;
4360                 continue;
4361               }
4362
4363             buf[bc] = '\0';
4364             printf_filtered ("Repeat count %d too large for buffer: ", repeat);
4365             puts_filtered (buf);
4366             puts_filtered ("\n");
4367             return -1;
4368           }
4369         default:
4370           if (bc < sizeof_buf - 1)
4371             {
4372               buf[bc++] = c;
4373               csum += c;
4374               continue;
4375             }
4376
4377           buf[bc] = '\0';
4378           puts_filtered ("Remote packet too long: ");
4379           puts_filtered (buf);
4380           puts_filtered ("\n");
4381
4382           return -1;
4383         }
4384     }
4385 }
4386
4387 /* Read a packet from the remote machine, with error checking, and
4388    store it in BUF.  If FOREVER, wait forever rather than timing out;
4389    this is used (in synchronous mode) to wait for a target that is is
4390    executing user code to stop.  */
4391 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
4392    don't have to change all the calls to getpkt to deal with the
4393    return value, because at the moment I don't know what the right
4394    thing to do it for those. */
4395 void
4396 getpkt (char *buf,
4397         long sizeof_buf,
4398         int forever)
4399 {
4400   int timed_out;
4401
4402   timed_out = getpkt_sane (buf, sizeof_buf, forever);
4403 }
4404
4405
4406 /* Read a packet from the remote machine, with error checking, and
4407    store it in BUF.  If FOREVER, wait forever rather than timing out;
4408    this is used (in synchronous mode) to wait for a target that is is
4409    executing user code to stop. If FOREVER == 0, this function is
4410    allowed to time out gracefully and return an indication of this to
4411    the caller. */
4412 static int
4413 getpkt_sane (char *buf,
4414         long sizeof_buf,
4415         int forever)
4416 {
4417   int c;
4418   int tries;
4419   int timeout;
4420   int val;
4421
4422   strcpy (buf, "timeout");
4423
4424   if (forever)
4425     {
4426       timeout = watchdog > 0 ? watchdog : -1;
4427     }
4428
4429   else
4430     timeout = remote_timeout;
4431
4432 #define MAX_TRIES 3
4433
4434   for (tries = 1; tries <= MAX_TRIES; tries++)
4435     {
4436       /* This can loop forever if the remote side sends us characters
4437          continuously, but if it pauses, we'll get a zero from readchar
4438          because of timeout.  Then we'll count that as a retry.  */
4439
4440       /* Note that we will only wait forever prior to the start of a packet.
4441          After that, we expect characters to arrive at a brisk pace.  They
4442          should show up within remote_timeout intervals.  */
4443
4444       do
4445         {
4446           c = readchar (timeout);
4447
4448           if (c == SERIAL_TIMEOUT)
4449             {
4450               if (forever)      /* Watchdog went off?  Kill the target. */
4451                 {
4452                   QUIT;
4453                   target_mourn_inferior ();
4454                   error ("Watchdog has expired.  Target detached.\n");
4455                 }
4456               if (remote_debug)
4457                 fputs_filtered ("Timed out.\n", gdb_stdlog);
4458               goto retry;
4459             }
4460         }
4461       while (c != '$');
4462
4463       /* We've found the start of a packet, now collect the data.  */
4464
4465       val = read_frame (buf, sizeof_buf);
4466
4467       if (val >= 0)
4468         {
4469           if (remote_debug)
4470             {
4471               fprintf_unfiltered (gdb_stdlog, "Packet received: ");
4472               fputstr_unfiltered (buf, 0, gdb_stdlog);
4473               fprintf_unfiltered (gdb_stdlog, "\n");
4474             }
4475           serial_write (remote_desc, "+", 1);
4476           return 0;
4477         }
4478
4479       /* Try the whole thing again.  */
4480     retry:
4481       serial_write (remote_desc, "-", 1);
4482     }
4483
4484   /* We have tried hard enough, and just can't receive the packet.  Give up. */
4485
4486   printf_unfiltered ("Ignoring packet error, continuing...\n");
4487   serial_write (remote_desc, "+", 1);
4488   return 1;
4489 }
4490 \f
4491 static void
4492 remote_kill (void)
4493 {
4494   /* For some mysterious reason, wait_for_inferior calls kill instead of
4495      mourn after it gets TARGET_WAITKIND_SIGNALLED.  Work around it.  */
4496   if (kill_kludge)
4497     {
4498       kill_kludge = 0;
4499       target_mourn_inferior ();
4500       return;
4501     }
4502
4503   /* Use catch_errors so the user can quit from gdb even when we aren't on
4504      speaking terms with the remote system.  */
4505   catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4506
4507   /* Don't wait for it to die.  I'm not really sure it matters whether
4508      we do or not.  For the existing stubs, kill is a noop.  */
4509   target_mourn_inferior ();
4510 }
4511
4512 /* Async version of remote_kill. */
4513 static void
4514 remote_async_kill (void)
4515 {
4516   /* Unregister the file descriptor from the event loop. */
4517   if (target_is_async_p ())
4518     serial_async (remote_desc, NULL, 0);
4519
4520   /* For some mysterious reason, wait_for_inferior calls kill instead of
4521      mourn after it gets TARGET_WAITKIND_SIGNALLED.  Work around it.  */
4522   if (kill_kludge)
4523     {
4524       kill_kludge = 0;
4525       target_mourn_inferior ();
4526       return;
4527     }
4528
4529   /* Use catch_errors so the user can quit from gdb even when we aren't on
4530      speaking terms with the remote system.  */
4531   catch_errors ((catch_errors_ftype *) putpkt, "k", "", RETURN_MASK_ERROR);
4532
4533   /* Don't wait for it to die.  I'm not really sure it matters whether
4534      we do or not.  For the existing stubs, kill is a noop.  */
4535   target_mourn_inferior ();
4536 }
4537
4538 static void
4539 remote_mourn (void)
4540 {
4541   remote_mourn_1 (&remote_ops);
4542 }
4543
4544 static void
4545 remote_async_mourn (void)
4546 {
4547   remote_mourn_1 (&remote_async_ops);
4548 }
4549
4550 static void
4551 extended_remote_mourn (void)
4552 {
4553   /* We do _not_ want to mourn the target like this; this will
4554      remove the extended remote target  from the target stack,
4555      and the next time the user says "run" it'll fail. 
4556
4557      FIXME: What is the right thing to do here?  */
4558 #if 0
4559   remote_mourn_1 (&extended_remote_ops);
4560 #endif
4561 }
4562
4563 /* Worker function for remote_mourn.  */
4564 static void
4565 remote_mourn_1 (struct target_ops *target)
4566 {
4567   unpush_target (target);
4568   generic_mourn_inferior ();
4569 }
4570
4571 /* In the extended protocol we want to be able to do things like
4572    "run" and have them basically work as expected.  So we need
4573    a special create_inferior function. 
4574
4575    FIXME: One day add support for changing the exec file
4576    we're debugging, arguments and an environment.  */
4577
4578 static void
4579 extended_remote_create_inferior (char *exec_file, char *args, char **env)
4580 {
4581   /* Rip out the breakpoints; we'll reinsert them after restarting
4582      the remote server.  */
4583   remove_breakpoints ();
4584
4585   /* Now restart the remote server.  */
4586   extended_remote_restart ();
4587
4588   /* Now put the breakpoints back in.  This way we're safe if the
4589      restart function works via a unix fork on the remote side.  */
4590   insert_breakpoints ();
4591
4592   /* Clean up from the last time we were running.  */
4593   clear_proceed_status ();
4594
4595   /* Let the remote process run.  */
4596   proceed (-1, TARGET_SIGNAL_0, 0);
4597 }
4598
4599 /* Async version of extended_remote_create_inferior. */
4600 static void
4601 extended_remote_async_create_inferior (char *exec_file, char *args, char **env)
4602 {
4603   /* Rip out the breakpoints; we'll reinsert them after restarting
4604      the remote server.  */
4605   remove_breakpoints ();
4606
4607   /* If running asynchronously, register the target file descriptor
4608      with the event loop. */
4609   if (event_loop_p && target_can_async_p ())
4610     target_async (inferior_event_handler, 0);
4611
4612   /* Now restart the remote server.  */
4613   extended_remote_restart ();
4614
4615   /* Now put the breakpoints back in.  This way we're safe if the
4616      restart function works via a unix fork on the remote side.  */
4617   insert_breakpoints ();
4618
4619   /* Clean up from the last time we were running.  */
4620   clear_proceed_status ();
4621
4622   /* Let the remote process run.  */
4623   proceed (-1, TARGET_SIGNAL_0, 0);
4624 }
4625 \f
4626
4627 /* On some machines, e.g. 68k, we may use a different breakpoint
4628    instruction than other targets; in those use REMOTE_BREAKPOINT
4629    instead of just BREAKPOINT_FROM_PC.  Also, bi-endian targets may
4630    define LITTLE_REMOTE_BREAKPOINT and BIG_REMOTE_BREAKPOINT.  If none
4631    of these are defined, we just call the standard routines that are
4632    in mem-break.c.  */
4633
4634 /* FIXME, these ought to be done in a more dynamic fashion.  For instance,
4635    the choice of breakpoint instruction affects target program design and
4636    vice versa, and by making it user-tweakable, the special code here
4637    goes away and we need fewer special GDB configurations.  */
4638
4639 #if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT)
4640 #define REMOTE_BREAKPOINT
4641 #endif
4642
4643 #ifdef REMOTE_BREAKPOINT
4644
4645 /* If the target isn't bi-endian, just pretend it is.  */
4646 #if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT)
4647 #define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4648 #define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
4649 #endif
4650
4651 static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT;
4652 static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT;
4653
4654 #endif /* REMOTE_BREAKPOINT */
4655
4656 /* Insert a breakpoint on targets that don't have any better
4657    breakpoint support.  We read the contents of the target location
4658    and stash it, then overwrite it with a breakpoint instruction.
4659    ADDR is the target location in the target machine.  CONTENTS_CACHE
4660    is a pointer to memory allocated for saving the target contents.
4661    It is guaranteed by the caller to be long enough to save the number
4662    of bytes returned by BREAKPOINT_FROM_PC.  */
4663
4664 static int
4665 remote_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
4666 {
4667   struct remote_state *rs = get_remote_state ();
4668 #ifdef REMOTE_BREAKPOINT
4669   int val;
4670 #endif  
4671   int bp_size;
4672
4673   /* Try the "Z" s/w breakpoint packet if it is not already disabled.
4674      If it succeeds, then set the support to PACKET_ENABLE.  If it
4675      fails, and the user has explicitly requested the Z support then
4676      report an error, otherwise, mark it disabled and go on. */
4677   
4678   if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4679     {
4680       char *buf = alloca (rs->remote_packet_size);
4681       char *p = buf;
4682       
4683       addr = remote_address_masked (addr);
4684       *(p++) = 'Z';
4685       *(p++) = '0';
4686       *(p++) = ',';
4687       p += hexnumstr (p, (ULONGEST) addr);
4688       BREAKPOINT_FROM_PC (&addr, &bp_size);
4689       sprintf (p, ",%d", bp_size);
4690       
4691       putpkt (buf);
4692       getpkt (buf, (rs->remote_packet_size), 0);
4693
4694       switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_SOFTWARE_BP]))
4695         {
4696         case PACKET_ERROR:
4697           return -1;
4698         case PACKET_OK:
4699           return 0;
4700         case PACKET_UNKNOWN:
4701           break;
4702         }
4703     }
4704
4705 #ifdef REMOTE_BREAKPOINT  
4706   val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
4707
4708   if (val == 0)
4709     {
4710       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
4711         val = target_write_memory (addr, (char *) big_break_insn,
4712                                    sizeof big_break_insn);
4713       else
4714         val = target_write_memory (addr, (char *) little_break_insn,
4715                                    sizeof little_break_insn);
4716     }
4717
4718   return val;
4719 #else
4720   return memory_insert_breakpoint (addr, contents_cache);
4721 #endif /* REMOTE_BREAKPOINT */
4722 }
4723
4724 static int
4725 remote_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
4726 {
4727   struct remote_state *rs = get_remote_state ();
4728   int bp_size;
4729
4730   if (remote_protocol_Z[Z_PACKET_SOFTWARE_BP].support != PACKET_DISABLE)
4731     {
4732       char *buf = alloca (rs->remote_packet_size);
4733       char *p = buf;
4734       
4735       *(p++) = 'z';
4736       *(p++) = '0';
4737       *(p++) = ',';
4738
4739       addr = remote_address_masked (addr);
4740       p += hexnumstr (p, (ULONGEST) addr);
4741       BREAKPOINT_FROM_PC (&addr, &bp_size);
4742       sprintf (p, ",%d", bp_size);
4743       
4744       putpkt (buf);
4745       getpkt (buf, (rs->remote_packet_size), 0);
4746
4747       return (buf[0] == 'E');
4748     }
4749
4750 #ifdef REMOTE_BREAKPOINT
4751   return target_write_memory (addr, contents_cache, sizeof big_break_insn);
4752 #else
4753   return memory_remove_breakpoint (addr, contents_cache);
4754 #endif /* REMOTE_BREAKPOINT */
4755 }
4756
4757 static int
4758 watchpoint_to_Z_packet (int type)
4759 {
4760   switch (type)
4761     {
4762     case hw_write:
4763       return 2;
4764       break;
4765     case hw_read:
4766       return 3;
4767       break;
4768     case hw_access:
4769       return 4;
4770       break;
4771     default:
4772       internal_error (__FILE__, __LINE__,
4773                       "hw_bp_to_z: bad watchpoint type %d", type);
4774     }
4775 }
4776
4777 static int
4778 remote_insert_watchpoint (CORE_ADDR addr, int len, int type)
4779 {
4780   struct remote_state *rs = get_remote_state ();
4781   char *buf = alloca (rs->remote_packet_size);
4782   char *p;
4783   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4784
4785   if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4786     error ("Can't set hardware watchpoints without the '%s' (%s) packet\n",
4787            remote_protocol_Z[packet].name,
4788            remote_protocol_Z[packet].title);
4789   
4790   sprintf (buf, "Z%x,", packet);
4791   p = strchr (buf, '\0');
4792   addr = remote_address_masked (addr);
4793   p += hexnumstr (p, (ULONGEST) addr);
4794   sprintf (p, ",%x", len);
4795   
4796   putpkt (buf);
4797   getpkt (buf, (rs->remote_packet_size), 0);
4798
4799   switch (packet_ok (buf, &remote_protocol_Z[packet]))
4800     {
4801     case PACKET_ERROR:
4802     case PACKET_UNKNOWN:
4803       return -1;
4804     case PACKET_OK:
4805       return 0;
4806     }
4807   internal_error (__FILE__, __LINE__,
4808                   "remote_insert_watchpoint: reached end of function");
4809 }
4810
4811
4812 static int
4813 remote_remove_watchpoint (CORE_ADDR addr, int len, int type)
4814 {
4815   struct remote_state *rs = get_remote_state ();
4816   char *buf = alloca (rs->remote_packet_size);
4817   char *p;
4818   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
4819
4820   if (remote_protocol_Z[packet].support == PACKET_DISABLE)
4821     error ("Can't clear hardware watchpoints without the '%s' (%s) packet\n",
4822            remote_protocol_Z[packet].name,
4823            remote_protocol_Z[packet].title);
4824   
4825   sprintf (buf, "z%x,", packet);
4826   p = strchr (buf, '\0');
4827   addr = remote_address_masked (addr);
4828   p += hexnumstr (p, (ULONGEST) addr);
4829   sprintf (p, ",%x", len);
4830   putpkt (buf);
4831   getpkt (buf, (rs->remote_packet_size), 0);
4832
4833   switch (packet_ok (buf, &remote_protocol_Z[packet]))
4834     {
4835     case PACKET_ERROR:
4836     case PACKET_UNKNOWN:
4837       return -1;
4838     case PACKET_OK:
4839       return 0;
4840     }
4841   internal_error (__FILE__, __LINE__,
4842                   "remote_remove_watchpoint: reached end of function");
4843 }
4844
4845
4846 int remote_hw_watchpoint_limit = -1;
4847 int remote_hw_breakpoint_limit = -1;
4848
4849 int
4850 remote_check_watch_resources (int type, int cnt, int ot)
4851 {
4852   if (type == bp_hardware_breakpoint)
4853     {
4854       if (remote_hw_breakpoint_limit == 0)
4855         return 0;
4856       else if (remote_hw_breakpoint_limit < 0)
4857         return 1;
4858       else if (cnt <= remote_hw_breakpoint_limit)
4859         return 1;
4860     }
4861   else
4862     {
4863       if (remote_hw_watchpoint_limit == 0)
4864         return 0;
4865       else if (remote_hw_watchpoint_limit < 0)
4866         return 1;
4867       else if (ot)
4868         return -1;
4869       else if (cnt <= remote_hw_watchpoint_limit)
4870         return 1;
4871     }
4872   return -1;
4873 }
4874
4875 int
4876 remote_stopped_by_watchpoint (void)
4877 {
4878     return remote_stopped_by_watchpoint_p;
4879 }
4880
4881 CORE_ADDR
4882 remote_stopped_data_address (void)
4883 {
4884   if (remote_stopped_by_watchpoint ())
4885     return remote_watch_data_address;
4886   return (CORE_ADDR)0;
4887 }
4888
4889
4890 static int
4891 remote_insert_hw_breakpoint (CORE_ADDR addr, char *shadow)
4892 {
4893   int len = 0;
4894   struct remote_state *rs = get_remote_state ();
4895   char *buf = alloca (rs->remote_packet_size);
4896   char *p = buf;
4897       
4898   /* The length field should be set to the size of a breakpoint
4899      instruction.  */
4900
4901   BREAKPOINT_FROM_PC (&addr, &len);  
4902
4903   if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4904     error ("Can't set hardware breakpoint without the '%s' (%s) packet\n",
4905            remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4906            remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4907   
4908   *(p++) = 'Z';
4909   *(p++) = '1';
4910   *(p++) = ',';
4911   
4912   addr = remote_address_masked (addr);
4913   p += hexnumstr (p, (ULONGEST) addr);
4914   sprintf (p, ",%x", len);
4915
4916   putpkt (buf);
4917   getpkt (buf, (rs->remote_packet_size), 0);
4918
4919   switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4920     {
4921     case PACKET_ERROR:
4922     case PACKET_UNKNOWN:
4923       return -1;
4924     case PACKET_OK:
4925       return 0;
4926     }
4927   internal_error (__FILE__, __LINE__,
4928                   "remote_insert_hw_breakpoint: reached end of function");
4929 }
4930
4931
4932 static int 
4933 remote_remove_hw_breakpoint (CORE_ADDR addr, char *shadow)
4934 {
4935   int len;
4936   struct remote_state *rs = get_remote_state ();
4937   char *buf = alloca (rs->remote_packet_size);
4938   char *p = buf;
4939
4940   /* The length field should be set to the size of a breakpoint
4941      instruction.  */
4942
4943   BREAKPOINT_FROM_PC (&addr, &len);
4944
4945   if (remote_protocol_Z[Z_PACKET_HARDWARE_BP].support == PACKET_DISABLE)
4946     error ("Can't clear hardware breakpoint without the '%s' (%s) packet\n",
4947            remote_protocol_Z[Z_PACKET_HARDWARE_BP].name,
4948            remote_protocol_Z[Z_PACKET_HARDWARE_BP].title);
4949   
4950   *(p++) = 'z';
4951   *(p++) = '1';
4952   *(p++) = ',';
4953   
4954   addr = remote_address_masked (addr);
4955   p += hexnumstr (p, (ULONGEST) addr);
4956   sprintf (p, ",%x", len);
4957
4958   putpkt(buf);
4959   getpkt (buf, (rs->remote_packet_size), 0);
4960   
4961   switch (packet_ok (buf, &remote_protocol_Z[Z_PACKET_HARDWARE_BP]))
4962     {
4963     case PACKET_ERROR:
4964     case PACKET_UNKNOWN:
4965       return -1;
4966     case PACKET_OK:
4967       return 0;
4968     }
4969   internal_error (__FILE__, __LINE__,
4970                   "remote_remove_hw_breakpoint: reached end of function");
4971 }
4972
4973 /* Some targets are only capable of doing downloads, and afterwards
4974    they switch to the remote serial protocol.  This function provides
4975    a clean way to get from the download target to the remote target.
4976    It's basically just a wrapper so that we don't have to expose any
4977    of the internal workings of remote.c.
4978
4979    Prior to calling this routine, you should shutdown the current
4980    target code, else you will get the "A program is being debugged
4981    already..." message.  Usually a call to pop_target() suffices.  */
4982
4983 void
4984 push_remote_target (char *name, int from_tty)
4985 {
4986   printf_filtered ("Switching to remote protocol\n");
4987   remote_open (name, from_tty);
4988 }
4989
4990 /* Table used by the crc32 function to calcuate the checksum. */
4991
4992 static unsigned long crc32_table[256] =
4993 {0, 0};
4994
4995 static unsigned long
4996 crc32 (unsigned char *buf, int len, unsigned int crc)
4997 {
4998   if (!crc32_table[1])
4999     {
5000       /* Initialize the CRC table and the decoding table. */
5001       int i, j;
5002       unsigned int c;
5003
5004       for (i = 0; i < 256; i++)
5005         {
5006           for (c = i << 24, j = 8; j > 0; --j)
5007             c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
5008           crc32_table[i] = c;
5009         }
5010     }
5011
5012   while (len--)
5013     {
5014       crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255];
5015       buf++;
5016     }
5017   return crc;
5018 }
5019
5020 /* compare-sections command
5021
5022    With no arguments, compares each loadable section in the exec bfd
5023    with the same memory range on the target, and reports mismatches.
5024    Useful for verifying the image on the target against the exec file.
5025    Depends on the target understanding the new "qCRC:" request.  */
5026
5027 /* FIXME: cagney/1999-10-26: This command should be broken down into a
5028    target method (target verify memory) and generic version of the
5029    actual command.  This will allow other high-level code (especially
5030    generic_load()) to make use of this target functionality. */
5031
5032 static void
5033 compare_sections_command (char *args, int from_tty)
5034 {
5035   struct remote_state *rs = get_remote_state ();
5036   asection *s;
5037   unsigned long host_crc, target_crc;
5038   extern bfd *exec_bfd;
5039   struct cleanup *old_chain;
5040   char *tmp;
5041   char *sectdata;
5042   const char *sectname;
5043   char *buf = alloca (rs->remote_packet_size);
5044   bfd_size_type size;
5045   bfd_vma lma;
5046   int matched = 0;
5047   int mismatched = 0;
5048
5049   if (!exec_bfd)
5050     error ("command cannot be used without an exec file");
5051   if (!current_target.to_shortname ||
5052       strcmp (current_target.to_shortname, "remote") != 0)
5053     error ("command can only be used with remote target");
5054
5055   for (s = exec_bfd->sections; s; s = s->next)
5056     {
5057       if (!(s->flags & SEC_LOAD))
5058         continue;               /* skip non-loadable section */
5059
5060       size = bfd_get_section_size_before_reloc (s);
5061       if (size == 0)
5062         continue;               /* skip zero-length section */
5063
5064       sectname = bfd_get_section_name (exec_bfd, s);
5065       if (args && strcmp (args, sectname) != 0)
5066         continue;               /* not the section selected by user */
5067
5068       matched = 1;              /* do this section */
5069       lma = s->lma;
5070       /* FIXME: assumes lma can fit into long */
5071       sprintf (buf, "qCRC:%lx,%lx", (long) lma, (long) size);
5072       putpkt (buf);
5073
5074       /* be clever; compute the host_crc before waiting for target reply */
5075       sectdata = xmalloc (size);
5076       old_chain = make_cleanup (xfree, sectdata);
5077       bfd_get_section_contents (exec_bfd, s, sectdata, 0, size);
5078       host_crc = crc32 ((unsigned char *) sectdata, size, 0xffffffff);
5079
5080       getpkt (buf, (rs->remote_packet_size), 0);
5081       if (buf[0] == 'E')
5082         error ("target memory fault, section %s, range 0x%s -- 0x%s",
5083                sectname, paddr (lma), paddr (lma + size));
5084       if (buf[0] != 'C')
5085         error ("remote target does not support this operation");
5086
5087       for (target_crc = 0, tmp = &buf[1]; *tmp; tmp++)
5088         target_crc = target_crc * 16 + fromhex (*tmp);
5089
5090       printf_filtered ("Section %s, range 0x%s -- 0x%s: ",
5091                        sectname, paddr (lma), paddr (lma + size));
5092       if (host_crc == target_crc)
5093         printf_filtered ("matched.\n");
5094       else
5095         {
5096           printf_filtered ("MIS-MATCHED!\n");
5097           mismatched++;
5098         }
5099
5100       do_cleanups (old_chain);
5101     }
5102   if (mismatched > 0)
5103     warning ("One or more sections of the remote executable does not match\n\
5104 the loaded file\n");
5105   if (args && !matched)
5106     printf_filtered ("No loaded section named '%s'.\n", args);
5107 }
5108
5109 static int
5110 remote_query (int query_type, char *buf, char *outbuf, int *bufsiz)
5111 {
5112   struct remote_state *rs = get_remote_state ();
5113   int i;
5114   char *buf2 = alloca (rs->remote_packet_size);
5115   char *p2 = &buf2[0];
5116
5117   if (!bufsiz)
5118     error ("null pointer to remote bufer size specified");
5119
5120   /* minimum outbuf size is (rs->remote_packet_size) - if bufsiz is not large enough let 
5121      the caller know and return what the minimum size is   */
5122   /* Note: a zero bufsiz can be used to query the minimum buffer size */
5123   if (*bufsiz < (rs->remote_packet_size))
5124     {
5125       *bufsiz = (rs->remote_packet_size);
5126       return -1;
5127     }
5128
5129   /* except for querying the minimum buffer size, target must be open */
5130   if (!remote_desc)
5131     error ("remote query is only available after target open");
5132
5133   /* we only take uppercase letters as query types, at least for now */
5134   if ((query_type < 'A') || (query_type > 'Z'))
5135     error ("invalid remote query type");
5136
5137   if (!buf)
5138     error ("null remote query specified");
5139
5140   if (!outbuf)
5141     error ("remote query requires a buffer to receive data");
5142
5143   outbuf[0] = '\0';
5144
5145   *p2++ = 'q';
5146   *p2++ = query_type;
5147
5148   /* we used one buffer char for the remote protocol q command and another
5149      for the query type.  As the remote protocol encapsulation uses 4 chars
5150      plus one extra in case we are debugging (remote_debug),
5151      we have PBUFZIZ - 7 left to pack the query string */
5152   i = 0;
5153   while (buf[i] && (i < ((rs->remote_packet_size) - 8)))
5154     {
5155       /* bad caller may have sent forbidden characters */
5156       if ((!isprint (buf[i])) || (buf[i] == '$') || (buf[i] == '#'))
5157         error ("illegal characters in query string");
5158
5159       *p2++ = buf[i];
5160       i++;
5161     }
5162   *p2 = buf[i];
5163
5164   if (buf[i])
5165     error ("query larger than available buffer");
5166
5167   i = putpkt (buf2);
5168   if (i < 0)
5169     return i;
5170
5171   getpkt (outbuf, *bufsiz, 0);
5172
5173   return 0;
5174 }
5175
5176 static void
5177 remote_rcmd (char *command,
5178              struct ui_file *outbuf)
5179 {
5180   struct remote_state *rs = get_remote_state ();
5181   int i;
5182   char *buf = alloca (rs->remote_packet_size);
5183   char *p = buf;
5184
5185   if (!remote_desc)
5186     error ("remote rcmd is only available after target open");
5187
5188   /* Send a NULL command across as an empty command */
5189   if (command == NULL)
5190     command = "";
5191
5192   /* The query prefix */
5193   strcpy (buf, "qRcmd,");
5194   p = strchr (buf, '\0');
5195
5196   if ((strlen (buf) + strlen (command) * 2 + 8/*misc*/) > (rs->remote_packet_size))
5197     error ("\"monitor\" command ``%s'' is too long\n", command);
5198
5199   /* Encode the actual command */
5200   bin2hex (command, p, 0);
5201
5202   if (putpkt (buf) < 0)
5203     error ("Communication problem with target\n");
5204
5205   /* get/display the response */
5206   while (1)
5207     {
5208       /* XXX - see also tracepoint.c:remote_get_noisy_reply() */
5209       buf[0] = '\0';
5210       getpkt (buf, (rs->remote_packet_size), 0);
5211       if (buf[0] == '\0')
5212         error ("Target does not support this command\n");
5213       if (buf[0] == 'O' && buf[1] != 'K')
5214         {
5215           remote_console_output (buf + 1); /* 'O' message from stub */
5216           continue;
5217         }
5218       if (strcmp (buf, "OK") == 0)
5219         break;
5220       if (strlen (buf) == 3 && buf[0] == 'E'
5221           && isdigit (buf[1]) && isdigit (buf[2]))
5222         {
5223           error ("Protocol error with Rcmd");
5224         }
5225       for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
5226         {
5227           char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
5228           fputc_unfiltered (c, outbuf);
5229         }
5230       break;
5231     }
5232 }
5233
5234 static void
5235 packet_command (char *args, int from_tty)
5236 {
5237   struct remote_state *rs = get_remote_state ();
5238   char *buf = alloca (rs->remote_packet_size);
5239
5240   if (!remote_desc)
5241     error ("command can only be used with remote target");
5242
5243   if (!args)
5244     error ("remote-packet command requires packet text as argument");
5245
5246   puts_filtered ("sending: ");
5247   print_packet (args);
5248   puts_filtered ("\n");
5249   putpkt (args);
5250
5251   getpkt (buf, (rs->remote_packet_size), 0);
5252   puts_filtered ("received: ");
5253   print_packet (buf);
5254   puts_filtered ("\n");
5255 }
5256
5257 #if 0
5258 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------------- */
5259
5260 static void display_thread_info (struct gdb_ext_thread_info *info);
5261
5262 static void threadset_test_cmd (char *cmd, int tty);
5263
5264 static void threadalive_test (char *cmd, int tty);
5265
5266 static void threadlist_test_cmd (char *cmd, int tty);
5267
5268 int get_and_display_threadinfo (threadref * ref);
5269
5270 static void threadinfo_test_cmd (char *cmd, int tty);
5271
5272 static int thread_display_step (threadref * ref, void *context);
5273
5274 static void threadlist_update_test_cmd (char *cmd, int tty);
5275
5276 static void init_remote_threadtests (void);
5277
5278 #define SAMPLE_THREAD  0x05060708       /* Truncated 64 bit threadid */
5279
5280 static void
5281 threadset_test_cmd (char *cmd, int tty)
5282 {
5283   int sample_thread = SAMPLE_THREAD;
5284
5285   printf_filtered ("Remote threadset test\n");
5286   set_thread (sample_thread, 1);
5287 }
5288
5289
5290 static void
5291 threadalive_test (char *cmd, int tty)
5292 {
5293   int sample_thread = SAMPLE_THREAD;
5294
5295   if (remote_thread_alive (pid_to_ptid (sample_thread)))
5296     printf_filtered ("PASS: Thread alive test\n");
5297   else
5298     printf_filtered ("FAIL: Thread alive test\n");
5299 }
5300
5301 void output_threadid (char *title, threadref * ref);
5302
5303 void
5304 output_threadid (char *title, threadref *ref)
5305 {
5306   char hexid[20];
5307
5308   pack_threadid (&hexid[0], ref);       /* Convert threead id into hex */
5309   hexid[16] = 0;
5310   printf_filtered ("%s  %s\n", title, (&hexid[0]));
5311 }
5312
5313 static void
5314 threadlist_test_cmd (char *cmd, int tty)
5315 {
5316   int startflag = 1;
5317   threadref nextthread;
5318   int done, result_count;
5319   threadref threadlist[3];
5320
5321   printf_filtered ("Remote Threadlist test\n");
5322   if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
5323                               &result_count, &threadlist[0]))
5324     printf_filtered ("FAIL: threadlist test\n");
5325   else
5326     {
5327       threadref *scan = threadlist;
5328       threadref *limit = scan + result_count;
5329
5330       while (scan < limit)
5331         output_threadid (" thread ", scan++);
5332     }
5333 }
5334
5335 void
5336 display_thread_info (struct gdb_ext_thread_info *info)
5337 {
5338   output_threadid ("Threadid: ", &info->threadid);
5339   printf_filtered ("Name: %s\n ", info->shortname);
5340   printf_filtered ("State: %s\n", info->display);
5341   printf_filtered ("other: %s\n\n", info->more_display);
5342 }
5343
5344 int
5345 get_and_display_threadinfo (threadref *ref)
5346 {
5347   int result;
5348   int set;
5349   struct gdb_ext_thread_info threadinfo;
5350
5351   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
5352     | TAG_MOREDISPLAY | TAG_DISPLAY;
5353   if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
5354     display_thread_info (&threadinfo);
5355   return result;
5356 }
5357
5358 static void
5359 threadinfo_test_cmd (char *cmd, int tty)
5360 {
5361   int athread = SAMPLE_THREAD;
5362   threadref thread;
5363   int set;
5364
5365   int_to_threadref (&thread, athread);
5366   printf_filtered ("Remote Threadinfo test\n");
5367   if (!get_and_display_threadinfo (&thread))
5368     printf_filtered ("FAIL cannot get thread info\n");
5369 }
5370
5371 static int
5372 thread_display_step (threadref *ref, void *context)
5373 {
5374   /* output_threadid(" threadstep ",ref); *//* simple test */
5375   return get_and_display_threadinfo (ref);
5376 }
5377
5378 static void
5379 threadlist_update_test_cmd (char *cmd, int tty)
5380 {
5381   printf_filtered ("Remote Threadlist update test\n");
5382   remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
5383 }
5384
5385 static void
5386 init_remote_threadtests (void)
5387 {
5388   add_com ("tlist", class_obscure, threadlist_test_cmd,
5389      "Fetch and print the remote list of thread identifiers, one pkt only");
5390   add_com ("tinfo", class_obscure, threadinfo_test_cmd,
5391            "Fetch and display info about one thread");
5392   add_com ("tset", class_obscure, threadset_test_cmd,
5393            "Test setting to a different thread");
5394   add_com ("tupd", class_obscure, threadlist_update_test_cmd,
5395            "Iterate through updating all remote thread info");
5396   add_com ("talive", class_obscure, threadalive_test,
5397            " Remote thread alive test ");
5398 }
5399
5400 #endif /* 0 */
5401
5402 /* Convert a thread ID to a string.  Returns the string in a static
5403    buffer.  */
5404
5405 static char *
5406 remote_pid_to_str (ptid_t ptid)
5407 {
5408   static char buf[30];
5409
5410   sprintf (buf, "Thread %d", PIDGET (ptid));
5411   return buf;
5412 }
5413
5414 static void
5415 init_remote_ops (void)
5416 {
5417   remote_ops.to_shortname = "remote";
5418   remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
5419   remote_ops.to_doc =
5420     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5421 Specify the serial device it is connected to\n\
5422 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
5423   remote_ops.to_open = remote_open;
5424   remote_ops.to_close = remote_close;
5425   remote_ops.to_detach = remote_detach;
5426   remote_ops.to_resume = remote_resume;
5427   remote_ops.to_wait = remote_wait;
5428   remote_ops.to_fetch_registers = remote_fetch_registers;
5429   remote_ops.to_store_registers = remote_store_registers;
5430   remote_ops.to_prepare_to_store = remote_prepare_to_store;
5431   remote_ops.to_xfer_memory = remote_xfer_memory;
5432   remote_ops.to_files_info = remote_files_info;
5433   remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
5434   remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
5435   remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5436   remote_ops.to_stopped_data_address = remote_stopped_data_address;
5437   remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5438   remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5439   remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5440   remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
5441   remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
5442   remote_ops.to_kill = remote_kill;
5443   remote_ops.to_load = generic_load;
5444   remote_ops.to_mourn_inferior = remote_mourn;
5445   remote_ops.to_thread_alive = remote_thread_alive;
5446   remote_ops.to_find_new_threads = remote_threads_info;
5447   remote_ops.to_pid_to_str = remote_pid_to_str;
5448   remote_ops.to_extra_thread_info = remote_threads_extra_info;
5449   remote_ops.to_stop = remote_stop;
5450   remote_ops.to_query = remote_query;
5451   remote_ops.to_rcmd = remote_rcmd;
5452   remote_ops.to_stratum = process_stratum;
5453   remote_ops.to_has_all_memory = 1;
5454   remote_ops.to_has_memory = 1;
5455   remote_ops.to_has_stack = 1;
5456   remote_ops.to_has_registers = 1;
5457   remote_ops.to_has_execution = 1;
5458   remote_ops.to_has_thread_control = tc_schedlock;      /* can lock scheduler */
5459   remote_ops.to_magic = OPS_MAGIC;
5460 }
5461
5462 /* Set up the extended remote vector by making a copy of the standard
5463    remote vector and adding to it.  */
5464
5465 static void
5466 init_extended_remote_ops (void)
5467 {
5468   extended_remote_ops = remote_ops;
5469
5470   extended_remote_ops.to_shortname = "extended-remote";
5471   extended_remote_ops.to_longname =
5472     "Extended remote serial target in gdb-specific protocol";
5473   extended_remote_ops.to_doc =
5474     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5475 Specify the serial device it is connected to (e.g. /dev/ttya).",
5476     extended_remote_ops.to_open = extended_remote_open;
5477   extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
5478   extended_remote_ops.to_mourn_inferior = extended_remote_mourn;
5479 }
5480
5481 /*
5482  * Command: info remote-process
5483  *
5484  * This implements Cisco's version of the "info proc" command.
5485  *
5486  * This query allows the target stub to return an arbitrary string
5487  * (or strings) giving arbitrary information about the target process.
5488  * This is optional; the target stub isn't required to implement it.
5489  *
5490  * Syntax: qfProcessInfo        request first string
5491  *         qsProcessInfo        request subsequent string
5492  * reply:  'O'<hex-encoded-string>
5493  *         'l'                  last reply (empty)
5494  */
5495
5496 static void
5497 remote_info_process (char *args, int from_tty)
5498 {
5499   struct remote_state *rs = get_remote_state ();
5500   char *buf = alloca (rs->remote_packet_size);
5501
5502   if (remote_desc == 0)
5503     error ("Command can only be used when connected to the remote target.");
5504
5505   putpkt ("qfProcessInfo");
5506   getpkt (buf, (rs->remote_packet_size), 0);
5507   if (buf[0] == 0)
5508     return;                     /* Silently: target does not support this feature. */
5509
5510   if (buf[0] == 'E')
5511     error ("info proc: target error.");
5512
5513   while (buf[0] == 'O')         /* Capitol-O packet */
5514     {
5515       remote_console_output (&buf[1]);
5516       putpkt ("qsProcessInfo");
5517       getpkt (buf, (rs->remote_packet_size), 0);
5518     }
5519 }
5520
5521 /*
5522  * Target Cisco 
5523  */
5524
5525 static void
5526 remote_cisco_open (char *name, int from_tty)
5527 {
5528   int ex;
5529   if (name == 0)
5530     error ("To open a remote debug connection, you need to specify what \n"
5531            "device is attached to the remote system (e.g. host:port).");
5532
5533   /* See FIXME above */
5534   wait_forever_enabled_p = 1;
5535
5536   target_preopen (from_tty);
5537
5538   unpush_target (&remote_cisco_ops);
5539
5540   remote_desc = remote_serial_open (name);
5541   if (!remote_desc)
5542     perror_with_name (name);
5543
5544   /*
5545    * If a baud rate was specified on the gdb  command line it will
5546    * be greater than the initial value of -1.  If it is, use it otherwise
5547    * default to 9600
5548    */
5549
5550   baud_rate = (baud_rate > 0) ? baud_rate : 9600;
5551   if (serial_setbaudrate (remote_desc, baud_rate))
5552     {
5553       serial_close (remote_desc);
5554       perror_with_name (name);
5555     }
5556
5557   serial_raw (remote_desc);
5558
5559   /* If there is something sitting in the buffer we might take it as a
5560      response to a command, which would be bad.  */
5561   serial_flush_input (remote_desc);
5562
5563   if (from_tty)
5564     {
5565       puts_filtered ("Remote debugging using ");
5566       puts_filtered (name);
5567       puts_filtered ("\n");
5568     }
5569
5570   remote_cisco_mode = 1;
5571
5572   push_target (&remote_cisco_ops);      /* Switch to using cisco target now */
5573
5574   init_all_packet_configs ();
5575
5576   general_thread = -2;
5577   continue_thread = -2;
5578
5579   /* Probe for ability to use "ThreadInfo" query, as required.  */
5580   use_threadinfo_query = 1;
5581   use_threadextra_query = 1;
5582   
5583   /* Without this, some commands which require an active target (such
5584      as kill) won't work.  This variable serves (at least) double duty
5585      as both the pid of the target process (if it has such), and as a
5586      flag indicating that a target is active.  These functions should
5587      be split out into seperate variables, especially since GDB will
5588      someday have a notion of debugging several processes.  */
5589   inferior_ptid = pid_to_ptid (MAGIC_NULL_PID);
5590
5591   /* Start the remote connection; if error, discard this target.  See
5592      the comments in remote_open_1() for further details such as the
5593      need to re-throw the exception.  */
5594   ex = catch_exceptions (uiout,
5595                          remote_start_remote_dummy, NULL,
5596                          "Couldn't establish connection to remote"
5597                          " target\n",
5598                          RETURN_MASK_ALL);
5599   if (ex < 0)
5600     {
5601       pop_target ();
5602       throw_exception (ex);
5603     }
5604 }
5605
5606 static void
5607 remote_cisco_close (int quitting)
5608 {
5609   remote_cisco_mode = 0;
5610   remote_close (quitting);
5611 }
5612
5613 static void
5614 remote_cisco_mourn (void)
5615 {
5616   remote_mourn_1 (&remote_cisco_ops);
5617 }
5618
5619 enum
5620 {
5621   READ_MORE,
5622   FATAL_ERROR,
5623   ENTER_DEBUG,
5624   DISCONNECT_TELNET
5625 }
5626 minitelnet_return;
5627
5628 /* Shared between readsocket() and readtty().  The size is arbitrary,
5629    however all targets are known to support a 400 character packet.  */
5630 static char tty_input[400];
5631
5632 static int escape_count;
5633 static int echo_check;
5634 extern int quit_flag;
5635
5636 static int
5637 readsocket (void)
5638 {
5639   int data;
5640
5641   /* Loop until the socket doesn't have any more data */
5642
5643   while ((data = readchar (0)) >= 0)
5644     {
5645       /* Check for the escape sequence */
5646       if (data == '|')
5647         {
5648           /* If this is the fourth escape, get out */
5649           if (++escape_count == 4)
5650             {
5651               return ENTER_DEBUG;
5652             }
5653           else
5654             {                   /* This is a '|', but not the fourth in a row. 
5655                                    Continue without echoing it.  If it isn't actually 
5656                                    one of four in a row, it'll be echoed later.  */
5657               continue;
5658             }
5659         }
5660       else
5661         /* Not a '|' */
5662         {
5663           /* Ensure any pending '|'s are flushed.  */
5664
5665           for (; escape_count > 0; escape_count--)
5666             putchar ('|');
5667         }
5668
5669       if (data == '\r')         /* If this is a return character, */
5670         continue;               /*  - just supress it. */
5671
5672       if (echo_check != -1)     /* Check for echo of user input.  */
5673         {
5674           if (tty_input[echo_check] == data)
5675             {
5676               gdb_assert (echo_check <= sizeof (tty_input));
5677               echo_check++;     /* Character matched user input: */
5678               continue;         /* Continue without echoing it.  */
5679             }
5680           else if ((data == '\n') && (tty_input[echo_check] == '\r'))
5681             {                   /* End of the line (and of echo checking).  */
5682               echo_check = -1;  /* No more echo supression */
5683               continue;         /* Continue without echoing.  */
5684             }
5685           else
5686             {                   /* Failed check for echo of user input.
5687                                    We now have some suppressed output to flush!  */
5688               int j;
5689
5690               for (j = 0; j < echo_check; j++)
5691                 putchar (tty_input[j]);
5692               echo_check = -1;
5693             }
5694         }
5695       putchar (data);           /* Default case: output the char.  */
5696     }
5697
5698   if (data == SERIAL_TIMEOUT)   /* Timeout returned from readchar.  */
5699     return READ_MORE;           /* Try to read some more */
5700   else
5701     return FATAL_ERROR;         /* Trouble, bail out */
5702 }
5703
5704 static int
5705 readtty (void)
5706 {
5707   int tty_bytecount;
5708
5709   /* First, read a buffer full from the terminal */
5710   tty_bytecount = read (fileno (stdin), tty_input, sizeof (tty_input) - 1);
5711   if (tty_bytecount == -1)
5712     {
5713       perror ("readtty: read failed");
5714       return FATAL_ERROR;
5715     }
5716
5717   /* Remove a quoted newline.  */
5718   if (tty_input[tty_bytecount - 1] == '\n' &&
5719       tty_input[tty_bytecount - 2] == '\\')     /* line ending in backslash */
5720     {
5721       tty_input[--tty_bytecount] = 0;   /* remove newline */
5722       tty_input[--tty_bytecount] = 0;   /* remove backslash */
5723     }
5724
5725   /* Turn trailing newlines into returns */
5726   if (tty_input[tty_bytecount - 1] == '\n')
5727     tty_input[tty_bytecount - 1] = '\r';
5728
5729   /* If the line consists of a ~, enter debugging mode.  */
5730   if ((tty_input[0] == '~') && (tty_bytecount == 2))
5731     return ENTER_DEBUG;
5732
5733   /* Make this a zero terminated string and write it out */
5734   tty_input[tty_bytecount] = 0;
5735   if (serial_write (remote_desc, tty_input, tty_bytecount))
5736     {
5737       perror_with_name ("readtty: write failed");
5738       return FATAL_ERROR;
5739     }
5740
5741   return READ_MORE;
5742 }
5743
5744 static int
5745 minitelnet (void)
5746 {
5747   fd_set input;                 /* file descriptors for select */
5748   int tablesize;                /* max number of FDs for select */
5749   int status;
5750   int quit_count = 0;
5751
5752   escape_count = 0;
5753   echo_check = -1;
5754
5755   tablesize = 8 * sizeof (input);
5756
5757   for (;;)
5758     {
5759       /* Check for anything from our socket - doesn't block. Note that
5760          this must be done *before* the select as there may be
5761          buffered I/O waiting to be processed.  */
5762
5763       if ((status = readsocket ()) == FATAL_ERROR)
5764         {
5765           error ("Debugging terminated by communications error");
5766         }
5767       else if (status != READ_MORE)
5768         {
5769           return (status);
5770         }
5771
5772       fflush (stdout);          /* Flush output before blocking */
5773
5774       /* Now block on more socket input or TTY input */
5775
5776       FD_ZERO (&input);
5777       FD_SET (fileno (stdin), &input);
5778       FD_SET (deprecated_serial_fd (remote_desc), &input);
5779
5780       status = select (tablesize, &input, 0, 0, 0);
5781       if ((status == -1) && (errno != EINTR))
5782         {
5783           error ("Communications error on select %d", errno);
5784         }
5785
5786       /* Handle Control-C typed */
5787
5788       if (quit_flag)
5789         {
5790           if ((++quit_count) == 2)
5791             {
5792               if (query ("Interrupt GDB? "))
5793                 {
5794                   printf_filtered ("Interrupted by user.\n");
5795                   throw_exception (RETURN_QUIT);
5796                 }
5797               quit_count = 0;
5798             }
5799           quit_flag = 0;
5800
5801           if (remote_break)
5802             serial_send_break (remote_desc);
5803           else
5804             serial_write (remote_desc, "\003", 1);
5805
5806           continue;
5807         }
5808
5809       /* Handle console input */
5810
5811       if (FD_ISSET (fileno (stdin), &input))
5812         {
5813           quit_count = 0;
5814           echo_check = 0;
5815           status = readtty ();
5816           if (status == READ_MORE)
5817             continue;
5818
5819           return status;        /* telnet session ended */
5820         }
5821     }
5822 }
5823
5824 static ptid_t
5825 remote_cisco_wait (ptid_t ptid, struct target_waitstatus *status)
5826 {
5827   if (minitelnet () != ENTER_DEBUG)
5828     {
5829       error ("Debugging session terminated by protocol error");
5830     }
5831   putpkt ("?");
5832   return remote_wait (ptid, status);
5833 }
5834
5835 static void
5836 init_remote_cisco_ops (void)
5837 {
5838   remote_cisco_ops.to_shortname = "cisco";
5839   remote_cisco_ops.to_longname = "Remote serial target in cisco-specific protocol";
5840   remote_cisco_ops.to_doc =
5841     "Use a remote machine via TCP, using a cisco-specific protocol.\n\
5842 Specify the serial device it is connected to (e.g. host:2020).";
5843   remote_cisco_ops.to_open = remote_cisco_open;
5844   remote_cisco_ops.to_close = remote_cisco_close;
5845   remote_cisco_ops.to_detach = remote_detach;
5846   remote_cisco_ops.to_resume = remote_resume;
5847   remote_cisco_ops.to_wait = remote_cisco_wait;
5848   remote_cisco_ops.to_fetch_registers = remote_fetch_registers;
5849   remote_cisco_ops.to_store_registers = remote_store_registers;
5850   remote_cisco_ops.to_prepare_to_store = remote_prepare_to_store;
5851   remote_cisco_ops.to_xfer_memory = remote_xfer_memory;
5852   remote_cisco_ops.to_files_info = remote_files_info;
5853   remote_cisco_ops.to_insert_breakpoint = remote_insert_breakpoint;
5854   remote_cisco_ops.to_remove_breakpoint = remote_remove_breakpoint;  
5855   remote_cisco_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5856   remote_cisco_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5857   remote_cisco_ops.to_insert_watchpoint = remote_insert_watchpoint;
5858   remote_cisco_ops.to_remove_watchpoint = remote_remove_watchpoint;
5859   remote_cisco_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5860   remote_cisco_ops.to_stopped_data_address = remote_stopped_data_address;
5861   remote_cisco_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5862   remote_cisco_ops.to_kill = remote_kill;
5863   remote_cisco_ops.to_load = generic_load;
5864   remote_cisco_ops.to_mourn_inferior = remote_cisco_mourn;
5865   remote_cisco_ops.to_thread_alive = remote_thread_alive;
5866   remote_cisco_ops.to_find_new_threads = remote_threads_info;
5867   remote_cisco_ops.to_pid_to_str = remote_pid_to_str;
5868   remote_cisco_ops.to_extra_thread_info = remote_threads_extra_info;
5869   remote_cisco_ops.to_stratum = process_stratum;
5870   remote_cisco_ops.to_has_all_memory = 1;
5871   remote_cisco_ops.to_has_memory = 1;
5872   remote_cisco_ops.to_has_stack = 1;
5873   remote_cisco_ops.to_has_registers = 1;
5874   remote_cisco_ops.to_has_execution = 1;
5875   remote_cisco_ops.to_magic = OPS_MAGIC;
5876 }
5877
5878 static int
5879 remote_can_async_p (void)
5880 {
5881   /* We're async whenever the serial device is. */
5882   return (current_target.to_async_mask_value) && serial_can_async_p (remote_desc);
5883 }
5884
5885 static int
5886 remote_is_async_p (void)
5887 {
5888   /* We're async whenever the serial device is. */
5889   return (current_target.to_async_mask_value) && serial_is_async_p (remote_desc);
5890 }
5891
5892 /* Pass the SERIAL event on and up to the client.  One day this code
5893    will be able to delay notifying the client of an event until the
5894    point where an entire packet has been received. */
5895
5896 static void (*async_client_callback) (enum inferior_event_type event_type, void *context);
5897 static void *async_client_context;
5898 static serial_event_ftype remote_async_serial_handler;
5899
5900 static void
5901 remote_async_serial_handler (struct serial *scb, void *context)
5902 {
5903   /* Don't propogate error information up to the client.  Instead let
5904      the client find out about the error by querying the target.  */
5905   async_client_callback (INF_REG_EVENT, async_client_context);
5906 }
5907
5908 static void
5909 remote_async (void (*callback) (enum inferior_event_type event_type, void *context), void *context)
5910 {
5911   if (current_target.to_async_mask_value == 0)
5912     internal_error (__FILE__, __LINE__,
5913                     "Calling remote_async when async is masked");
5914
5915   if (callback != NULL)
5916     {
5917       serial_async (remote_desc, remote_async_serial_handler, NULL);
5918       async_client_callback = callback;
5919       async_client_context = context;
5920     }
5921   else
5922     serial_async (remote_desc, NULL, NULL);
5923 }
5924
5925 /* Target async and target extended-async.
5926
5927    This are temporary targets, until it is all tested.  Eventually
5928    async support will be incorporated int the usual 'remote'
5929    target. */
5930
5931 static void
5932 init_remote_async_ops (void)
5933 {
5934   remote_async_ops.to_shortname = "async";
5935   remote_async_ops.to_longname = "Remote serial target in async version of the gdb-specific protocol";
5936   remote_async_ops.to_doc =
5937     "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
5938 Specify the serial device it is connected to (e.g. /dev/ttya).";
5939   remote_async_ops.to_open = remote_async_open;
5940   remote_async_ops.to_close = remote_close;
5941   remote_async_ops.to_detach = remote_async_detach;
5942   remote_async_ops.to_resume = remote_async_resume;
5943   remote_async_ops.to_wait = remote_async_wait;
5944   remote_async_ops.to_fetch_registers = remote_fetch_registers;
5945   remote_async_ops.to_store_registers = remote_store_registers;
5946   remote_async_ops.to_prepare_to_store = remote_prepare_to_store;
5947   remote_async_ops.to_xfer_memory = remote_xfer_memory;
5948   remote_async_ops.to_files_info = remote_files_info;
5949   remote_async_ops.to_insert_breakpoint = remote_insert_breakpoint;
5950   remote_async_ops.to_remove_breakpoint = remote_remove_breakpoint;
5951   remote_async_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
5952   remote_async_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
5953   remote_async_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
5954   remote_async_ops.to_insert_watchpoint = remote_insert_watchpoint;
5955   remote_async_ops.to_remove_watchpoint = remote_remove_watchpoint;
5956   remote_async_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
5957   remote_async_ops.to_stopped_data_address = remote_stopped_data_address;
5958   remote_async_ops.to_terminal_inferior = remote_async_terminal_inferior;
5959   remote_async_ops.to_terminal_ours = remote_async_terminal_ours;
5960   remote_async_ops.to_kill = remote_async_kill;
5961   remote_async_ops.to_load = generic_load;
5962   remote_async_ops.to_mourn_inferior = remote_async_mourn;
5963   remote_async_ops.to_thread_alive = remote_thread_alive;
5964   remote_async_ops.to_find_new_threads = remote_threads_info;
5965   remote_async_ops.to_pid_to_str = remote_pid_to_str;
5966   remote_async_ops.to_extra_thread_info = remote_threads_extra_info;
5967   remote_async_ops.to_stop = remote_stop;
5968   remote_async_ops.to_query = remote_query;
5969   remote_async_ops.to_rcmd = remote_rcmd;
5970   remote_async_ops.to_stratum = process_stratum;
5971   remote_async_ops.to_has_all_memory = 1;
5972   remote_async_ops.to_has_memory = 1;
5973   remote_async_ops.to_has_stack = 1;
5974   remote_async_ops.to_has_registers = 1;
5975   remote_async_ops.to_has_execution = 1;
5976   remote_async_ops.to_has_thread_control = tc_schedlock;        /* can lock scheduler */
5977   remote_async_ops.to_can_async_p = remote_can_async_p;
5978   remote_async_ops.to_is_async_p = remote_is_async_p;
5979   remote_async_ops.to_async = remote_async;
5980   remote_async_ops.to_async_mask_value = 1;
5981   remote_async_ops.to_magic = OPS_MAGIC;
5982 }
5983
5984 /* Set up the async extended remote vector by making a copy of the standard
5985    remote vector and adding to it.  */
5986
5987 static void
5988 init_extended_async_remote_ops (void)
5989 {
5990   extended_async_remote_ops = remote_async_ops;
5991
5992   extended_async_remote_ops.to_shortname = "extended-async";
5993   extended_async_remote_ops.to_longname =
5994     "Extended remote serial target in async gdb-specific protocol";
5995   extended_async_remote_ops.to_doc =
5996     "Use a remote computer via a serial line, using an async gdb-specific protocol.\n\
5997 Specify the serial device it is connected to (e.g. /dev/ttya).",
5998     extended_async_remote_ops.to_open = extended_remote_async_open;
5999   extended_async_remote_ops.to_create_inferior = extended_remote_async_create_inferior;
6000   extended_async_remote_ops.to_mourn_inferior = extended_remote_mourn;
6001 }
6002
6003 static void
6004 set_remote_cmd (char *args, int from_tty)
6005 {
6006 }
6007
6008 static void
6009 show_remote_cmd (char *args, int from_tty)
6010 {
6011   /* FIXME: cagney/2002-06-15: This function should iterate over
6012      remote_show_cmdlist for a list of sub commands to show.  */
6013   show_remote_protocol_Z_packet_cmd (args, from_tty, NULL);
6014   show_remote_protocol_e_packet_cmd (args, from_tty, NULL);
6015   show_remote_protocol_E_packet_cmd (args, from_tty, NULL);
6016   show_remote_protocol_P_packet_cmd (args, from_tty, NULL);
6017   show_remote_protocol_qSymbol_packet_cmd (args, from_tty, NULL);
6018   show_remote_protocol_binary_download_cmd (args, from_tty, NULL);
6019 }
6020
6021 static void
6022 build_remote_gdbarch_data (void)
6023 {
6024   remote_address_size = TARGET_ADDR_BIT;
6025 }
6026
6027 /* Saved pointer to previous owner of the new_objfile event. */
6028 static void (*remote_new_objfile_chain) (struct objfile *);
6029
6030 /* Function to be called whenever a new objfile (shlib) is detected. */
6031 static void
6032 remote_new_objfile (struct objfile *objfile)
6033 {
6034   if (remote_desc != 0)         /* Have a remote connection */
6035     {
6036       remote_check_symbols (objfile);
6037     }
6038   /* Call predecessor on chain, if any. */
6039   if (remote_new_objfile_chain != 0 &&
6040       remote_desc == 0)
6041     remote_new_objfile_chain (objfile);
6042 }
6043
6044 void
6045 _initialize_remote (void)
6046 {
6047   static struct cmd_list_element *remote_set_cmdlist;
6048   static struct cmd_list_element *remote_show_cmdlist;
6049   struct cmd_list_element *tmpcmd;
6050
6051   /* architecture specific data */
6052   remote_gdbarch_data_handle = register_gdbarch_data (init_remote_state,
6053                                                       free_remote_state);
6054
6055   /* Old tacky stuff.  NOTE: This comes after the remote protocol so
6056      that the remote protocol has been initialized.  */
6057   register_gdbarch_swap (&remote_address_size, 
6058                          sizeof (&remote_address_size), NULL);
6059   register_gdbarch_swap (NULL, 0, build_remote_gdbarch_data);
6060
6061   init_remote_ops ();
6062   add_target (&remote_ops);
6063
6064   init_extended_remote_ops ();
6065   add_target (&extended_remote_ops);
6066
6067   init_remote_async_ops ();
6068   add_target (&remote_async_ops);
6069
6070   init_extended_async_remote_ops ();
6071   add_target (&extended_async_remote_ops);
6072
6073   init_remote_cisco_ops ();
6074   add_target (&remote_cisco_ops);
6075
6076   /* Hook into new objfile notification.  */
6077   remote_new_objfile_chain = target_new_objfile_hook;
6078   target_new_objfile_hook  = remote_new_objfile;
6079
6080 #if 0
6081   init_remote_threadtests ();
6082 #endif
6083
6084   /* set/show remote ... */
6085
6086   add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, "\
6087 Remote protocol specific variables\n\
6088 Configure various remote-protocol specific variables such as\n\
6089 the packets being used",
6090                   &remote_set_cmdlist, "set remote ",
6091                   0/*allow-unknown*/, &setlist);
6092   add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, "\
6093 Remote protocol specific variables\n\
6094 Configure various remote-protocol specific variables such as\n\
6095 the packets being used",
6096                   &remote_show_cmdlist, "show remote ",
6097                   0/*allow-unknown*/, &showlist);
6098
6099   add_cmd ("compare-sections", class_obscure, compare_sections_command,
6100            "Compare section data on target to the exec file.\n\
6101 Argument is a single section name (default: all loaded sections).",
6102            &cmdlist);
6103
6104   add_cmd ("packet", class_maintenance, packet_command,
6105            "Send an arbitrary packet to a remote target.\n\
6106    maintenance packet TEXT\n\
6107 If GDB is talking to an inferior via the GDB serial protocol, then\n\
6108 this command sends the string TEXT to the inferior, and displays the\n\
6109 response packet.  GDB supplies the initial `$' character, and the\n\
6110 terminating `#' character and checksum.",
6111            &maintenancelist);
6112
6113   add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break,
6114                            "Set whether to send break if interrupted.\n",
6115                            "Show whether to send break if interrupted.\n",
6116                            NULL, NULL,
6117                            &setlist, &showlist);
6118
6119   /* Install commands for configuring memory read/write packets. */
6120
6121   add_cmd ("remotewritesize", no_class, set_memory_write_packet_size,
6122            "Set the maximum number of bytes per memory write packet (deprecated).\n",
6123            &setlist);
6124   add_cmd ("remotewritesize", no_class, show_memory_write_packet_size,
6125            "Show the maximum number of bytes per memory write packet (deprecated).\n",
6126            &showlist);
6127   add_cmd ("memory-write-packet-size", no_class,
6128            set_memory_write_packet_size,
6129            "Set the maximum number of bytes per memory-write packet.\n"
6130            "Specify the number of bytes in a packet or 0 (zero) for the\n"
6131            "default packet size.  The actual limit is further reduced\n"
6132            "dependent on the target.  Specify ``fixed'' to disable the\n"
6133            "further restriction and ``limit'' to enable that restriction\n",
6134            &remote_set_cmdlist);
6135   add_cmd ("memory-read-packet-size", no_class,
6136            set_memory_read_packet_size,
6137            "Set the maximum number of bytes per memory-read packet.\n"
6138            "Specify the number of bytes in a packet or 0 (zero) for the\n"
6139            "default packet size.  The actual limit is further reduced\n"
6140            "dependent on the target.  Specify ``fixed'' to disable the\n"
6141            "further restriction and ``limit'' to enable that restriction\n",
6142            &remote_set_cmdlist);
6143   add_cmd ("memory-write-packet-size", no_class,
6144            show_memory_write_packet_size,
6145            "Show the maximum number of bytes per memory-write packet.\n",
6146            &remote_show_cmdlist);
6147   add_cmd ("memory-read-packet-size", no_class,
6148            show_memory_read_packet_size,
6149            "Show the maximum number of bytes per memory-read packet.\n",
6150            &remote_show_cmdlist);
6151
6152   add_setshow_cmd ("hardware-watchpoint-limit", no_class,
6153                    var_zinteger, &remote_hw_watchpoint_limit, "\
6154 Set the maximum number of target hardware watchpoints.\n\
6155 Specify a negative limit for unlimited.", "\
6156 Show the maximum number of target hardware watchpoints.\n",
6157                    NULL, NULL, &remote_set_cmdlist, &remote_show_cmdlist);
6158   add_setshow_cmd ("hardware-breakpoint-limit", no_class,
6159                    var_zinteger, &remote_hw_breakpoint_limit, "\
6160 Set the maximum number of target hardware breakpoints.\n\
6161 Specify a negative limit for unlimited.", "\
6162 Show the maximum number of target hardware breakpoints.\n",
6163                    NULL, NULL, &remote_set_cmdlist, &remote_show_cmdlist);
6164
6165   add_show_from_set
6166     (add_set_cmd ("remoteaddresssize", class_obscure,
6167                   var_integer, (char *) &remote_address_size,
6168                   "Set the maximum size of the address (in bits) \
6169 in a memory packet.\n",
6170                   &setlist),
6171      &showlist);
6172
6173   add_packet_config_cmd (&remote_protocol_binary_download,
6174                          "X", "binary-download",
6175                          set_remote_protocol_binary_download_cmd,
6176                          show_remote_protocol_binary_download_cmd,
6177                          &remote_set_cmdlist, &remote_show_cmdlist,
6178                          1);
6179 #if 0
6180   /* XXXX - should ``set remotebinarydownload'' be retained for
6181      compatibility. */
6182   add_show_from_set
6183     (add_set_cmd ("remotebinarydownload", no_class,
6184                   var_boolean, (char *) &remote_binary_download,
6185                   "Set binary downloads.\n", &setlist),
6186      &showlist);
6187 #endif
6188
6189   add_info ("remote-process", remote_info_process,
6190             "Query the remote system for process info.");
6191
6192   add_packet_config_cmd (&remote_protocol_qSymbol,
6193                          "qSymbol", "symbol-lookup",
6194                          set_remote_protocol_qSymbol_packet_cmd,
6195                          show_remote_protocol_qSymbol_packet_cmd,
6196                          &remote_set_cmdlist, &remote_show_cmdlist,
6197                          0);
6198
6199   add_packet_config_cmd (&remote_protocol_e,
6200                          "e", "step-over-range",
6201                          set_remote_protocol_e_packet_cmd,
6202                          show_remote_protocol_e_packet_cmd,
6203                          &remote_set_cmdlist, &remote_show_cmdlist,
6204                          0);
6205   /* Disable by default.  The ``e'' packet has nasty interactions with
6206      the threading code - it relies on global state.  */
6207   remote_protocol_e.detect = AUTO_BOOLEAN_FALSE;
6208   update_packet_config (&remote_protocol_e);
6209
6210   add_packet_config_cmd (&remote_protocol_E,
6211                          "E", "step-over-range-w-signal",
6212                          set_remote_protocol_E_packet_cmd,
6213                          show_remote_protocol_E_packet_cmd,
6214                          &remote_set_cmdlist, &remote_show_cmdlist,
6215                          0);
6216   /* Disable by default.  The ``e'' packet has nasty interactions with
6217      the threading code - it relies on global state.  */
6218   remote_protocol_E.detect = AUTO_BOOLEAN_FALSE;
6219   update_packet_config (&remote_protocol_E);
6220
6221   add_packet_config_cmd (&remote_protocol_P,
6222                          "P", "set-register",
6223                          set_remote_protocol_P_packet_cmd,
6224                          show_remote_protocol_P_packet_cmd,
6225                          &remote_set_cmdlist, &remote_show_cmdlist,
6226                          1);
6227
6228   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_SOFTWARE_BP],
6229                          "Z0", "software-breakpoint",
6230                          set_remote_protocol_Z_software_bp_packet_cmd,
6231                          show_remote_protocol_Z_software_bp_packet_cmd,
6232                          &remote_set_cmdlist, &remote_show_cmdlist,
6233                          0);
6234
6235   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_HARDWARE_BP],
6236                          "Z1", "hardware-breakpoint",
6237                          set_remote_protocol_Z_hardware_bp_packet_cmd,
6238                          show_remote_protocol_Z_hardware_bp_packet_cmd,
6239                          &remote_set_cmdlist, &remote_show_cmdlist,
6240                          0);
6241
6242   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_WRITE_WP],
6243                          "Z2", "write-watchpoint",
6244                          set_remote_protocol_Z_write_wp_packet_cmd,
6245                          show_remote_protocol_Z_write_wp_packet_cmd,
6246                          &remote_set_cmdlist, &remote_show_cmdlist,
6247                          0);
6248
6249   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_READ_WP],
6250                          "Z3", "read-watchpoint",
6251                          set_remote_protocol_Z_read_wp_packet_cmd,
6252                          show_remote_protocol_Z_read_wp_packet_cmd,
6253                          &remote_set_cmdlist, &remote_show_cmdlist,
6254                          0);
6255
6256   add_packet_config_cmd (&remote_protocol_Z[Z_PACKET_ACCESS_WP],
6257                          "Z4", "access-watchpoint",
6258                          set_remote_protocol_Z_access_wp_packet_cmd,
6259                          show_remote_protocol_Z_access_wp_packet_cmd,
6260                          &remote_set_cmdlist, &remote_show_cmdlist,
6261                          0);
6262
6263   /* Keep the old ``set remote Z-packet ...'' working. */
6264   add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
6265                                 &remote_Z_packet_detect, "\
6266 Set use of remote protocol `Z' packets",
6267                                 "Show use of remote protocol `Z' packets ",
6268                                 set_remote_protocol_Z_packet_cmd,
6269                                 show_remote_protocol_Z_packet_cmd,
6270                                 &remote_set_cmdlist, &remote_show_cmdlist);
6271 }