Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / remote.c
1 /* Remote target communications for serial-line targets in custom GDB protocol
2
3    Copyright (C) 1988-2013 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 /* See the GDB User Guide for details of the GDB remote protocol.  */
21
22 #include "defs.h"
23 #include "gdb_string.h"
24 #include <ctype.h>
25 #include <fcntl.h>
26 #include "inferior.h"
27 #include "bfd.h"
28 #include "symfile.h"
29 #include "exceptions.h"
30 #include "target.h"
31 /*#include "terminal.h" */
32 #include "gdbcmd.h"
33 #include "objfiles.h"
34 #include "gdb-stabs.h"
35 #include "gdbthread.h"
36 #include "remote.h"
37 #include "remote-notif.h"
38 #include "regcache.h"
39 #include "value.h"
40 #include "gdb_assert.h"
41 #include "observer.h"
42 #include "solib.h"
43 #include "cli/cli-decode.h"
44 #include "cli/cli-setshow.h"
45 #include "target-descriptions.h"
46 #include "gdb_bfd.h"
47
48 #include <ctype.h>
49 #include <sys/time.h>
50
51 #include "event-loop.h"
52 #include "event-top.h"
53 #include "inf-loop.h"
54
55 #include <signal.h>
56 #include "serial.h"
57
58 #include "gdbcore.h" /* for exec_bfd */
59
60 #include "remote-fileio.h"
61 #include "gdb/fileio.h"
62 #include "gdb_stat.h"
63 #include "xml-support.h"
64
65 #include "memory-map.h"
66
67 #include "tracepoint.h"
68 #include "ax.h"
69 #include "ax-gdb.h"
70 #include "agent.h"
71 #include "btrace.h"
72
73 /* Temp hacks for tracepoint encoding migration.  */
74 static char *target_buf;
75 static long target_buf_size;
76
77 /* The size to align memory write packets, when practical.  The protocol
78    does not guarantee any alignment, and gdb will generate short
79    writes and unaligned writes, but even as a best-effort attempt this
80    can improve bulk transfers.  For instance, if a write is misaligned
81    relative to the target's data bus, the stub may need to make an extra
82    round trip fetching data from the target.  This doesn't make a
83    huge difference, but it's easy to do, so we try to be helpful.
84
85    The alignment chosen is arbitrary; usually data bus width is
86    important here, not the possibly larger cache line size.  */
87 enum { REMOTE_ALIGN_WRITES = 16 };
88
89 /* Prototypes for local functions.  */
90 static void cleanup_sigint_signal_handler (void *dummy);
91 static void initialize_sigint_signal_handler (void);
92 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
93 static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
94                                  int forever, int *is_notif);
95
96 static void handle_remote_sigint (int);
97 static void handle_remote_sigint_twice (int);
98 static void async_remote_interrupt (gdb_client_data);
99 void async_remote_interrupt_twice (gdb_client_data);
100
101 static void remote_files_info (struct target_ops *ignore);
102
103 static void remote_prepare_to_store (struct regcache *regcache);
104
105 static void remote_open (char *name, int from_tty);
106
107 static void extended_remote_open (char *name, int from_tty);
108
109 static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
110
111 static void remote_close (int quitting);
112
113 static void remote_mourn (struct target_ops *ops);
114
115 static void extended_remote_restart (void);
116
117 static void extended_remote_mourn (struct target_ops *);
118
119 static void remote_mourn_1 (struct target_ops *);
120
121 static void remote_send (char **buf, long *sizeof_buf_p);
122
123 static int readchar (int timeout);
124
125 static void remote_serial_write (const char *str, int len);
126
127 static void remote_kill (struct target_ops *ops);
128
129 static int tohex (int nib);
130
131 static int remote_can_async_p (void);
132
133 static int remote_is_async_p (void);
134
135 static void remote_async (void (*callback) (enum inferior_event_type event_type,
136                                             void *context), void *context);
137
138 static void remote_detach (struct target_ops *ops, char *args, int from_tty);
139
140 static void remote_interrupt (int signo);
141
142 static void remote_interrupt_twice (int signo);
143
144 static void interrupt_query (void);
145
146 static void set_general_thread (struct ptid ptid);
147 static void set_continue_thread (struct ptid ptid);
148
149 static void get_offsets (void);
150
151 static void skip_frame (void);
152
153 static long read_frame (char **buf_p, long *sizeof_buf);
154
155 static int hexnumlen (ULONGEST num);
156
157 static void init_remote_ops (void);
158
159 static void init_extended_remote_ops (void);
160
161 static void remote_stop (ptid_t);
162
163 static int ishex (int ch, int *val);
164
165 static int stubhex (int ch);
166
167 static int hexnumstr (char *, ULONGEST);
168
169 static int hexnumnstr (char *, ULONGEST, int);
170
171 static CORE_ADDR remote_address_masked (CORE_ADDR);
172
173 static void print_packet (char *);
174
175 static void compare_sections_command (char *, int);
176
177 static void packet_command (char *, int);
178
179 static int stub_unpack_int (char *buff, int fieldlength);
180
181 static ptid_t remote_current_thread (ptid_t oldptid);
182
183 static void remote_find_new_threads (void);
184
185 static void record_currthread (ptid_t currthread);
186
187 static int fromhex (int a);
188
189 static int putpkt_binary (char *buf, int cnt);
190
191 static void check_binary_download (CORE_ADDR addr);
192
193 struct packet_config;
194
195 static void show_packet_config_cmd (struct packet_config *config);
196
197 static void update_packet_config (struct packet_config *config);
198
199 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
200                                             struct cmd_list_element *c);
201
202 static void show_remote_protocol_packet_cmd (struct ui_file *file,
203                                              int from_tty,
204                                              struct cmd_list_element *c,
205                                              const char *value);
206
207 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
208 static ptid_t read_ptid (char *buf, char **obuf);
209
210 static void remote_set_permissions (void);
211
212 struct remote_state;
213 static int remote_get_trace_status (struct trace_status *ts);
214
215 static int remote_upload_tracepoints (struct uploaded_tp **utpp);
216
217 static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
218   
219 static void remote_query_supported (void);
220
221 static void remote_check_symbols (struct objfile *objfile);
222
223 void _initialize_remote (void);
224
225 struct stop_reply;
226 static void stop_reply_xfree (struct stop_reply *);
227 static void remote_parse_stop_reply (char *, struct stop_reply *);
228 static void push_stop_reply (struct stop_reply *);
229 static void discard_pending_stop_replies (struct inferior *);
230 static int peek_stop_reply (ptid_t ptid);
231
232 static void remote_async_inferior_event_handler (gdb_client_data);
233
234 static void remote_terminal_ours (void);
235
236 static int remote_read_description_p (struct target_ops *target);
237
238 static void remote_console_output (char *msg);
239
240 static int remote_supports_cond_breakpoints (void);
241
242 static int remote_can_run_breakpoint_commands (void);
243
244 /* For "remote".  */
245
246 static struct cmd_list_element *remote_cmdlist;
247
248 /* For "set remote" and "show remote".  */
249
250 static struct cmd_list_element *remote_set_cmdlist;
251 static struct cmd_list_element *remote_show_cmdlist;
252
253 /* Description of the remote protocol state for the currently
254    connected target.  This is per-target state, and independent of the
255    selected architecture.  */
256
257 struct remote_state
258 {
259   /* A buffer to use for incoming packets, and its current size.  The
260      buffer is grown dynamically for larger incoming packets.
261      Outgoing packets may also be constructed in this buffer.
262      BUF_SIZE is always at least REMOTE_PACKET_SIZE;
263      REMOTE_PACKET_SIZE should be used to limit the length of outgoing
264      packets.  */
265   char *buf;
266   long buf_size;
267
268   /* True if we're going through initial connection setup (finding out
269      about the remote side's threads, relocating symbols, etc.).  */
270   int starting_up;
271
272   /* If we negotiated packet size explicitly (and thus can bypass
273      heuristics for the largest packet size that will not overflow
274      a buffer in the stub), this will be set to that packet size.
275      Otherwise zero, meaning to use the guessed size.  */
276   long explicit_packet_size;
277
278   /* remote_wait is normally called when the target is running and
279      waits for a stop reply packet.  But sometimes we need to call it
280      when the target is already stopped.  We can send a "?" packet
281      and have remote_wait read the response.  Or, if we already have
282      the response, we can stash it in BUF and tell remote_wait to
283      skip calling getpkt.  This flag is set when BUF contains a
284      stop reply packet and the target is not waiting.  */
285   int cached_wait_status;
286
287   /* True, if in no ack mode.  That is, neither GDB nor the stub will
288      expect acks from each other.  The connection is assumed to be
289      reliable.  */
290   int noack_mode;
291
292   /* True if we're connected in extended remote mode.  */
293   int extended;
294
295   /* True if the stub reported support for multi-process
296      extensions.  */
297   int multi_process_aware;
298
299   /* True if we resumed the target and we're waiting for the target to
300      stop.  In the mean time, we can't start another command/query.
301      The remote server wouldn't be ready to process it, so we'd
302      timeout waiting for a reply that would never come and eventually
303      we'd close the connection.  This can happen in asynchronous mode
304      because we allow GDB commands while the target is running.  */
305   int waiting_for_stop_reply;
306
307   /* True if the stub reports support for non-stop mode.  */
308   int non_stop_aware;
309
310   /* True if the stub reports support for vCont;t.  */
311   int support_vCont_t;
312
313   /* True if the stub reports support for conditional tracepoints.  */
314   int cond_tracepoints;
315
316   /* True if the stub reports support for target-side breakpoint
317      conditions.  */
318   int cond_breakpoints;
319
320   /* True if the stub reports support for target-side breakpoint
321      commands.  */
322   int breakpoint_commands;
323
324   /* True if the stub reports support for fast tracepoints.  */
325   int fast_tracepoints;
326
327   /* True if the stub reports support for static tracepoints.  */
328   int static_tracepoints;
329
330   /* True if the stub reports support for installing tracepoint while
331      tracing.  */
332   int install_in_trace;
333
334   /* True if the stub can continue running a trace while GDB is
335      disconnected.  */
336   int disconnected_tracing;
337
338   /* True if the stub reports support for enabling and disabling
339      tracepoints while a trace experiment is running.  */
340   int enable_disable_tracepoints;
341
342   /* True if the stub can collect strings using tracenz bytecode.  */
343   int string_tracing;
344
345   /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
346      responded to that.  */
347   int ctrlc_pending_p;
348 };
349
350 /* Private data that we'll store in (struct thread_info)->private.  */
351 struct private_thread_info
352 {
353   char *extra;
354   int core;
355 };
356
357 static void
358 free_private_thread_info (struct private_thread_info *info)
359 {
360   xfree (info->extra);
361   xfree (info);
362 }
363
364 /* Returns true if the multi-process extensions are in effect.  */
365 static int
366 remote_multi_process_p (struct remote_state *rs)
367 {
368   return rs->multi_process_aware;
369 }
370
371 /* This data could be associated with a target, but we do not always
372    have access to the current target when we need it, so for now it is
373    static.  This will be fine for as long as only one target is in use
374    at a time.  */
375 static struct remote_state remote_state;
376
377 static struct remote_state *
378 get_remote_state_raw (void)
379 {
380   return &remote_state;
381 }
382
383 /* Description of the remote protocol for a given architecture.  */
384
385 struct packet_reg
386 {
387   long offset; /* Offset into G packet.  */
388   long regnum; /* GDB's internal register number.  */
389   LONGEST pnum; /* Remote protocol register number.  */
390   int in_g_packet; /* Always part of G packet.  */
391   /* long size in bytes;  == register_size (target_gdbarch (), regnum);
392      at present.  */
393   /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
394      at present.  */
395 };
396
397 struct remote_arch_state
398 {
399   /* Description of the remote protocol registers.  */
400   long sizeof_g_packet;
401
402   /* Description of the remote protocol registers indexed by REGNUM
403      (making an array gdbarch_num_regs in size).  */
404   struct packet_reg *regs;
405
406   /* This is the size (in chars) of the first response to the ``g''
407      packet.  It is used as a heuristic when determining the maximum
408      size of memory-read and memory-write packets.  A target will
409      typically only reserve a buffer large enough to hold the ``g''
410      packet.  The size does not include packet overhead (headers and
411      trailers).  */
412   long actual_register_packet_size;
413
414   /* This is the maximum size (in chars) of a non read/write packet.
415      It is also used as a cap on the size of read/write packets.  */
416   long remote_packet_size;
417 };
418
419 long sizeof_pkt = 2000;
420
421 /* Utility: generate error from an incoming stub packet.  */
422 static void
423 trace_error (char *buf)
424 {
425   if (*buf++ != 'E')
426     return;                     /* not an error msg */
427   switch (*buf)
428     {
429     case '1':                   /* malformed packet error */
430       if (*++buf == '0')        /*   general case: */
431         error (_("remote.c: error in outgoing packet."));
432       else
433         error (_("remote.c: error in outgoing packet at field #%ld."),
434                strtol (buf, NULL, 16));
435     default:
436       error (_("Target returns error code '%s'."), buf);
437     }
438 }
439
440 /* Utility: wait for reply from stub, while accepting "O" packets.  */
441 static char *
442 remote_get_noisy_reply (char **buf_p,
443                         long *sizeof_buf)
444 {
445   do                            /* Loop on reply from remote stub.  */
446     {
447       char *buf;
448
449       QUIT;                     /* Allow user to bail out with ^C.  */
450       getpkt (buf_p, sizeof_buf, 0);
451       buf = *buf_p;
452       if (buf[0] == 'E')
453         trace_error (buf);
454       else if (strncmp (buf, "qRelocInsn:", strlen ("qRelocInsn:")) == 0)
455         {
456           ULONGEST ul;
457           CORE_ADDR from, to, org_to;
458           char *p, *pp;
459           int adjusted_size = 0;
460           volatile struct gdb_exception ex;
461
462           p = buf + strlen ("qRelocInsn:");
463           pp = unpack_varlen_hex (p, &ul);
464           if (*pp != ';')
465             error (_("invalid qRelocInsn packet: %s"), buf);
466           from = ul;
467
468           p = pp + 1;
469           unpack_varlen_hex (p, &ul);
470           to = ul;
471
472           org_to = to;
473
474           TRY_CATCH (ex, RETURN_MASK_ALL)
475             {
476               gdbarch_relocate_instruction (target_gdbarch (), &to, from);
477             }
478           if (ex.reason >= 0)
479             {
480               adjusted_size = to - org_to;
481
482               xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size);
483               putpkt (buf);
484             }
485           else if (ex.reason < 0 && ex.error == MEMORY_ERROR)
486             {
487               /* Propagate memory errors silently back to the target.
488                  The stub may have limited the range of addresses we
489                  can write to, for example.  */
490               putpkt ("E01");
491             }
492           else
493             {
494               /* Something unexpectedly bad happened.  Be verbose so
495                  we can tell what, and propagate the error back to the
496                  stub, so it doesn't get stuck waiting for a
497                  response.  */
498               exception_fprintf (gdb_stderr, ex,
499                                  _("warning: relocating instruction: "));
500               putpkt ("E01");
501             }
502         }
503       else if (buf[0] == 'O' && buf[1] != 'K')
504         remote_console_output (buf + 1);        /* 'O' message from stub */
505       else
506         return buf;             /* Here's the actual reply.  */
507     }
508   while (1);
509 }
510
511 /* Handle for retreving the remote protocol data from gdbarch.  */
512 static struct gdbarch_data *remote_gdbarch_data_handle;
513
514 static struct remote_arch_state *
515 get_remote_arch_state (void)
516 {
517   return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle);
518 }
519
520 /* Fetch the global remote target state.  */
521
522 static struct remote_state *
523 get_remote_state (void)
524 {
525   /* Make sure that the remote architecture state has been
526      initialized, because doing so might reallocate rs->buf.  Any
527      function which calls getpkt also needs to be mindful of changes
528      to rs->buf, but this call limits the number of places which run
529      into trouble.  */
530   get_remote_arch_state ();
531
532   return get_remote_state_raw ();
533 }
534
535 static int
536 compare_pnums (const void *lhs_, const void *rhs_)
537 {
538   const struct packet_reg * const *lhs = lhs_;
539   const struct packet_reg * const *rhs = rhs_;
540
541   if ((*lhs)->pnum < (*rhs)->pnum)
542     return -1;
543   else if ((*lhs)->pnum == (*rhs)->pnum)
544     return 0;
545   else
546     return 1;
547 }
548
549 static int
550 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
551 {
552   int regnum, num_remote_regs, offset;
553   struct packet_reg **remote_regs;
554
555   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
556     {
557       struct packet_reg *r = &regs[regnum];
558
559       if (register_size (gdbarch, regnum) == 0)
560         /* Do not try to fetch zero-sized (placeholder) registers.  */
561         r->pnum = -1;
562       else
563         r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
564
565       r->regnum = regnum;
566     }
567
568   /* Define the g/G packet format as the contents of each register
569      with a remote protocol number, in order of ascending protocol
570      number.  */
571
572   remote_regs = alloca (gdbarch_num_regs (gdbarch)
573                         * sizeof (struct packet_reg *));
574   for (num_remote_regs = 0, regnum = 0;
575        regnum < gdbarch_num_regs (gdbarch);
576        regnum++)
577     if (regs[regnum].pnum != -1)
578       remote_regs[num_remote_regs++] = &regs[regnum];
579
580   qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
581          compare_pnums);
582
583   for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
584     {
585       remote_regs[regnum]->in_g_packet = 1;
586       remote_regs[regnum]->offset = offset;
587       offset += register_size (gdbarch, remote_regs[regnum]->regnum);
588     }
589
590   return offset;
591 }
592
593 /* Given the architecture described by GDBARCH, return the remote
594    protocol register's number and the register's offset in the g/G
595    packets of GDB register REGNUM, in PNUM and POFFSET respectively.
596    If the target does not have a mapping for REGNUM, return false,
597    otherwise, return true.  */
598
599 int
600 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
601                                    int *pnum, int *poffset)
602 {
603   int sizeof_g_packet;
604   struct packet_reg *regs;
605   struct cleanup *old_chain;
606
607   gdb_assert (regnum < gdbarch_num_regs (gdbarch));
608
609   regs = xcalloc (gdbarch_num_regs (gdbarch), sizeof (struct packet_reg));
610   old_chain = make_cleanup (xfree, regs);
611
612   sizeof_g_packet = map_regcache_remote_table (gdbarch, regs);
613
614   *pnum = regs[regnum].pnum;
615   *poffset = regs[regnum].offset;
616
617   do_cleanups (old_chain);
618
619   return *pnum != -1;
620 }
621
622 static void *
623 init_remote_state (struct gdbarch *gdbarch)
624 {
625   struct remote_state *rs = get_remote_state_raw ();
626   struct remote_arch_state *rsa;
627
628   rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
629
630   /* Use the architecture to build a regnum<->pnum table, which will be
631      1:1 unless a feature set specifies otherwise.  */
632   rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
633                                       gdbarch_num_regs (gdbarch),
634                                       struct packet_reg);
635
636   /* Record the maximum possible size of the g packet - it may turn out
637      to be smaller.  */
638   rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
639
640   /* Default maximum number of characters in a packet body.  Many
641      remote stubs have a hardwired buffer size of 400 bytes
642      (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used
643      as the maximum packet-size to ensure that the packet and an extra
644      NUL character can always fit in the buffer.  This stops GDB
645      trashing stubs that try to squeeze an extra NUL into what is
646      already a full buffer (As of 1999-12-04 that was most stubs).  */
647   rsa->remote_packet_size = 400 - 1;
648
649   /* This one is filled in when a ``g'' packet is received.  */
650   rsa->actual_register_packet_size = 0;
651
652   /* Should rsa->sizeof_g_packet needs more space than the
653      default, adjust the size accordingly.  Remember that each byte is
654      encoded as two characters.  32 is the overhead for the packet
655      header / footer.  NOTE: cagney/1999-10-26: I suspect that 8
656      (``$NN:G...#NN'') is a better guess, the below has been padded a
657      little.  */
658   if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
659     rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
660
661   /* Make sure that the packet buffer is plenty big enough for
662      this architecture.  */
663   if (rs->buf_size < rsa->remote_packet_size)
664     {
665       rs->buf_size = 2 * rsa->remote_packet_size;
666       rs->buf = xrealloc (rs->buf, rs->buf_size);
667     }
668
669   return rsa;
670 }
671
672 /* Return the current allowed size of a remote packet.  This is
673    inferred from the current architecture, and should be used to
674    limit the length of outgoing packets.  */
675 static long
676 get_remote_packet_size (void)
677 {
678   struct remote_state *rs = get_remote_state ();
679   struct remote_arch_state *rsa = get_remote_arch_state ();
680
681   if (rs->explicit_packet_size)
682     return rs->explicit_packet_size;
683
684   return rsa->remote_packet_size;
685 }
686
687 static struct packet_reg *
688 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
689 {
690   if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ()))
691     return NULL;
692   else
693     {
694       struct packet_reg *r = &rsa->regs[regnum];
695
696       gdb_assert (r->regnum == regnum);
697       return r;
698     }
699 }
700
701 static struct packet_reg *
702 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
703 {
704   int i;
705
706   for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
707     {
708       struct packet_reg *r = &rsa->regs[i];
709
710       if (r->pnum == pnum)
711         return r;
712     }
713   return NULL;
714 }
715
716 /* FIXME: graces/2002-08-08: These variables should eventually be
717    bound to an instance of the target object (as in gdbarch-tdep()),
718    when such a thing exists.  */
719
720 /* This is set to the data address of the access causing the target
721    to stop for a watchpoint.  */
722 static CORE_ADDR remote_watch_data_address;
723
724 /* This is non-zero if target stopped for a watchpoint.  */
725 static int remote_stopped_by_watchpoint_p;
726
727 static struct target_ops remote_ops;
728
729 static struct target_ops extended_remote_ops;
730
731 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
732    ``forever'' still use the normal timeout mechanism.  This is
733    currently used by the ASYNC code to guarentee that target reads
734    during the initial connect always time-out.  Once getpkt has been
735    modified to return a timeout indication and, in turn
736    remote_wait()/wait_for_inferior() have gained a timeout parameter
737    this can go away.  */
738 static int wait_forever_enabled_p = 1;
739
740 /* Allow the user to specify what sequence to send to the remote
741    when he requests a program interruption: Although ^C is usually
742    what remote systems expect (this is the default, here), it is
743    sometimes preferable to send a break.  On other systems such
744    as the Linux kernel, a break followed by g, which is Magic SysRq g
745    is required in order to interrupt the execution.  */
746 const char interrupt_sequence_control_c[] = "Ctrl-C";
747 const char interrupt_sequence_break[] = "BREAK";
748 const char interrupt_sequence_break_g[] = "BREAK-g";
749 static const char *const interrupt_sequence_modes[] =
750   {
751     interrupt_sequence_control_c,
752     interrupt_sequence_break,
753     interrupt_sequence_break_g,
754     NULL
755   };
756 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
757
758 static void
759 show_interrupt_sequence (struct ui_file *file, int from_tty,
760                          struct cmd_list_element *c,
761                          const char *value)
762 {
763   if (interrupt_sequence_mode == interrupt_sequence_control_c)
764     fprintf_filtered (file,
765                       _("Send the ASCII ETX character (Ctrl-c) "
766                         "to the remote target to interrupt the "
767                         "execution of the program.\n"));
768   else if (interrupt_sequence_mode == interrupt_sequence_break)
769     fprintf_filtered (file,
770                       _("send a break signal to the remote target "
771                         "to interrupt the execution of the program.\n"));
772   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
773     fprintf_filtered (file,
774                       _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
775                         "the remote target to interrupt the execution "
776                         "of Linux kernel.\n"));
777   else
778     internal_error (__FILE__, __LINE__,
779                     _("Invalid value for interrupt_sequence_mode: %s."),
780                     interrupt_sequence_mode);
781 }
782
783 /* This boolean variable specifies whether interrupt_sequence is sent
784    to the remote target when gdb connects to it.
785    This is mostly needed when you debug the Linux kernel: The Linux kernel
786    expects BREAK g which is Magic SysRq g for connecting gdb.  */
787 static int interrupt_on_connect = 0;
788
789 /* This variable is used to implement the "set/show remotebreak" commands.
790    Since these commands are now deprecated in favor of "set/show remote
791    interrupt-sequence", it no longer has any effect on the code.  */
792 static int remote_break;
793
794 static void
795 set_remotebreak (char *args, int from_tty, struct cmd_list_element *c)
796 {
797   if (remote_break)
798     interrupt_sequence_mode = interrupt_sequence_break;
799   else
800     interrupt_sequence_mode = interrupt_sequence_control_c;
801 }
802
803 static void
804 show_remotebreak (struct ui_file *file, int from_tty,
805                   struct cmd_list_element *c,
806                   const char *value)
807 {
808 }
809
810 /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
811    remote_open knows that we don't have a file open when the program
812    starts.  */
813 static struct serial *remote_desc = NULL;
814
815 /* This variable sets the number of bits in an address that are to be
816    sent in a memory ("M" or "m") packet.  Normally, after stripping
817    leading zeros, the entire address would be sent.  This variable
818    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
819    initial implementation of remote.c restricted the address sent in
820    memory packets to ``host::sizeof long'' bytes - (typically 32
821    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
822    address was never sent.  Since fixing this bug may cause a break in
823    some remote targets this variable is principly provided to
824    facilitate backward compatibility.  */
825
826 static unsigned int remote_address_size;
827
828 /* Temporary to track who currently owns the terminal.  See
829    remote_terminal_* for more details.  */
830
831 static int remote_async_terminal_ours_p;
832
833 /* The executable file to use for "run" on the remote side.  */
834
835 static char *remote_exec_file = "";
836
837 \f
838 /* User configurable variables for the number of characters in a
839    memory read/write packet.  MIN (rsa->remote_packet_size,
840    rsa->sizeof_g_packet) is the default.  Some targets need smaller
841    values (fifo overruns, et.al.) and some users need larger values
842    (speed up transfers).  The variables ``preferred_*'' (the user
843    request), ``current_*'' (what was actually set) and ``forced_*''
844    (Positive - a soft limit, negative - a hard limit).  */
845
846 struct memory_packet_config
847 {
848   char *name;
849   long size;
850   int fixed_p;
851 };
852
853 /* Compute the current size of a read/write packet.  Since this makes
854    use of ``actual_register_packet_size'' the computation is dynamic.  */
855
856 static long
857 get_memory_packet_size (struct memory_packet_config *config)
858 {
859   struct remote_state *rs = get_remote_state ();
860   struct remote_arch_state *rsa = get_remote_arch_state ();
861
862   /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
863      law?) that some hosts don't cope very well with large alloca()
864      calls.  Eventually the alloca() code will be replaced by calls to
865      xmalloc() and make_cleanups() allowing this restriction to either
866      be lifted or removed.  */
867 #ifndef MAX_REMOTE_PACKET_SIZE
868 #define MAX_REMOTE_PACKET_SIZE 16384
869 #endif
870   /* NOTE: 20 ensures we can write at least one byte.  */
871 #ifndef MIN_REMOTE_PACKET_SIZE
872 #define MIN_REMOTE_PACKET_SIZE 20
873 #endif
874   long what_they_get;
875   if (config->fixed_p)
876     {
877       if (config->size <= 0)
878         what_they_get = MAX_REMOTE_PACKET_SIZE;
879       else
880         what_they_get = config->size;
881     }
882   else
883     {
884       what_they_get = get_remote_packet_size ();
885       /* Limit the packet to the size specified by the user.  */
886       if (config->size > 0
887           && what_they_get > config->size)
888         what_they_get = config->size;
889
890       /* Limit it to the size of the targets ``g'' response unless we have
891          permission from the stub to use a larger packet size.  */
892       if (rs->explicit_packet_size == 0
893           && rsa->actual_register_packet_size > 0
894           && what_they_get > rsa->actual_register_packet_size)
895         what_they_get = rsa->actual_register_packet_size;
896     }
897   if (what_they_get > MAX_REMOTE_PACKET_SIZE)
898     what_they_get = MAX_REMOTE_PACKET_SIZE;
899   if (what_they_get < MIN_REMOTE_PACKET_SIZE)
900     what_they_get = MIN_REMOTE_PACKET_SIZE;
901
902   /* Make sure there is room in the global buffer for this packet
903      (including its trailing NUL byte).  */
904   if (rs->buf_size < what_they_get + 1)
905     {
906       rs->buf_size = 2 * what_they_get;
907       rs->buf = xrealloc (rs->buf, 2 * what_they_get);
908     }
909
910   return what_they_get;
911 }
912
913 /* Update the size of a read/write packet.  If they user wants
914    something really big then do a sanity check.  */
915
916 static void
917 set_memory_packet_size (char *args, struct memory_packet_config *config)
918 {
919   int fixed_p = config->fixed_p;
920   long size = config->size;
921
922   if (args == NULL)
923     error (_("Argument required (integer, `fixed' or `limited')."));
924   else if (strcmp (args, "hard") == 0
925       || strcmp (args, "fixed") == 0)
926     fixed_p = 1;
927   else if (strcmp (args, "soft") == 0
928            || strcmp (args, "limit") == 0)
929     fixed_p = 0;
930   else
931     {
932       char *end;
933
934       size = strtoul (args, &end, 0);
935       if (args == end)
936         error (_("Invalid %s (bad syntax)."), config->name);
937 #if 0
938       /* Instead of explicitly capping the size of a packet to
939          MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
940          instead allowed to set the size to something arbitrarily
941          large.  */
942       if (size > MAX_REMOTE_PACKET_SIZE)
943         error (_("Invalid %s (too large)."), config->name);
944 #endif
945     }
946   /* Extra checks?  */
947   if (fixed_p && !config->fixed_p)
948     {
949       if (! query (_("The target may not be able to correctly handle a %s\n"
950                    "of %ld bytes. Change the packet size? "),
951                    config->name, size))
952         error (_("Packet size not changed."));
953     }
954   /* Update the config.  */
955   config->fixed_p = fixed_p;
956   config->size = size;
957 }
958
959 static void
960 show_memory_packet_size (struct memory_packet_config *config)
961 {
962   printf_filtered (_("The %s is %ld. "), config->name, config->size);
963   if (config->fixed_p)
964     printf_filtered (_("Packets are fixed at %ld bytes.\n"),
965                      get_memory_packet_size (config));
966   else
967     printf_filtered (_("Packets are limited to %ld bytes.\n"),
968                      get_memory_packet_size (config));
969 }
970
971 static struct memory_packet_config memory_write_packet_config =
972 {
973   "memory-write-packet-size",
974 };
975
976 static void
977 set_memory_write_packet_size (char *args, int from_tty)
978 {
979   set_memory_packet_size (args, &memory_write_packet_config);
980 }
981
982 static void
983 show_memory_write_packet_size (char *args, int from_tty)
984 {
985   show_memory_packet_size (&memory_write_packet_config);
986 }
987
988 static long
989 get_memory_write_packet_size (void)
990 {
991   return get_memory_packet_size (&memory_write_packet_config);
992 }
993
994 static struct memory_packet_config memory_read_packet_config =
995 {
996   "memory-read-packet-size",
997 };
998
999 static void
1000 set_memory_read_packet_size (char *args, int from_tty)
1001 {
1002   set_memory_packet_size (args, &memory_read_packet_config);
1003 }
1004
1005 static void
1006 show_memory_read_packet_size (char *args, int from_tty)
1007 {
1008   show_memory_packet_size (&memory_read_packet_config);
1009 }
1010
1011 static long
1012 get_memory_read_packet_size (void)
1013 {
1014   long size = get_memory_packet_size (&memory_read_packet_config);
1015
1016   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1017      extra buffer size argument before the memory read size can be
1018      increased beyond this.  */
1019   if (size > get_remote_packet_size ())
1020     size = get_remote_packet_size ();
1021   return size;
1022 }
1023
1024 \f
1025 /* Generic configuration support for packets the stub optionally
1026    supports.  Allows the user to specify the use of the packet as well
1027    as allowing GDB to auto-detect support in the remote stub.  */
1028
1029 enum packet_support
1030   {
1031     PACKET_SUPPORT_UNKNOWN = 0,
1032     PACKET_ENABLE,
1033     PACKET_DISABLE
1034   };
1035
1036 struct packet_config
1037   {
1038     const char *name;
1039     const char *title;
1040     enum auto_boolean detect;
1041     enum packet_support support;
1042   };
1043
1044 /* Analyze a packet's return value and update the packet config
1045    accordingly.  */
1046
1047 enum packet_result
1048 {
1049   PACKET_ERROR,
1050   PACKET_OK,
1051   PACKET_UNKNOWN
1052 };
1053
1054 static void
1055 update_packet_config (struct packet_config *config)
1056 {
1057   switch (config->detect)
1058     {
1059     case AUTO_BOOLEAN_TRUE:
1060       config->support = PACKET_ENABLE;
1061       break;
1062     case AUTO_BOOLEAN_FALSE:
1063       config->support = PACKET_DISABLE;
1064       break;
1065     case AUTO_BOOLEAN_AUTO:
1066       config->support = PACKET_SUPPORT_UNKNOWN;
1067       break;
1068     }
1069 }
1070
1071 static void
1072 show_packet_config_cmd (struct packet_config *config)
1073 {
1074   char *support = "internal-error";
1075
1076   switch (config->support)
1077     {
1078     case PACKET_ENABLE:
1079       support = "enabled";
1080       break;
1081     case PACKET_DISABLE:
1082       support = "disabled";
1083       break;
1084     case PACKET_SUPPORT_UNKNOWN:
1085       support = "unknown";
1086       break;
1087     }
1088   switch (config->detect)
1089     {
1090     case AUTO_BOOLEAN_AUTO:
1091       printf_filtered (_("Support for the `%s' packet "
1092                          "is auto-detected, currently %s.\n"),
1093                        config->name, support);
1094       break;
1095     case AUTO_BOOLEAN_TRUE:
1096     case AUTO_BOOLEAN_FALSE:
1097       printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1098                        config->name, support);
1099       break;
1100     }
1101 }
1102
1103 static void
1104 add_packet_config_cmd (struct packet_config *config, const char *name,
1105                        const char *title, int legacy)
1106 {
1107   char *set_doc;
1108   char *show_doc;
1109   char *cmd_name;
1110
1111   config->name = name;
1112   config->title = title;
1113   config->detect = AUTO_BOOLEAN_AUTO;
1114   config->support = PACKET_SUPPORT_UNKNOWN;
1115   set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1116                         name, title);
1117   show_doc = xstrprintf ("Show current use of remote "
1118                          "protocol `%s' (%s) packet",
1119                          name, title);
1120   /* set/show TITLE-packet {auto,on,off} */
1121   cmd_name = xstrprintf ("%s-packet", title);
1122   add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1123                                 &config->detect, set_doc,
1124                                 show_doc, NULL, /* help_doc */
1125                                 set_remote_protocol_packet_cmd,
1126                                 show_remote_protocol_packet_cmd,
1127                                 &remote_set_cmdlist, &remote_show_cmdlist);
1128   /* The command code copies the documentation strings.  */
1129   xfree (set_doc);
1130   xfree (show_doc);
1131   /* set/show remote NAME-packet {auto,on,off} -- legacy.  */
1132   if (legacy)
1133     {
1134       char *legacy_name;
1135
1136       legacy_name = xstrprintf ("%s-packet", name);
1137       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1138                      &remote_set_cmdlist);
1139       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1140                      &remote_show_cmdlist);
1141     }
1142 }
1143
1144 static enum packet_result
1145 packet_check_result (const char *buf)
1146 {
1147   if (buf[0] != '\0')
1148     {
1149       /* The stub recognized the packet request.  Check that the
1150          operation succeeded.  */
1151       if (buf[0] == 'E'
1152           && isxdigit (buf[1]) && isxdigit (buf[2])
1153           && buf[3] == '\0')
1154         /* "Enn"  - definitly an error.  */
1155         return PACKET_ERROR;
1156
1157       /* Always treat "E." as an error.  This will be used for
1158          more verbose error messages, such as E.memtypes.  */
1159       if (buf[0] == 'E' && buf[1] == '.')
1160         return PACKET_ERROR;
1161
1162       /* The packet may or may not be OK.  Just assume it is.  */
1163       return PACKET_OK;
1164     }
1165   else
1166     /* The stub does not support the packet.  */
1167     return PACKET_UNKNOWN;
1168 }
1169
1170 static enum packet_result
1171 packet_ok (const char *buf, struct packet_config *config)
1172 {
1173   enum packet_result result;
1174
1175   result = packet_check_result (buf);
1176   switch (result)
1177     {
1178     case PACKET_OK:
1179     case PACKET_ERROR:
1180       /* The stub recognized the packet request.  */
1181       switch (config->support)
1182         {
1183         case PACKET_SUPPORT_UNKNOWN:
1184           if (remote_debug)
1185             fprintf_unfiltered (gdb_stdlog,
1186                                     "Packet %s (%s) is supported\n",
1187                                     config->name, config->title);
1188           config->support = PACKET_ENABLE;
1189           break;
1190         case PACKET_DISABLE:
1191           internal_error (__FILE__, __LINE__,
1192                           _("packet_ok: attempt to use a disabled packet"));
1193           break;
1194         case PACKET_ENABLE:
1195           break;
1196         }
1197       break;
1198     case PACKET_UNKNOWN:
1199       /* The stub does not support the packet.  */
1200       switch (config->support)
1201         {
1202         case PACKET_ENABLE:
1203           if (config->detect == AUTO_BOOLEAN_AUTO)
1204             /* If the stub previously indicated that the packet was
1205                supported then there is a protocol error..  */
1206             error (_("Protocol error: %s (%s) conflicting enabled responses."),
1207                    config->name, config->title);
1208           else
1209             /* The user set it wrong.  */
1210             error (_("Enabled packet %s (%s) not recognized by stub"),
1211                    config->name, config->title);
1212           break;
1213         case PACKET_SUPPORT_UNKNOWN:
1214           if (remote_debug)
1215             fprintf_unfiltered (gdb_stdlog,
1216                                 "Packet %s (%s) is NOT supported\n",
1217                                 config->name, config->title);
1218           config->support = PACKET_DISABLE;
1219           break;
1220         case PACKET_DISABLE:
1221           break;
1222         }
1223       break;
1224     }
1225
1226   return result;
1227 }
1228
1229 enum {
1230   PACKET_vCont = 0,
1231   PACKET_X,
1232   PACKET_qSymbol,
1233   PACKET_P,
1234   PACKET_p,
1235   PACKET_Z0,
1236   PACKET_Z1,
1237   PACKET_Z2,
1238   PACKET_Z3,
1239   PACKET_Z4,
1240   PACKET_vFile_open,
1241   PACKET_vFile_pread,
1242   PACKET_vFile_pwrite,
1243   PACKET_vFile_close,
1244   PACKET_vFile_unlink,
1245   PACKET_vFile_readlink,
1246   PACKET_qXfer_auxv,
1247   PACKET_qXfer_features,
1248   PACKET_qXfer_libraries,
1249   PACKET_qXfer_libraries_svr4,
1250   PACKET_qXfer_memory_map,
1251   PACKET_qXfer_spu_read,
1252   PACKET_qXfer_spu_write,
1253   PACKET_qXfer_osdata,
1254   PACKET_qXfer_threads,
1255   PACKET_qXfer_statictrace_read,
1256   PACKET_qXfer_traceframe_info,
1257   PACKET_qXfer_uib,
1258   PACKET_qGetTIBAddr,
1259   PACKET_qGetTLSAddr,
1260   PACKET_qSupported,
1261   PACKET_QPassSignals,
1262   PACKET_QProgramSignals,
1263   PACKET_qSearch_memory,
1264   PACKET_vAttach,
1265   PACKET_vRun,
1266   PACKET_QStartNoAckMode,
1267   PACKET_vKill,
1268   PACKET_qXfer_siginfo_read,
1269   PACKET_qXfer_siginfo_write,
1270   PACKET_qAttached,
1271   PACKET_ConditionalTracepoints,
1272   PACKET_ConditionalBreakpoints,
1273   PACKET_BreakpointCommands,
1274   PACKET_FastTracepoints,
1275   PACKET_StaticTracepoints,
1276   PACKET_InstallInTrace,
1277   PACKET_bc,
1278   PACKET_bs,
1279   PACKET_TracepointSource,
1280   PACKET_QAllow,
1281   PACKET_qXfer_fdpic,
1282   PACKET_QDisableRandomization,
1283   PACKET_QAgent,
1284   PACKET_QTBuffer_size,
1285   PACKET_Qbtrace_off,
1286   PACKET_Qbtrace_bts,
1287   PACKET_qXfer_btrace,
1288   PACKET_MAX
1289 };
1290
1291 static struct packet_config remote_protocol_packets[PACKET_MAX];
1292
1293 static void
1294 set_remote_protocol_packet_cmd (char *args, int from_tty,
1295                                 struct cmd_list_element *c)
1296 {
1297   struct packet_config *packet;
1298
1299   for (packet = remote_protocol_packets;
1300        packet < &remote_protocol_packets[PACKET_MAX];
1301        packet++)
1302     {
1303       if (&packet->detect == c->var)
1304         {
1305           update_packet_config (packet);
1306           return;
1307         }
1308     }
1309   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1310                   c->name);
1311 }
1312
1313 static void
1314 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
1315                                  struct cmd_list_element *c,
1316                                  const char *value)
1317 {
1318   struct packet_config *packet;
1319
1320   for (packet = remote_protocol_packets;
1321        packet < &remote_protocol_packets[PACKET_MAX];
1322        packet++)
1323     {
1324       if (&packet->detect == c->var)
1325         {
1326           show_packet_config_cmd (packet);
1327           return;
1328         }
1329     }
1330   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1331                   c->name);
1332 }
1333
1334 /* Should we try one of the 'Z' requests?  */
1335
1336 enum Z_packet_type
1337 {
1338   Z_PACKET_SOFTWARE_BP,
1339   Z_PACKET_HARDWARE_BP,
1340   Z_PACKET_WRITE_WP,
1341   Z_PACKET_READ_WP,
1342   Z_PACKET_ACCESS_WP,
1343   NR_Z_PACKET_TYPES
1344 };
1345
1346 /* For compatibility with older distributions.  Provide a ``set remote
1347    Z-packet ...'' command that updates all the Z packet types.  */
1348
1349 static enum auto_boolean remote_Z_packet_detect;
1350
1351 static void
1352 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
1353                                   struct cmd_list_element *c)
1354 {
1355   int i;
1356
1357   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1358     {
1359       remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1360       update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
1361     }
1362 }
1363
1364 static void
1365 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1366                                    struct cmd_list_element *c,
1367                                    const char *value)
1368 {
1369   int i;
1370
1371   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1372     {
1373       show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1374     }
1375 }
1376
1377 /* Should we try the 'ThreadInfo' query packet?
1378
1379    This variable (NOT available to the user: auto-detect only!)
1380    determines whether GDB will use the new, simpler "ThreadInfo"
1381    query or the older, more complex syntax for thread queries.
1382    This is an auto-detect variable (set to true at each connect,
1383    and set to false when the target fails to recognize it).  */
1384
1385 static int use_threadinfo_query;
1386 static int use_threadextra_query;
1387
1388 /* Tokens for use by the asynchronous signal handlers for SIGINT.  */
1389 static struct async_signal_handler *sigint_remote_twice_token;
1390 static struct async_signal_handler *sigint_remote_token;
1391
1392 \f
1393 /* Asynchronous signal handle registered as event loop source for
1394    when we have pending events ready to be passed to the core.  */
1395
1396 static struct async_event_handler *remote_async_inferior_event_token;
1397
1398 \f
1399
1400 static ptid_t magic_null_ptid;
1401 static ptid_t not_sent_ptid;
1402 static ptid_t any_thread_ptid;
1403
1404 /* These are the threads which we last sent to the remote system.  The
1405    TID member will be -1 for all or -2 for not sent yet.  */
1406
1407 static ptid_t general_thread;
1408 static ptid_t continue_thread;
1409
1410 /* This is the traceframe which we last selected on the remote system.
1411    It will be -1 if no traceframe is selected.  */
1412 static int remote_traceframe_number = -1;
1413
1414 /* Find out if the stub attached to PID (and hence GDB should offer to
1415    detach instead of killing it when bailing out).  */
1416
1417 static int
1418 remote_query_attached (int pid)
1419 {
1420   struct remote_state *rs = get_remote_state ();
1421   size_t size = get_remote_packet_size ();
1422
1423   if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE)
1424     return 0;
1425
1426   if (remote_multi_process_p (rs))
1427     xsnprintf (rs->buf, size, "qAttached:%x", pid);
1428   else
1429     xsnprintf (rs->buf, size, "qAttached");
1430
1431   putpkt (rs->buf);
1432   getpkt (&rs->buf, &rs->buf_size, 0);
1433
1434   switch (packet_ok (rs->buf,
1435                      &remote_protocol_packets[PACKET_qAttached]))
1436     {
1437     case PACKET_OK:
1438       if (strcmp (rs->buf, "1") == 0)
1439         return 1;
1440       break;
1441     case PACKET_ERROR:
1442       warning (_("Remote failure reply: %s"), rs->buf);
1443       break;
1444     case PACKET_UNKNOWN:
1445       break;
1446     }
1447
1448   return 0;
1449 }
1450
1451 /* Add PID to GDB's inferior table.  If FAKE_PID_P is true, then PID
1452    has been invented by GDB, instead of reported by the target.  Since
1453    we can be connected to a remote system before before knowing about
1454    any inferior, mark the target with execution when we find the first
1455    inferior.  If ATTACHED is 1, then we had just attached to this
1456    inferior.  If it is 0, then we just created this inferior.  If it
1457    is -1, then try querying the remote stub to find out if it had
1458    attached to the inferior or not.  */
1459
1460 static struct inferior *
1461 remote_add_inferior (int fake_pid_p, int pid, int attached)
1462 {
1463   struct inferior *inf;
1464
1465   /* Check whether this process we're learning about is to be
1466      considered attached, or if is to be considered to have been
1467      spawned by the stub.  */
1468   if (attached == -1)
1469     attached = remote_query_attached (pid);
1470
1471   if (gdbarch_has_global_solist (target_gdbarch ()))
1472     {
1473       /* If the target shares code across all inferiors, then every
1474          attach adds a new inferior.  */
1475       inf = add_inferior (pid);
1476
1477       /* ... and every inferior is bound to the same program space.
1478          However, each inferior may still have its own address
1479          space.  */
1480       inf->aspace = maybe_new_address_space ();
1481       inf->pspace = current_program_space;
1482     }
1483   else
1484     {
1485       /* In the traditional debugging scenario, there's a 1-1 match
1486          between program/address spaces.  We simply bind the inferior
1487          to the program space's address space.  */
1488       inf = current_inferior ();
1489       inferior_appeared (inf, pid);
1490     }
1491
1492   inf->attach_flag = attached;
1493   inf->fake_pid_p = fake_pid_p;
1494
1495   return inf;
1496 }
1497
1498 /* Add thread PTID to GDB's thread list.  Tag it as executing/running
1499    according to RUNNING.  */
1500
1501 static void
1502 remote_add_thread (ptid_t ptid, int running)
1503 {
1504   add_thread (ptid);
1505
1506   set_executing (ptid, running);
1507   set_running (ptid, running);
1508 }
1509
1510 /* Come here when we learn about a thread id from the remote target.
1511    It may be the first time we hear about such thread, so take the
1512    opportunity to add it to GDB's thread list.  In case this is the
1513    first time we're noticing its corresponding inferior, add it to
1514    GDB's inferior list as well.  */
1515
1516 static void
1517 remote_notice_new_inferior (ptid_t currthread, int running)
1518 {
1519   /* If this is a new thread, add it to GDB's thread list.
1520      If we leave it up to WFI to do this, bad things will happen.  */
1521
1522   if (in_thread_list (currthread) && is_exited (currthread))
1523     {
1524       /* We're seeing an event on a thread id we knew had exited.
1525          This has to be a new thread reusing the old id.  Add it.  */
1526       remote_add_thread (currthread, running);
1527       return;
1528     }
1529
1530   if (!in_thread_list (currthread))
1531     {
1532       struct inferior *inf = NULL;
1533       int pid = ptid_get_pid (currthread);
1534
1535       if (ptid_is_pid (inferior_ptid)
1536           && pid == ptid_get_pid (inferior_ptid))
1537         {
1538           /* inferior_ptid has no thread member yet.  This can happen
1539              with the vAttach -> remote_wait,"TAAthread:" path if the
1540              stub doesn't support qC.  This is the first stop reported
1541              after an attach, so this is the main thread.  Update the
1542              ptid in the thread list.  */
1543           if (in_thread_list (pid_to_ptid (pid)))
1544             thread_change_ptid (inferior_ptid, currthread);
1545           else
1546             {
1547               remote_add_thread (currthread, running);
1548               inferior_ptid = currthread;
1549             }
1550           return;
1551         }
1552
1553       if (ptid_equal (magic_null_ptid, inferior_ptid))
1554         {
1555           /* inferior_ptid is not set yet.  This can happen with the
1556              vRun -> remote_wait,"TAAthread:" path if the stub
1557              doesn't support qC.  This is the first stop reported
1558              after an attach, so this is the main thread.  Update the
1559              ptid in the thread list.  */
1560           thread_change_ptid (inferior_ptid, currthread);
1561           return;
1562         }
1563
1564       /* When connecting to a target remote, or to a target
1565          extended-remote which already was debugging an inferior, we
1566          may not know about it yet.  Add it before adding its child
1567          thread, so notifications are emitted in a sensible order.  */
1568       if (!in_inferior_list (ptid_get_pid (currthread)))
1569         {
1570           struct remote_state *rs = get_remote_state ();
1571           int fake_pid_p = !remote_multi_process_p (rs);
1572
1573           inf = remote_add_inferior (fake_pid_p,
1574                                      ptid_get_pid (currthread), -1);
1575         }
1576
1577       /* This is really a new thread.  Add it.  */
1578       remote_add_thread (currthread, running);
1579
1580       /* If we found a new inferior, let the common code do whatever
1581          it needs to with it (e.g., read shared libraries, insert
1582          breakpoints).  */
1583       if (inf != NULL)
1584         notice_new_inferior (currthread, running, 0);
1585     }
1586 }
1587
1588 /* Return the private thread data, creating it if necessary.  */
1589
1590 static struct private_thread_info *
1591 demand_private_info (ptid_t ptid)
1592 {
1593   struct thread_info *info = find_thread_ptid (ptid);
1594
1595   gdb_assert (info);
1596
1597   if (!info->private)
1598     {
1599       info->private = xmalloc (sizeof (*(info->private)));
1600       info->private_dtor = free_private_thread_info;
1601       info->private->core = -1;
1602       info->private->extra = 0;
1603     }
1604
1605   return info->private;
1606 }
1607
1608 /* Call this function as a result of
1609    1) A halt indication (T packet) containing a thread id
1610    2) A direct query of currthread
1611    3) Successful execution of set thread */
1612
1613 static void
1614 record_currthread (ptid_t currthread)
1615 {
1616   general_thread = currthread;
1617 }
1618
1619 static char *last_pass_packet;
1620
1621 /* If 'QPassSignals' is supported, tell the remote stub what signals
1622    it can simply pass through to the inferior without reporting.  */
1623
1624 static void
1625 remote_pass_signals (int numsigs, unsigned char *pass_signals)
1626 {
1627   if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
1628     {
1629       char *pass_packet, *p;
1630       int count = 0, i;
1631
1632       gdb_assert (numsigs < 256);
1633       for (i = 0; i < numsigs; i++)
1634         {
1635           if (pass_signals[i])
1636             count++;
1637         }
1638       pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1639       strcpy (pass_packet, "QPassSignals:");
1640       p = pass_packet + strlen (pass_packet);
1641       for (i = 0; i < numsigs; i++)
1642         {
1643           if (pass_signals[i])
1644             {
1645               if (i >= 16)
1646                 *p++ = tohex (i >> 4);
1647               *p++ = tohex (i & 15);
1648               if (count)
1649                 *p++ = ';';
1650               else
1651                 break;
1652               count--;
1653             }
1654         }
1655       *p = 0;
1656       if (!last_pass_packet || strcmp (last_pass_packet, pass_packet))
1657         {
1658           struct remote_state *rs = get_remote_state ();
1659           char *buf = rs->buf;
1660
1661           putpkt (pass_packet);
1662           getpkt (&rs->buf, &rs->buf_size, 0);
1663           packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
1664           if (last_pass_packet)
1665             xfree (last_pass_packet);
1666           last_pass_packet = pass_packet;
1667         }
1668       else
1669         xfree (pass_packet);
1670     }
1671 }
1672
1673 /* The last QProgramSignals packet sent to the target.  We bypass
1674    sending a new program signals list down to the target if the new
1675    packet is exactly the same as the last we sent.  IOW, we only let
1676    the target know about program signals list changes.  */
1677
1678 static char *last_program_signals_packet;
1679
1680 /* If 'QProgramSignals' is supported, tell the remote stub what
1681    signals it should pass through to the inferior when detaching.  */
1682
1683 static void
1684 remote_program_signals (int numsigs, unsigned char *signals)
1685 {
1686   if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
1687     {
1688       char *packet, *p;
1689       int count = 0, i;
1690
1691       gdb_assert (numsigs < 256);
1692       for (i = 0; i < numsigs; i++)
1693         {
1694           if (signals[i])
1695             count++;
1696         }
1697       packet = xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
1698       strcpy (packet, "QProgramSignals:");
1699       p = packet + strlen (packet);
1700       for (i = 0; i < numsigs; i++)
1701         {
1702           if (signal_pass_state (i))
1703             {
1704               if (i >= 16)
1705                 *p++ = tohex (i >> 4);
1706               *p++ = tohex (i & 15);
1707               if (count)
1708                 *p++ = ';';
1709               else
1710                 break;
1711               count--;
1712             }
1713         }
1714       *p = 0;
1715       if (!last_program_signals_packet
1716           || strcmp (last_program_signals_packet, packet) != 0)
1717         {
1718           struct remote_state *rs = get_remote_state ();
1719           char *buf = rs->buf;
1720
1721           putpkt (packet);
1722           getpkt (&rs->buf, &rs->buf_size, 0);
1723           packet_ok (buf, &remote_protocol_packets[PACKET_QProgramSignals]);
1724           xfree (last_program_signals_packet);
1725           last_program_signals_packet = packet;
1726         }
1727       else
1728         xfree (packet);
1729     }
1730 }
1731
1732 /* If PTID is MAGIC_NULL_PTID, don't set any thread.  If PTID is
1733    MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1734    thread.  If GEN is set, set the general thread, if not, then set
1735    the step/continue thread.  */
1736 static void
1737 set_thread (struct ptid ptid, int gen)
1738 {
1739   struct remote_state *rs = get_remote_state ();
1740   ptid_t state = gen ? general_thread : continue_thread;
1741   char *buf = rs->buf;
1742   char *endbuf = rs->buf + get_remote_packet_size ();
1743
1744   if (ptid_equal (state, ptid))
1745     return;
1746
1747   *buf++ = 'H';
1748   *buf++ = gen ? 'g' : 'c';
1749   if (ptid_equal (ptid, magic_null_ptid))
1750     xsnprintf (buf, endbuf - buf, "0");
1751   else if (ptid_equal (ptid, any_thread_ptid))
1752     xsnprintf (buf, endbuf - buf, "0");
1753   else if (ptid_equal (ptid, minus_one_ptid))
1754     xsnprintf (buf, endbuf - buf, "-1");
1755   else
1756     write_ptid (buf, endbuf, ptid);
1757   putpkt (rs->buf);
1758   getpkt (&rs->buf, &rs->buf_size, 0);
1759   if (gen)
1760     general_thread = ptid;
1761   else
1762     continue_thread = ptid;
1763 }
1764
1765 static void
1766 set_general_thread (struct ptid ptid)
1767 {
1768   set_thread (ptid, 1);
1769 }
1770
1771 static void
1772 set_continue_thread (struct ptid ptid)
1773 {
1774   set_thread (ptid, 0);
1775 }
1776
1777 /* Change the remote current process.  Which thread within the process
1778    ends up selected isn't important, as long as it is the same process
1779    as what INFERIOR_PTID points to.
1780
1781    This comes from that fact that there is no explicit notion of
1782    "selected process" in the protocol.  The selected process for
1783    general operations is the process the selected general thread
1784    belongs to.  */
1785
1786 static void
1787 set_general_process (void)
1788 {
1789   struct remote_state *rs = get_remote_state ();
1790
1791   /* If the remote can't handle multiple processes, don't bother.  */
1792   if (!rs->extended || !remote_multi_process_p (rs))
1793     return;
1794
1795   /* We only need to change the remote current thread if it's pointing
1796      at some other process.  */
1797   if (ptid_get_pid (general_thread) != ptid_get_pid (inferior_ptid))
1798     set_general_thread (inferior_ptid);
1799 }
1800
1801 \f
1802 /*  Return nonzero if the thread PTID is still alive on the remote
1803     system.  */
1804
1805 static int
1806 remote_thread_alive (struct target_ops *ops, ptid_t ptid)
1807 {
1808   struct remote_state *rs = get_remote_state ();
1809   char *p, *endp;
1810
1811   if (ptid_equal (ptid, magic_null_ptid))
1812     /* The main thread is always alive.  */
1813     return 1;
1814
1815   if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0)
1816     /* The main thread is always alive.  This can happen after a
1817        vAttach, if the remote side doesn't support
1818        multi-threading.  */
1819     return 1;
1820
1821   p = rs->buf;
1822   endp = rs->buf + get_remote_packet_size ();
1823
1824   *p++ = 'T';
1825   write_ptid (p, endp, ptid);
1826
1827   putpkt (rs->buf);
1828   getpkt (&rs->buf, &rs->buf_size, 0);
1829   return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
1830 }
1831
1832 /* About these extended threadlist and threadinfo packets.  They are
1833    variable length packets but, the fields within them are often fixed
1834    length.  They are redundent enough to send over UDP as is the
1835    remote protocol in general.  There is a matching unit test module
1836    in libstub.  */
1837
1838 #define OPAQUETHREADBYTES 8
1839
1840 /* a 64 bit opaque identifier */
1841 typedef unsigned char threadref[OPAQUETHREADBYTES];
1842
1843 /* WARNING: This threadref data structure comes from the remote O.S.,
1844    libstub protocol encoding, and remote.c.  It is not particularly
1845    changable.  */
1846
1847 /* Right now, the internal structure is int. We want it to be bigger.
1848    Plan to fix this.  */
1849
1850 typedef int gdb_threadref;      /* Internal GDB thread reference.  */
1851
1852 /* gdb_ext_thread_info is an internal GDB data structure which is
1853    equivalent to the reply of the remote threadinfo packet.  */
1854
1855 struct gdb_ext_thread_info
1856   {
1857     threadref threadid;         /* External form of thread reference.  */
1858     int active;                 /* Has state interesting to GDB?
1859                                    regs, stack.  */
1860     char display[256];          /* Brief state display, name,
1861                                    blocked/suspended.  */
1862     char shortname[32];         /* To be used to name threads.  */
1863     char more_display[256];     /* Long info, statistics, queue depth,
1864                                    whatever.  */
1865   };
1866
1867 /* The volume of remote transfers can be limited by submitting
1868    a mask containing bits specifying the desired information.
1869    Use a union of these values as the 'selection' parameter to
1870    get_thread_info.  FIXME: Make these TAG names more thread specific.  */
1871
1872 #define TAG_THREADID 1
1873 #define TAG_EXISTS 2
1874 #define TAG_DISPLAY 4
1875 #define TAG_THREADNAME 8
1876 #define TAG_MOREDISPLAY 16
1877
1878 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1879
1880 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1881
1882 static char *unpack_nibble (char *buf, int *val);
1883
1884 static char *pack_nibble (char *buf, int nibble);
1885
1886 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1887
1888 static char *unpack_byte (char *buf, int *value);
1889
1890 static char *pack_int (char *buf, int value);
1891
1892 static char *unpack_int (char *buf, int *value);
1893
1894 static char *unpack_string (char *src, char *dest, int length);
1895
1896 static char *pack_threadid (char *pkt, threadref *id);
1897
1898 static char *unpack_threadid (char *inbuf, threadref *id);
1899
1900 void int_to_threadref (threadref *id, int value);
1901
1902 static int threadref_to_int (threadref *ref);
1903
1904 static void copy_threadref (threadref *dest, threadref *src);
1905
1906 static int threadmatch (threadref *dest, threadref *src);
1907
1908 static char *pack_threadinfo_request (char *pkt, int mode,
1909                                       threadref *id);
1910
1911 static int remote_unpack_thread_info_response (char *pkt,
1912                                                threadref *expectedref,
1913                                                struct gdb_ext_thread_info
1914                                                *info);
1915
1916
1917 static int remote_get_threadinfo (threadref *threadid,
1918                                   int fieldset, /*TAG mask */
1919                                   struct gdb_ext_thread_info *info);
1920
1921 static char *pack_threadlist_request (char *pkt, int startflag,
1922                                       int threadcount,
1923                                       threadref *nextthread);
1924
1925 static int parse_threadlist_response (char *pkt,
1926                                       int result_limit,
1927                                       threadref *original_echo,
1928                                       threadref *resultlist,
1929                                       int *doneflag);
1930
1931 static int remote_get_threadlist (int startflag,
1932                                   threadref *nextthread,
1933                                   int result_limit,
1934                                   int *done,
1935                                   int *result_count,
1936                                   threadref *threadlist);
1937
1938 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1939
1940 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1941                                        void *context, int looplimit);
1942
1943 static int remote_newthread_step (threadref *ref, void *context);
1944
1945
1946 /* Write a PTID to BUF.  ENDBUF points to one-passed-the-end of the
1947    buffer we're allowed to write to.  Returns
1948    BUF+CHARACTERS_WRITTEN.  */
1949
1950 static char *
1951 write_ptid (char *buf, const char *endbuf, ptid_t ptid)
1952 {
1953   int pid, tid;
1954   struct remote_state *rs = get_remote_state ();
1955
1956   if (remote_multi_process_p (rs))
1957     {
1958       pid = ptid_get_pid (ptid);
1959       if (pid < 0)
1960         buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
1961       else
1962         buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
1963     }
1964   tid = ptid_get_tid (ptid);
1965   if (tid < 0)
1966     buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
1967   else
1968     buf += xsnprintf (buf, endbuf - buf, "%x", tid);
1969
1970   return buf;
1971 }
1972
1973 /* Extract a PTID from BUF.  If non-null, OBUF is set to the to one
1974    passed the last parsed char.  Returns null_ptid on error.  */
1975
1976 static ptid_t
1977 read_ptid (char *buf, char **obuf)
1978 {
1979   char *p = buf;
1980   char *pp;
1981   ULONGEST pid = 0, tid = 0;
1982
1983   if (*p == 'p')
1984     {
1985       /* Multi-process ptid.  */
1986       pp = unpack_varlen_hex (p + 1, &pid);
1987       if (*pp != '.')
1988         error (_("invalid remote ptid: %s"), p);
1989
1990       p = pp;
1991       pp = unpack_varlen_hex (p + 1, &tid);
1992       if (obuf)
1993         *obuf = pp;
1994       return ptid_build (pid, 0, tid);
1995     }
1996
1997   /* No multi-process.  Just a tid.  */
1998   pp = unpack_varlen_hex (p, &tid);
1999
2000   /* Since the stub is not sending a process id, then default to
2001      what's in inferior_ptid, unless it's null at this point.  If so,
2002      then since there's no way to know the pid of the reported
2003      threads, use the magic number.  */
2004   if (ptid_equal (inferior_ptid, null_ptid))
2005     pid = ptid_get_pid (magic_null_ptid);
2006   else
2007     pid = ptid_get_pid (inferior_ptid);
2008
2009   if (obuf)
2010     *obuf = pp;
2011   return ptid_build (pid, 0, tid);
2012 }
2013
2014 /* Encode 64 bits in 16 chars of hex.  */
2015
2016 static const char hexchars[] = "0123456789abcdef";
2017
2018 static int
2019 ishex (int ch, int *val)
2020 {
2021   if ((ch >= 'a') && (ch <= 'f'))
2022     {
2023       *val = ch - 'a' + 10;
2024       return 1;
2025     }
2026   if ((ch >= 'A') && (ch <= 'F'))
2027     {
2028       *val = ch - 'A' + 10;
2029       return 1;
2030     }
2031   if ((ch >= '0') && (ch <= '9'))
2032     {
2033       *val = ch - '0';
2034       return 1;
2035     }
2036   return 0;
2037 }
2038
2039 static int
2040 stubhex (int ch)
2041 {
2042   if (ch >= 'a' && ch <= 'f')
2043     return ch - 'a' + 10;
2044   if (ch >= '0' && ch <= '9')
2045     return ch - '0';
2046   if (ch >= 'A' && ch <= 'F')
2047     return ch - 'A' + 10;
2048   return -1;
2049 }
2050
2051 static int
2052 stub_unpack_int (char *buff, int fieldlength)
2053 {
2054   int nibble;
2055   int retval = 0;
2056
2057   while (fieldlength)
2058     {
2059       nibble = stubhex (*buff++);
2060       retval |= nibble;
2061       fieldlength--;
2062       if (fieldlength)
2063         retval = retval << 4;
2064     }
2065   return retval;
2066 }
2067
2068 char *
2069 unpack_varlen_hex (char *buff,  /* packet to parse */
2070                    ULONGEST *result)
2071 {
2072   int nibble;
2073   ULONGEST retval = 0;
2074
2075   while (ishex (*buff, &nibble))
2076     {
2077       buff++;
2078       retval = retval << 4;
2079       retval |= nibble & 0x0f;
2080     }
2081   *result = retval;
2082   return buff;
2083 }
2084
2085 static char *
2086 unpack_nibble (char *buf, int *val)
2087 {
2088   *val = fromhex (*buf++);
2089   return buf;
2090 }
2091
2092 static char *
2093 pack_nibble (char *buf, int nibble)
2094 {
2095   *buf++ = hexchars[(nibble & 0x0f)];
2096   return buf;
2097 }
2098
2099 static char *
2100 pack_hex_byte (char *pkt, int byte)
2101 {
2102   *pkt++ = hexchars[(byte >> 4) & 0xf];
2103   *pkt++ = hexchars[(byte & 0xf)];
2104   return pkt;
2105 }
2106
2107 static char *
2108 unpack_byte (char *buf, int *value)
2109 {
2110   *value = stub_unpack_int (buf, 2);
2111   return buf + 2;
2112 }
2113
2114 static char *
2115 pack_int (char *buf, int value)
2116 {
2117   buf = pack_hex_byte (buf, (value >> 24) & 0xff);
2118   buf = pack_hex_byte (buf, (value >> 16) & 0xff);
2119   buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
2120   buf = pack_hex_byte (buf, (value & 0xff));
2121   return buf;
2122 }
2123
2124 static char *
2125 unpack_int (char *buf, int *value)
2126 {
2127   *value = stub_unpack_int (buf, 8);
2128   return buf + 8;
2129 }
2130
2131 #if 0                   /* Currently unused, uncomment when needed.  */
2132 static char *pack_string (char *pkt, char *string);
2133
2134 static char *
2135 pack_string (char *pkt, char *string)
2136 {
2137   char ch;
2138   int len;
2139
2140   len = strlen (string);
2141   if (len > 200)
2142     len = 200;          /* Bigger than most GDB packets, junk???  */
2143   pkt = pack_hex_byte (pkt, len);
2144   while (len-- > 0)
2145     {
2146       ch = *string++;
2147       if ((ch == '\0') || (ch == '#'))
2148         ch = '*';               /* Protect encapsulation.  */
2149       *pkt++ = ch;
2150     }
2151   return pkt;
2152 }
2153 #endif /* 0 (unused) */
2154
2155 static char *
2156 unpack_string (char *src, char *dest, int length)
2157 {
2158   while (length--)
2159     *dest++ = *src++;
2160   *dest = '\0';
2161   return src;
2162 }
2163
2164 static char *
2165 pack_threadid (char *pkt, threadref *id)
2166 {
2167   char *limit;
2168   unsigned char *altid;
2169
2170   altid = (unsigned char *) id;
2171   limit = pkt + BUF_THREAD_ID_SIZE;
2172   while (pkt < limit)
2173     pkt = pack_hex_byte (pkt, *altid++);
2174   return pkt;
2175 }
2176
2177
2178 static char *
2179 unpack_threadid (char *inbuf, threadref *id)
2180 {
2181   char *altref;
2182   char *limit = inbuf + BUF_THREAD_ID_SIZE;
2183   int x, y;
2184
2185   altref = (char *) id;
2186
2187   while (inbuf < limit)
2188     {
2189       x = stubhex (*inbuf++);
2190       y = stubhex (*inbuf++);
2191       *altref++ = (x << 4) | y;
2192     }
2193   return inbuf;
2194 }
2195
2196 /* Externally, threadrefs are 64 bits but internally, they are still
2197    ints.  This is due to a mismatch of specifications.  We would like
2198    to use 64bit thread references internally.  This is an adapter
2199    function.  */
2200
2201 void
2202 int_to_threadref (threadref *id, int value)
2203 {
2204   unsigned char *scan;
2205
2206   scan = (unsigned char *) id;
2207   {
2208     int i = 4;
2209     while (i--)
2210       *scan++ = 0;
2211   }
2212   *scan++ = (value >> 24) & 0xff;
2213   *scan++ = (value >> 16) & 0xff;
2214   *scan++ = (value >> 8) & 0xff;
2215   *scan++ = (value & 0xff);
2216 }
2217
2218 static int
2219 threadref_to_int (threadref *ref)
2220 {
2221   int i, value = 0;
2222   unsigned char *scan;
2223
2224   scan = *ref;
2225   scan += 4;
2226   i = 4;
2227   while (i-- > 0)
2228     value = (value << 8) | ((*scan++) & 0xff);
2229   return value;
2230 }
2231
2232 static void
2233 copy_threadref (threadref *dest, threadref *src)
2234 {
2235   int i;
2236   unsigned char *csrc, *cdest;
2237
2238   csrc = (unsigned char *) src;
2239   cdest = (unsigned char *) dest;
2240   i = 8;
2241   while (i--)
2242     *cdest++ = *csrc++;
2243 }
2244
2245 static int
2246 threadmatch (threadref *dest, threadref *src)
2247 {
2248   /* Things are broken right now, so just assume we got a match.  */
2249 #if 0
2250   unsigned char *srcp, *destp;
2251   int i, result;
2252   srcp = (char *) src;
2253   destp = (char *) dest;
2254
2255   result = 1;
2256   while (i-- > 0)
2257     result &= (*srcp++ == *destp++) ? 1 : 0;
2258   return result;
2259 #endif
2260   return 1;
2261 }
2262
2263 /*
2264    threadid:1,        # always request threadid
2265    context_exists:2,
2266    display:4,
2267    unique_name:8,
2268    more_display:16
2269  */
2270
2271 /* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
2272
2273 static char *
2274 pack_threadinfo_request (char *pkt, int mode, threadref *id)
2275 {
2276   *pkt++ = 'q';                         /* Info Query */
2277   *pkt++ = 'P';                         /* process or thread info */
2278   pkt = pack_int (pkt, mode);           /* mode */
2279   pkt = pack_threadid (pkt, id);        /* threadid */
2280   *pkt = '\0';                          /* terminate */
2281   return pkt;
2282 }
2283
2284 /* These values tag the fields in a thread info response packet.  */
2285 /* Tagging the fields allows us to request specific fields and to
2286    add more fields as time goes by.  */
2287
2288 #define TAG_THREADID 1          /* Echo the thread identifier.  */
2289 #define TAG_EXISTS 2            /* Is this process defined enough to
2290                                    fetch registers and its stack?  */
2291 #define TAG_DISPLAY 4           /* A short thing maybe to put on a window */
2292 #define TAG_THREADNAME 8        /* string, maps 1-to-1 with a thread is.  */
2293 #define TAG_MOREDISPLAY 16      /* Whatever the kernel wants to say about
2294                                    the process.  */
2295
2296 static int
2297 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
2298                                     struct gdb_ext_thread_info *info)
2299 {
2300   struct remote_state *rs = get_remote_state ();
2301   int mask, length;
2302   int tag;
2303   threadref ref;
2304   char *limit = pkt + rs->buf_size; /* Plausible parsing limit.  */
2305   int retval = 1;
2306
2307   /* info->threadid = 0; FIXME: implement zero_threadref.  */
2308   info->active = 0;
2309   info->display[0] = '\0';
2310   info->shortname[0] = '\0';
2311   info->more_display[0] = '\0';
2312
2313   /* Assume the characters indicating the packet type have been
2314      stripped.  */
2315   pkt = unpack_int (pkt, &mask);        /* arg mask */
2316   pkt = unpack_threadid (pkt, &ref);
2317
2318   if (mask == 0)
2319     warning (_("Incomplete response to threadinfo request."));
2320   if (!threadmatch (&ref, expectedref))
2321     {                   /* This is an answer to a different request.  */
2322       warning (_("ERROR RMT Thread info mismatch."));
2323       return 0;
2324     }
2325   copy_threadref (&info->threadid, &ref);
2326
2327   /* Loop on tagged fields , try to bail if somthing goes wrong.  */
2328
2329   /* Packets are terminated with nulls.  */
2330   while ((pkt < limit) && mask && *pkt)
2331     {
2332       pkt = unpack_int (pkt, &tag);     /* tag */
2333       pkt = unpack_byte (pkt, &length); /* length */
2334       if (!(tag & mask))                /* Tags out of synch with mask.  */
2335         {
2336           warning (_("ERROR RMT: threadinfo tag mismatch."));
2337           retval = 0;
2338           break;
2339         }
2340       if (tag == TAG_THREADID)
2341         {
2342           if (length != 16)
2343             {
2344               warning (_("ERROR RMT: length of threadid is not 16."));
2345               retval = 0;
2346               break;
2347             }
2348           pkt = unpack_threadid (pkt, &ref);
2349           mask = mask & ~TAG_THREADID;
2350           continue;
2351         }
2352       if (tag == TAG_EXISTS)
2353         {
2354           info->active = stub_unpack_int (pkt, length);
2355           pkt += length;
2356           mask = mask & ~(TAG_EXISTS);
2357           if (length > 8)
2358             {
2359               warning (_("ERROR RMT: 'exists' length too long."));
2360               retval = 0;
2361               break;
2362             }
2363           continue;
2364         }
2365       if (tag == TAG_THREADNAME)
2366         {
2367           pkt = unpack_string (pkt, &info->shortname[0], length);
2368           mask = mask & ~TAG_THREADNAME;
2369           continue;
2370         }
2371       if (tag == TAG_DISPLAY)
2372         {
2373           pkt = unpack_string (pkt, &info->display[0], length);
2374           mask = mask & ~TAG_DISPLAY;
2375           continue;
2376         }
2377       if (tag == TAG_MOREDISPLAY)
2378         {
2379           pkt = unpack_string (pkt, &info->more_display[0], length);
2380           mask = mask & ~TAG_MOREDISPLAY;
2381           continue;
2382         }
2383       warning (_("ERROR RMT: unknown thread info tag."));
2384       break;                    /* Not a tag we know about.  */
2385     }
2386   return retval;
2387 }
2388
2389 static int
2390 remote_get_threadinfo (threadref *threadid, int fieldset,       /* TAG mask */
2391                        struct gdb_ext_thread_info *info)
2392 {
2393   struct remote_state *rs = get_remote_state ();
2394   int result;
2395
2396   pack_threadinfo_request (rs->buf, fieldset, threadid);
2397   putpkt (rs->buf);
2398   getpkt (&rs->buf, &rs->buf_size, 0);
2399
2400   if (rs->buf[0] == '\0')
2401     return 0;
2402
2403   result = remote_unpack_thread_info_response (rs->buf + 2,
2404                                                threadid, info);
2405   return result;
2406 }
2407
2408 /*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
2409
2410 static char *
2411 pack_threadlist_request (char *pkt, int startflag, int threadcount,
2412                          threadref *nextthread)
2413 {
2414   *pkt++ = 'q';                 /* info query packet */
2415   *pkt++ = 'L';                 /* Process LIST or threadLIST request */
2416   pkt = pack_nibble (pkt, startflag);           /* initflag 1 bytes */
2417   pkt = pack_hex_byte (pkt, threadcount);       /* threadcount 2 bytes */
2418   pkt = pack_threadid (pkt, nextthread);        /* 64 bit thread identifier */
2419   *pkt = '\0';
2420   return pkt;
2421 }
2422
2423 /* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2424
2425 static int
2426 parse_threadlist_response (char *pkt, int result_limit,
2427                            threadref *original_echo, threadref *resultlist,
2428                            int *doneflag)
2429 {
2430   struct remote_state *rs = get_remote_state ();
2431   char *limit;
2432   int count, resultcount, done;
2433
2434   resultcount = 0;
2435   /* Assume the 'q' and 'M chars have been stripped.  */
2436   limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
2437   /* done parse past here */
2438   pkt = unpack_byte (pkt, &count);      /* count field */
2439   pkt = unpack_nibble (pkt, &done);
2440   /* The first threadid is the argument threadid.  */
2441   pkt = unpack_threadid (pkt, original_echo);   /* should match query packet */
2442   while ((count-- > 0) && (pkt < limit))
2443     {
2444       pkt = unpack_threadid (pkt, resultlist++);
2445       if (resultcount++ >= result_limit)
2446         break;
2447     }
2448   if (doneflag)
2449     *doneflag = done;
2450   return resultcount;
2451 }
2452
2453 static int
2454 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
2455                        int *done, int *result_count, threadref *threadlist)
2456 {
2457   struct remote_state *rs = get_remote_state ();
2458   static threadref echo_nextthread;
2459   int result = 1;
2460
2461   /* Trancate result limit to be smaller than the packet size.  */
2462   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
2463       >= get_remote_packet_size ())
2464     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
2465
2466   pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
2467   putpkt (rs->buf);
2468   getpkt (&rs->buf, &rs->buf_size, 0);
2469
2470   if (*rs->buf == '\0')
2471     return 0;
2472   else
2473     *result_count =
2474       parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
2475                                  threadlist, done);
2476
2477   if (!threadmatch (&echo_nextthread, nextthread))
2478     {
2479       /* FIXME: This is a good reason to drop the packet.  */
2480       /* Possably, there is a duplicate response.  */
2481       /* Possabilities :
2482          retransmit immediatly - race conditions
2483          retransmit after timeout - yes
2484          exit
2485          wait for packet, then exit
2486        */
2487       warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2488       return 0;                 /* I choose simply exiting.  */
2489     }
2490   if (*result_count <= 0)
2491     {
2492       if (*done != 1)
2493         {
2494           warning (_("RMT ERROR : failed to get remote thread list."));
2495           result = 0;
2496         }
2497       return result;            /* break; */
2498     }
2499   if (*result_count > result_limit)
2500     {
2501       *result_count = 0;
2502       warning (_("RMT ERROR: threadlist response longer than requested."));
2503       return 0;
2504     }
2505   return result;
2506 }
2507
2508 /* This is the interface between remote and threads, remotes upper
2509    interface.  */
2510
2511 /* remote_find_new_threads retrieves the thread list and for each
2512    thread in the list, looks up the thread in GDB's internal list,
2513    adding the thread if it does not already exist.  This involves
2514    getting partial thread lists from the remote target so, polling the
2515    quit_flag is required.  */
2516
2517
2518 /* About this many threadisds fit in a packet.  */
2519
2520 #define MAXTHREADLISTRESULTS 32
2521
2522 static int
2523 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
2524                             int looplimit)
2525 {
2526   int done, i, result_count;
2527   int startflag = 1;
2528   int result = 1;
2529   int loopcount = 0;
2530   static threadref nextthread;
2531   static threadref resultthreadlist[MAXTHREADLISTRESULTS];
2532
2533   done = 0;
2534   while (!done)
2535     {
2536       if (loopcount++ > looplimit)
2537         {
2538           result = 0;
2539           warning (_("Remote fetch threadlist -infinite loop-."));
2540           break;
2541         }
2542       if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
2543                                   &done, &result_count, resultthreadlist))
2544         {
2545           result = 0;
2546           break;
2547         }
2548       /* Clear for later iterations.  */
2549       startflag = 0;
2550       /* Setup to resume next batch of thread references, set nextthread.  */
2551       if (result_count >= 1)
2552         copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
2553       i = 0;
2554       while (result_count--)
2555         if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
2556           break;
2557     }
2558   return result;
2559 }
2560
2561 static int
2562 remote_newthread_step (threadref *ref, void *context)
2563 {
2564   int pid = ptid_get_pid (inferior_ptid);
2565   ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref));
2566
2567   if (!in_thread_list (ptid))
2568     add_thread (ptid);
2569   return 1;                     /* continue iterator */
2570 }
2571
2572 #define CRAZY_MAX_THREADS 1000
2573
2574 static ptid_t
2575 remote_current_thread (ptid_t oldpid)
2576 {
2577   struct remote_state *rs = get_remote_state ();
2578
2579   putpkt ("qC");
2580   getpkt (&rs->buf, &rs->buf_size, 0);
2581   if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
2582     return read_ptid (&rs->buf[2], NULL);
2583   else
2584     return oldpid;
2585 }
2586
2587 /* Find new threads for info threads command.
2588  * Original version, using John Metzler's thread protocol.
2589  */
2590
2591 static void
2592 remote_find_new_threads (void)
2593 {
2594   remote_threadlist_iterator (remote_newthread_step, 0,
2595                               CRAZY_MAX_THREADS);
2596 }
2597
2598 #if defined(HAVE_LIBEXPAT)
2599
2600 typedef struct thread_item
2601 {
2602   ptid_t ptid;
2603   char *extra;
2604   int core;
2605 } thread_item_t;
2606 DEF_VEC_O(thread_item_t);
2607
2608 struct threads_parsing_context
2609 {
2610   VEC (thread_item_t) *items;
2611 };
2612
2613 static void
2614 start_thread (struct gdb_xml_parser *parser,
2615               const struct gdb_xml_element *element,
2616               void *user_data, VEC(gdb_xml_value_s) *attributes)
2617 {
2618   struct threads_parsing_context *data = user_data;
2619
2620   struct thread_item item;
2621   char *id;
2622   struct gdb_xml_value *attr;
2623
2624   id = xml_find_attribute (attributes, "id")->value;
2625   item.ptid = read_ptid (id, NULL);
2626
2627   attr = xml_find_attribute (attributes, "core");
2628   if (attr != NULL)
2629     item.core = *(ULONGEST *) attr->value;
2630   else
2631     item.core = -1;
2632
2633   item.extra = 0;
2634
2635   VEC_safe_push (thread_item_t, data->items, &item);
2636 }
2637
2638 static void
2639 end_thread (struct gdb_xml_parser *parser,
2640             const struct gdb_xml_element *element,
2641             void *user_data, const char *body_text)
2642 {
2643   struct threads_parsing_context *data = user_data;
2644
2645   if (body_text && *body_text)
2646     VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text);
2647 }
2648
2649 const struct gdb_xml_attribute thread_attributes[] = {
2650   { "id", GDB_XML_AF_NONE, NULL, NULL },
2651   { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2652   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2653 };
2654
2655 const struct gdb_xml_element thread_children[] = {
2656   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2657 };
2658
2659 const struct gdb_xml_element threads_children[] = {
2660   { "thread", thread_attributes, thread_children,
2661     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
2662     start_thread, end_thread },
2663   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2664 };
2665
2666 const struct gdb_xml_element threads_elements[] = {
2667   { "threads", NULL, threads_children,
2668     GDB_XML_EF_NONE, NULL, NULL },
2669   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2670 };
2671
2672 /* Discard the contents of the constructed thread info context.  */
2673
2674 static void
2675 clear_threads_parsing_context (void *p)
2676 {
2677   struct threads_parsing_context *context = p;
2678   int i;
2679   struct thread_item *item;
2680
2681   for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
2682     xfree (item->extra);
2683
2684   VEC_free (thread_item_t, context->items);
2685 }
2686
2687 #endif
2688
2689 /*
2690  * Find all threads for info threads command.
2691  * Uses new thread protocol contributed by Cisco.
2692  * Falls back and attempts to use the older method (above)
2693  * if the target doesn't respond to the new method.
2694  */
2695
2696 static void
2697 remote_threads_info (struct target_ops *ops)
2698 {
2699   struct remote_state *rs = get_remote_state ();
2700   char *bufp;
2701   ptid_t new_thread;
2702
2703   if (remote_desc == 0)         /* paranoia */
2704     error (_("Command can only be used when connected to the remote target."));
2705
2706 #if defined(HAVE_LIBEXPAT)
2707   if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2708     {
2709       char *xml = target_read_stralloc (&current_target,
2710                                          TARGET_OBJECT_THREADS, NULL);
2711
2712       struct cleanup *back_to = make_cleanup (xfree, xml);
2713
2714       if (xml && *xml)
2715         {
2716           struct threads_parsing_context context;
2717
2718           context.items = NULL;
2719           make_cleanup (clear_threads_parsing_context, &context);
2720
2721           if (gdb_xml_parse_quick (_("threads"), "threads.dtd",
2722                                    threads_elements, xml, &context) == 0)
2723             {
2724               int i;
2725               struct thread_item *item;
2726
2727               for (i = 0;
2728                    VEC_iterate (thread_item_t, context.items, i, item);
2729                    ++i)
2730                 {
2731                   if (!ptid_equal (item->ptid, null_ptid))
2732                     {
2733                       struct private_thread_info *info;
2734                       /* In non-stop mode, we assume new found threads
2735                          are running until proven otherwise with a
2736                          stop reply.  In all-stop, we can only get
2737                          here if all threads are stopped.  */
2738                       int running = non_stop ? 1 : 0;
2739
2740                       remote_notice_new_inferior (item->ptid, running);
2741
2742                       info = demand_private_info (item->ptid);
2743                       info->core = item->core;
2744                       info->extra = item->extra;
2745                       item->extra = NULL;
2746                     }
2747                 }
2748             }
2749         }
2750
2751       do_cleanups (back_to);
2752       return;
2753     }
2754 #endif
2755
2756   if (use_threadinfo_query)
2757     {
2758       putpkt ("qfThreadInfo");
2759       getpkt (&rs->buf, &rs->buf_size, 0);
2760       bufp = rs->buf;
2761       if (bufp[0] != '\0')              /* q packet recognized */
2762         {
2763           struct cleanup *old_chain;
2764           char *saved_reply;
2765
2766           /* remote_notice_new_inferior (in the loop below) may make
2767              new RSP calls, which clobber rs->buf.  Work with a
2768              copy.  */
2769           bufp = saved_reply = xstrdup (rs->buf);
2770           old_chain = make_cleanup (free_current_contents, &saved_reply);
2771
2772           while (*bufp++ == 'm')        /* reply contains one or more TID */
2773             {
2774               do
2775                 {
2776                   new_thread = read_ptid (bufp, &bufp);
2777                   if (!ptid_equal (new_thread, null_ptid))
2778                     {
2779                       /* In non-stop mode, we assume new found threads
2780                          are running until proven otherwise with a
2781                          stop reply.  In all-stop, we can only get
2782                          here if all threads are stopped.  */
2783                       int running = non_stop ? 1 : 0;
2784
2785                       remote_notice_new_inferior (new_thread, running);
2786                     }
2787                 }
2788               while (*bufp++ == ',');   /* comma-separated list */
2789               free_current_contents (&saved_reply);
2790               putpkt ("qsThreadInfo");
2791               getpkt (&rs->buf, &rs->buf_size, 0);
2792               bufp = saved_reply = xstrdup (rs->buf);
2793             }
2794           do_cleanups (old_chain);
2795           return;       /* done */
2796         }
2797     }
2798
2799   /* Only qfThreadInfo is supported in non-stop mode.  */
2800   if (non_stop)
2801     return;
2802
2803   /* Else fall back to old method based on jmetzler protocol.  */
2804   use_threadinfo_query = 0;
2805   remote_find_new_threads ();
2806   return;
2807 }
2808
2809 /*
2810  * Collect a descriptive string about the given thread.
2811  * The target may say anything it wants to about the thread
2812  * (typically info about its blocked / runnable state, name, etc.).
2813  * This string will appear in the info threads display.
2814  *
2815  * Optional: targets are not required to implement this function.
2816  */
2817
2818 static char *
2819 remote_threads_extra_info (struct thread_info *tp)
2820 {
2821   struct remote_state *rs = get_remote_state ();
2822   int result;
2823   int set;
2824   threadref id;
2825   struct gdb_ext_thread_info threadinfo;
2826   static char display_buf[100]; /* arbitrary...  */
2827   int n = 0;                    /* position in display_buf */
2828
2829   if (remote_desc == 0)         /* paranoia */
2830     internal_error (__FILE__, __LINE__,
2831                     _("remote_threads_extra_info"));
2832
2833   if (ptid_equal (tp->ptid, magic_null_ptid)
2834       || (ptid_get_pid (tp->ptid) != 0 && ptid_get_tid (tp->ptid) == 0))
2835     /* This is the main thread which was added by GDB.  The remote
2836        server doesn't know about it.  */
2837     return NULL;
2838
2839   if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2840     {
2841       struct thread_info *info = find_thread_ptid (tp->ptid);
2842
2843       if (info && info->private)
2844         return info->private->extra;
2845       else
2846         return NULL;
2847     }
2848
2849   if (use_threadextra_query)
2850     {
2851       char *b = rs->buf;
2852       char *endb = rs->buf + get_remote_packet_size ();
2853
2854       xsnprintf (b, endb - b, "qThreadExtraInfo,");
2855       b += strlen (b);
2856       write_ptid (b, endb, tp->ptid);
2857
2858       putpkt (rs->buf);
2859       getpkt (&rs->buf, &rs->buf_size, 0);
2860       if (rs->buf[0] != 0)
2861         {
2862           n = min (strlen (rs->buf) / 2, sizeof (display_buf));
2863           result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
2864           display_buf [result] = '\0';
2865           return display_buf;
2866         }
2867     }
2868
2869   /* If the above query fails, fall back to the old method.  */
2870   use_threadextra_query = 0;
2871   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
2872     | TAG_MOREDISPLAY | TAG_DISPLAY;
2873   int_to_threadref (&id, ptid_get_tid (tp->ptid));
2874   if (remote_get_threadinfo (&id, set, &threadinfo))
2875     if (threadinfo.active)
2876       {
2877         if (*threadinfo.shortname)
2878           n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
2879                           " Name: %s,", threadinfo.shortname);
2880         if (*threadinfo.display)
2881           n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2882                           " State: %s,", threadinfo.display);
2883         if (*threadinfo.more_display)
2884           n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2885                           " Priority: %s", threadinfo.more_display);
2886
2887         if (n > 0)
2888           {
2889             /* For purely cosmetic reasons, clear up trailing commas.  */
2890             if (',' == display_buf[n-1])
2891               display_buf[n-1] = ' ';
2892             return display_buf;
2893           }
2894       }
2895   return NULL;
2896 }
2897 \f
2898
2899 static int
2900 remote_static_tracepoint_marker_at (CORE_ADDR addr,
2901                                     struct static_tracepoint_marker *marker)
2902 {
2903   struct remote_state *rs = get_remote_state ();
2904   char *p = rs->buf;
2905
2906   xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
2907   p += strlen (p);
2908   p += hexnumstr (p, addr);
2909   putpkt (rs->buf);
2910   getpkt (&rs->buf, &rs->buf_size, 0);
2911   p = rs->buf;
2912
2913   if (*p == 'E')
2914     error (_("Remote failure reply: %s"), p);
2915
2916   if (*p++ == 'm')
2917     {
2918       parse_static_tracepoint_marker_definition (p, &p, marker);
2919       return 1;
2920     }
2921
2922   return 0;
2923 }
2924
2925 static VEC(static_tracepoint_marker_p) *
2926 remote_static_tracepoint_markers_by_strid (const char *strid)
2927 {
2928   struct remote_state *rs = get_remote_state ();
2929   VEC(static_tracepoint_marker_p) *markers = NULL;
2930   struct static_tracepoint_marker *marker = NULL;
2931   struct cleanup *old_chain;
2932   char *p;
2933
2934   /* Ask for a first packet of static tracepoint marker
2935      definition.  */
2936   putpkt ("qTfSTM");
2937   getpkt (&rs->buf, &rs->buf_size, 0);
2938   p = rs->buf;
2939   if (*p == 'E')
2940     error (_("Remote failure reply: %s"), p);
2941
2942   old_chain = make_cleanup (free_current_marker, &marker);
2943
2944   while (*p++ == 'm')
2945     {
2946       if (marker == NULL)
2947         marker = XCNEW (struct static_tracepoint_marker);
2948
2949       do
2950         {
2951           parse_static_tracepoint_marker_definition (p, &p, marker);
2952
2953           if (strid == NULL || strcmp (strid, marker->str_id) == 0)
2954             {
2955               VEC_safe_push (static_tracepoint_marker_p,
2956                              markers, marker);
2957               marker = NULL;
2958             }
2959           else
2960             {
2961               release_static_tracepoint_marker (marker);
2962               memset (marker, 0, sizeof (*marker));
2963             }
2964         }
2965       while (*p++ == ',');      /* comma-separated list */
2966       /* Ask for another packet of static tracepoint definition.  */
2967       putpkt ("qTsSTM");
2968       getpkt (&rs->buf, &rs->buf_size, 0);
2969       p = rs->buf;
2970     }
2971
2972   do_cleanups (old_chain);
2973   return markers;
2974 }
2975
2976 \f
2977 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
2978
2979 static ptid_t
2980 remote_get_ada_task_ptid (long lwp, long thread)
2981 {
2982   return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
2983 }
2984 \f
2985
2986 /* Restart the remote side; this is an extended protocol operation.  */
2987
2988 static void
2989 extended_remote_restart (void)
2990 {
2991   struct remote_state *rs = get_remote_state ();
2992
2993   /* Send the restart command; for reasons I don't understand the
2994      remote side really expects a number after the "R".  */
2995   xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
2996   putpkt (rs->buf);
2997
2998   remote_fileio_reset ();
2999 }
3000 \f
3001 /* Clean up connection to a remote debugger.  */
3002
3003 static void
3004 remote_close (int quitting)
3005 {
3006   if (remote_desc == NULL)
3007     return; /* already closed */
3008
3009   /* Make sure we leave stdin registered in the event loop, and we
3010      don't leave the async SIGINT signal handler installed.  */
3011   remote_terminal_ours ();
3012
3013   serial_close (remote_desc);
3014   remote_desc = NULL;
3015
3016   /* We don't have a connection to the remote stub anymore.  Get rid
3017      of all the inferiors and their threads we were controlling.
3018      Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3019      will be unable to find the thread corresponding to (pid, 0, 0).  */
3020   inferior_ptid = null_ptid;
3021   discard_all_inferiors ();
3022
3023   /* Stop replies may from inferiors which are still unknown to GDB.
3024      We are closing the remote target, so we should discard
3025      everything, including the stop replies from GDB-unknown
3026      inferiors.  */
3027   discard_pending_stop_replies (NULL);
3028
3029   if (remote_async_inferior_event_token)
3030     delete_async_event_handler (&remote_async_inferior_event_token);
3031
3032   remote_notif_unregister_async_event_handler ();
3033 }
3034
3035 /* Query the remote side for the text, data and bss offsets.  */
3036
3037 static void
3038 get_offsets (void)
3039 {
3040   struct remote_state *rs = get_remote_state ();
3041   char *buf;
3042   char *ptr;
3043   int lose, num_segments = 0, do_sections, do_segments;
3044   CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
3045   struct section_offsets *offs;
3046   struct symfile_segment_data *data;
3047
3048   if (symfile_objfile == NULL)
3049     return;
3050
3051   putpkt ("qOffsets");
3052   getpkt (&rs->buf, &rs->buf_size, 0);
3053   buf = rs->buf;
3054
3055   if (buf[0] == '\000')
3056     return;                     /* Return silently.  Stub doesn't support
3057                                    this command.  */
3058   if (buf[0] == 'E')
3059     {
3060       warning (_("Remote failure reply: %s"), buf);
3061       return;
3062     }
3063
3064   /* Pick up each field in turn.  This used to be done with scanf, but
3065      scanf will make trouble if CORE_ADDR size doesn't match
3066      conversion directives correctly.  The following code will work
3067      with any size of CORE_ADDR.  */
3068   text_addr = data_addr = bss_addr = 0;
3069   ptr = buf;
3070   lose = 0;
3071
3072   if (strncmp (ptr, "Text=", 5) == 0)
3073     {
3074       ptr += 5;
3075       /* Don't use strtol, could lose on big values.  */
3076       while (*ptr && *ptr != ';')
3077         text_addr = (text_addr << 4) + fromhex (*ptr++);
3078
3079       if (strncmp (ptr, ";Data=", 6) == 0)
3080         {
3081           ptr += 6;
3082           while (*ptr && *ptr != ';')
3083             data_addr = (data_addr << 4) + fromhex (*ptr++);
3084         }
3085       else
3086         lose = 1;
3087
3088       if (!lose && strncmp (ptr, ";Bss=", 5) == 0)
3089         {
3090           ptr += 5;
3091           while (*ptr && *ptr != ';')
3092             bss_addr = (bss_addr << 4) + fromhex (*ptr++);
3093
3094           if (bss_addr != data_addr)
3095             warning (_("Target reported unsupported offsets: %s"), buf);
3096         }
3097       else
3098         lose = 1;
3099     }
3100   else if (strncmp (ptr, "TextSeg=", 8) == 0)
3101     {
3102       ptr += 8;
3103       /* Don't use strtol, could lose on big values.  */
3104       while (*ptr && *ptr != ';')
3105         text_addr = (text_addr << 4) + fromhex (*ptr++);
3106       num_segments = 1;
3107
3108       if (strncmp (ptr, ";DataSeg=", 9) == 0)
3109         {
3110           ptr += 9;
3111           while (*ptr && *ptr != ';')
3112             data_addr = (data_addr << 4) + fromhex (*ptr++);
3113           num_segments++;
3114         }
3115     }
3116   else
3117     lose = 1;
3118
3119   if (lose)
3120     error (_("Malformed response to offset query, %s"), buf);
3121   else if (*ptr != '\0')
3122     warning (_("Target reported unsupported offsets: %s"), buf);
3123
3124   offs = ((struct section_offsets *)
3125           alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
3126   memcpy (offs, symfile_objfile->section_offsets,
3127           SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
3128
3129   data = get_symfile_segment_data (symfile_objfile->obfd);
3130   do_segments = (data != NULL);
3131   do_sections = num_segments == 0;
3132
3133   if (num_segments > 0)
3134     {
3135       segments[0] = text_addr;
3136       segments[1] = data_addr;
3137     }
3138   /* If we have two segments, we can still try to relocate everything
3139      by assuming that the .text and .data offsets apply to the whole
3140      text and data segments.  Convert the offsets given in the packet
3141      to base addresses for symfile_map_offsets_to_segments.  */
3142   else if (data && data->num_segments == 2)
3143     {
3144       segments[0] = data->segment_bases[0] + text_addr;
3145       segments[1] = data->segment_bases[1] + data_addr;
3146       num_segments = 2;
3147     }
3148   /* If the object file has only one segment, assume that it is text
3149      rather than data; main programs with no writable data are rare,
3150      but programs with no code are useless.  Of course the code might
3151      have ended up in the data segment... to detect that we would need
3152      the permissions here.  */
3153   else if (data && data->num_segments == 1)
3154     {
3155       segments[0] = data->segment_bases[0] + text_addr;
3156       num_segments = 1;
3157     }
3158   /* There's no way to relocate by segment.  */
3159   else
3160     do_segments = 0;
3161
3162   if (do_segments)
3163     {
3164       int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
3165                                                  offs, num_segments, segments);
3166
3167       if (ret == 0 && !do_sections)
3168         error (_("Can not handle qOffsets TextSeg "
3169                  "response with this symbol file"));
3170
3171       if (ret > 0)
3172         do_sections = 0;
3173     }
3174
3175   if (data)
3176     free_symfile_segment_data (data);
3177
3178   if (do_sections)
3179     {
3180       offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
3181
3182       /* This is a temporary kludge to force data and bss to use the
3183          same offsets because that's what nlmconv does now.  The real
3184          solution requires changes to the stub and remote.c that I
3185          don't have time to do right now.  */
3186
3187       offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
3188       offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
3189     }
3190
3191   objfile_relocate (symfile_objfile, offs);
3192 }
3193
3194 /* Callback for iterate_over_threads.  Set the STOP_REQUESTED flags in
3195    threads we know are stopped already.  This is used during the
3196    initial remote connection in non-stop mode --- threads that are
3197    reported as already being stopped are left stopped.  */
3198
3199 static int
3200 set_stop_requested_callback (struct thread_info *thread, void *data)
3201 {
3202   /* If we have a stop reply for this thread, it must be stopped.  */
3203   if (peek_stop_reply (thread->ptid))
3204     set_stop_requested (thread->ptid, 1);
3205
3206   return 0;
3207 }
3208
3209 /* Send interrupt_sequence to remote target.  */
3210 static void
3211 send_interrupt_sequence (void)
3212 {
3213   if (interrupt_sequence_mode == interrupt_sequence_control_c)
3214     remote_serial_write ("\x03", 1);
3215   else if (interrupt_sequence_mode == interrupt_sequence_break)
3216     serial_send_break (remote_desc);
3217   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
3218     {
3219       serial_send_break (remote_desc);
3220       remote_serial_write ("g", 1);
3221     }
3222   else
3223     internal_error (__FILE__, __LINE__,
3224                     _("Invalid value for interrupt_sequence_mode: %s."),
3225                     interrupt_sequence_mode);
3226 }
3227
3228
3229 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3230    and extract the PTID.  Returns NULL_PTID if not found.  */
3231
3232 static ptid_t
3233 stop_reply_extract_thread (char *stop_reply)
3234 {
3235   if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
3236     {
3237       char *p;
3238
3239       /* Txx r:val ; r:val (...)  */
3240       p = &stop_reply[3];
3241
3242       /* Look for "register" named "thread".  */
3243       while (*p != '\0')
3244         {
3245           char *p1;
3246
3247           p1 = strchr (p, ':');
3248           if (p1 == NULL)
3249             return null_ptid;
3250
3251           if (strncmp (p, "thread", p1 - p) == 0)
3252             return read_ptid (++p1, &p);
3253
3254           p1 = strchr (p, ';');
3255           if (p1 == NULL)
3256             return null_ptid;
3257           p1++;
3258
3259           p = p1;
3260         }
3261     }
3262
3263   return null_ptid;
3264 }
3265
3266 /* Query the remote target for which is the current thread/process,
3267    add it to our tables, and update INFERIOR_PTID.  The caller is
3268    responsible for setting the state such that the remote end is ready
3269    to return the current thread.
3270
3271    This function is called after handling the '?' or 'vRun' packets,
3272    whose response is a stop reply from which we can also try
3273    extracting the thread.  If the target doesn't support the explicit
3274    qC query, we infer the current thread from that stop reply, passed
3275    in in WAIT_STATUS, which may be NULL.  */
3276
3277 static void
3278 add_current_inferior_and_thread (char *wait_status)
3279 {
3280   struct remote_state *rs = get_remote_state ();
3281   int fake_pid_p = 0;
3282   ptid_t ptid = null_ptid;
3283
3284   inferior_ptid = null_ptid;
3285
3286   /* Now, if we have thread information, update inferior_ptid.  First
3287      if we have a stop reply handy, maybe it's a T stop reply with a
3288      "thread" register we can extract the current thread from.  If
3289      not, ask the remote which is the current thread, with qC.  The
3290      former method avoids a roundtrip.  Note we don't use
3291      remote_parse_stop_reply as that makes use of the target
3292      architecture, which we haven't yet fully determined at this
3293      point.  */
3294   if (wait_status != NULL)
3295     ptid = stop_reply_extract_thread (wait_status);
3296   if (ptid_equal (ptid, null_ptid))
3297     ptid = remote_current_thread (inferior_ptid);
3298
3299   if (!ptid_equal (ptid, null_ptid))
3300     {
3301       if (!remote_multi_process_p (rs))
3302         fake_pid_p = 1;
3303
3304       inferior_ptid = ptid;
3305     }
3306   else
3307     {
3308       /* Without this, some commands which require an active target
3309          (such as kill) won't work.  This variable serves (at least)
3310          double duty as both the pid of the target process (if it has
3311          such), and as a flag indicating that a target is active.  */
3312       inferior_ptid = magic_null_ptid;
3313       fake_pid_p = 1;
3314     }
3315
3316   remote_add_inferior (fake_pid_p, ptid_get_pid (inferior_ptid), -1);
3317
3318   /* Add the main thread.  */
3319   add_thread_silent (inferior_ptid);
3320 }
3321
3322 static void
3323 remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
3324 {
3325   struct remote_state *rs = get_remote_state ();
3326   struct packet_config *noack_config;
3327   char *wait_status = NULL;
3328
3329   immediate_quit++;             /* Allow user to interrupt it.  */
3330   QUIT;
3331
3332   if (interrupt_on_connect)
3333     send_interrupt_sequence ();
3334
3335   /* Ack any packet which the remote side has already sent.  */
3336   serial_write (remote_desc, "+", 1);
3337
3338   /* Signal other parts that we're going through the initial setup,
3339      and so things may not be stable yet.  */
3340   rs->starting_up = 1;
3341
3342   /* The first packet we send to the target is the optional "supported
3343      packets" request.  If the target can answer this, it will tell us
3344      which later probes to skip.  */
3345   remote_query_supported ();
3346
3347   /* If the stub wants to get a QAllow, compose one and send it.  */
3348   if (remote_protocol_packets[PACKET_QAllow].support != PACKET_DISABLE)
3349     remote_set_permissions ();
3350
3351   /* Next, we possibly activate noack mode.
3352
3353      If the QStartNoAckMode packet configuration is set to AUTO,
3354      enable noack mode if the stub reported a wish for it with
3355      qSupported.
3356
3357      If set to TRUE, then enable noack mode even if the stub didn't
3358      report it in qSupported.  If the stub doesn't reply OK, the
3359      session ends with an error.
3360
3361      If FALSE, then don't activate noack mode, regardless of what the
3362      stub claimed should be the default with qSupported.  */
3363
3364   noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
3365
3366   if (noack_config->detect == AUTO_BOOLEAN_TRUE
3367       || (noack_config->detect == AUTO_BOOLEAN_AUTO
3368           && noack_config->support == PACKET_ENABLE))
3369     {
3370       putpkt ("QStartNoAckMode");
3371       getpkt (&rs->buf, &rs->buf_size, 0);
3372       if (packet_ok (rs->buf, noack_config) == PACKET_OK)
3373         rs->noack_mode = 1;
3374     }
3375
3376   if (extended_p)
3377     {
3378       /* Tell the remote that we are using the extended protocol.  */
3379       putpkt ("!");
3380       getpkt (&rs->buf, &rs->buf_size, 0);
3381     }
3382
3383   /* Let the target know which signals it is allowed to pass down to
3384      the program.  */
3385   update_signals_program_target ();
3386
3387   /* Next, if the target can specify a description, read it.  We do
3388      this before anything involving memory or registers.  */
3389   target_find_description ();
3390
3391   /* Next, now that we know something about the target, update the
3392      address spaces in the program spaces.  */
3393   update_address_spaces ();
3394
3395   /* On OSs where the list of libraries is global to all
3396      processes, we fetch them early.  */
3397   if (gdbarch_has_global_solist (target_gdbarch ()))
3398     solib_add (NULL, from_tty, target, auto_solib_add);
3399
3400   if (non_stop)
3401     {
3402       if (!rs->non_stop_aware)
3403         error (_("Non-stop mode requested, but remote "
3404                  "does not support non-stop"));
3405
3406       putpkt ("QNonStop:1");
3407       getpkt (&rs->buf, &rs->buf_size, 0);
3408
3409       if (strcmp (rs->buf, "OK") != 0)
3410         error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
3411
3412       /* Find about threads and processes the stub is already
3413          controlling.  We default to adding them in the running state.
3414          The '?' query below will then tell us about which threads are
3415          stopped.  */
3416       remote_threads_info (target);
3417     }
3418   else if (rs->non_stop_aware)
3419     {
3420       /* Don't assume that the stub can operate in all-stop mode.
3421          Request it explicitly.  */
3422       putpkt ("QNonStop:0");
3423       getpkt (&rs->buf, &rs->buf_size, 0);
3424
3425       if (strcmp (rs->buf, "OK") != 0)
3426         error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
3427     }
3428
3429   /* Check whether the target is running now.  */
3430   putpkt ("?");
3431   getpkt (&rs->buf, &rs->buf_size, 0);
3432
3433   if (!non_stop)
3434     {
3435       ptid_t ptid;
3436       int fake_pid_p = 0;
3437       struct inferior *inf;
3438
3439       if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
3440         {
3441           if (!extended_p)
3442             error (_("The target is not running (try extended-remote?)"));
3443
3444           /* We're connected, but not running.  Drop out before we
3445              call start_remote.  */
3446           rs->starting_up = 0;
3447           return;
3448         }
3449       else
3450         {
3451           /* Save the reply for later.  */
3452           wait_status = alloca (strlen (rs->buf) + 1);
3453           strcpy (wait_status, rs->buf);
3454         }
3455
3456       /* Let the stub know that we want it to return the thread.  */
3457       set_continue_thread (minus_one_ptid);
3458
3459       add_current_inferior_and_thread (wait_status);
3460
3461       /* init_wait_for_inferior should be called before get_offsets in order
3462          to manage `inserted' flag in bp loc in a correct state.
3463          breakpoint_init_inferior, called from init_wait_for_inferior, set
3464          `inserted' flag to 0, while before breakpoint_re_set, called from
3465          start_remote, set `inserted' flag to 1.  In the initialization of
3466          inferior, breakpoint_init_inferior should be called first, and then
3467          breakpoint_re_set can be called.  If this order is broken, state of
3468          `inserted' flag is wrong, and cause some problems on breakpoint
3469          manipulation.  */
3470       init_wait_for_inferior ();
3471
3472       get_offsets ();           /* Get text, data & bss offsets.  */
3473
3474       /* If we could not find a description using qXfer, and we know
3475          how to do it some other way, try again.  This is not
3476          supported for non-stop; it could be, but it is tricky if
3477          there are no stopped threads when we connect.  */
3478       if (remote_read_description_p (target)
3479           && gdbarch_target_desc (target_gdbarch ()) == NULL)
3480         {
3481           target_clear_description ();
3482           target_find_description ();
3483         }
3484
3485       /* Use the previously fetched status.  */
3486       gdb_assert (wait_status != NULL);
3487       strcpy (rs->buf, wait_status);
3488       rs->cached_wait_status = 1;
3489
3490       immediate_quit--;
3491       start_remote (from_tty); /* Initialize gdb process mechanisms.  */
3492     }
3493   else
3494     {
3495       /* Clear WFI global state.  Do this before finding about new
3496          threads and inferiors, and setting the current inferior.
3497          Otherwise we would clear the proceed status of the current
3498          inferior when we want its stop_soon state to be preserved
3499          (see notice_new_inferior).  */
3500       init_wait_for_inferior ();
3501
3502       /* In non-stop, we will either get an "OK", meaning that there
3503          are no stopped threads at this time; or, a regular stop
3504          reply.  In the latter case, there may be more than one thread
3505          stopped --- we pull them all out using the vStopped
3506          mechanism.  */
3507       if (strcmp (rs->buf, "OK") != 0)
3508         {
3509           struct notif_client *notif = &notif_client_stop;
3510
3511           /* remote_notif_get_pending_replies acks this one, and gets
3512              the rest out.  */
3513           notif_client_stop.pending_event
3514             = remote_notif_parse (notif, rs->buf);
3515           remote_notif_get_pending_events (notif);
3516
3517           /* Make sure that threads that were stopped remain
3518              stopped.  */
3519           iterate_over_threads (set_stop_requested_callback, NULL);
3520         }
3521
3522       if (target_can_async_p ())
3523         target_async (inferior_event_handler, 0);
3524
3525       if (thread_count () == 0)
3526         {
3527           if (!extended_p)
3528             error (_("The target is not running (try extended-remote?)"));
3529
3530           /* We're connected, but not running.  Drop out before we
3531              call start_remote.  */
3532           rs->starting_up = 0;
3533           return;
3534         }
3535
3536       /* Let the stub know that we want it to return the thread.  */
3537
3538       /* Force the stub to choose a thread.  */
3539       set_general_thread (null_ptid);
3540
3541       /* Query it.  */
3542       inferior_ptid = remote_current_thread (minus_one_ptid);
3543       if (ptid_equal (inferior_ptid, minus_one_ptid))
3544         error (_("remote didn't report the current thread in non-stop mode"));
3545
3546       get_offsets ();           /* Get text, data & bss offsets.  */
3547
3548       /* In non-stop mode, any cached wait status will be stored in
3549          the stop reply queue.  */
3550       gdb_assert (wait_status == NULL);
3551
3552       /* Report all signals during attach/startup.  */
3553       remote_pass_signals (0, NULL);
3554     }
3555
3556   /* If we connected to a live target, do some additional setup.  */
3557   if (target_has_execution)
3558     {
3559       if (exec_bfd)     /* No use without an exec file.  */
3560         remote_check_symbols (symfile_objfile);
3561     }
3562
3563   /* Possibly the target has been engaged in a trace run started
3564      previously; find out where things are at.  */
3565   if (remote_get_trace_status (current_trace_status ()) != -1)
3566     {
3567       struct uploaded_tp *uploaded_tps = NULL;
3568       struct uploaded_tsv *uploaded_tsvs = NULL;
3569
3570       if (current_trace_status ()->running)
3571         printf_filtered (_("Trace is already running on the target.\n"));
3572
3573       /* Get trace state variables first, they may be checked when
3574          parsing uploaded commands.  */
3575
3576       remote_upload_trace_state_variables (&uploaded_tsvs);
3577
3578       merge_uploaded_trace_state_variables (&uploaded_tsvs);
3579
3580       remote_upload_tracepoints (&uploaded_tps);
3581
3582       merge_uploaded_tracepoints (&uploaded_tps);
3583     }
3584
3585   /* The thread and inferior lists are now synchronized with the
3586      target, our symbols have been relocated, and we're merged the
3587      target's tracepoints with ours.  We're done with basic start
3588      up.  */
3589   rs->starting_up = 0;
3590
3591   /* If breakpoints are global, insert them now.  */
3592   if (gdbarch_has_global_breakpoints (target_gdbarch ())
3593       && breakpoints_always_inserted_mode ())
3594     insert_breakpoints ();
3595 }
3596
3597 /* Open a connection to a remote debugger.
3598    NAME is the filename used for communication.  */
3599
3600 static void
3601 remote_open (char *name, int from_tty)
3602 {
3603   remote_open_1 (name, from_tty, &remote_ops, 0);
3604 }
3605
3606 /* Open a connection to a remote debugger using the extended
3607    remote gdb protocol.  NAME is the filename used for communication.  */
3608
3609 static void
3610 extended_remote_open (char *name, int from_tty)
3611 {
3612   remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
3613 }
3614
3615 /* Generic code for opening a connection to a remote target.  */
3616
3617 static void
3618 init_all_packet_configs (void)
3619 {
3620   int i;
3621
3622   for (i = 0; i < PACKET_MAX; i++)
3623     update_packet_config (&remote_protocol_packets[i]);
3624 }
3625
3626 /* Symbol look-up.  */
3627
3628 static void
3629 remote_check_symbols (struct objfile *objfile)
3630 {
3631   struct remote_state *rs = get_remote_state ();
3632   char *msg, *reply, *tmp;
3633   struct minimal_symbol *sym;
3634   int end;
3635
3636   /* The remote side has no concept of inferiors that aren't running
3637      yet, it only knows about running processes.  If we're connected
3638      but our current inferior is not running, we should not invite the
3639      remote target to request symbol lookups related to its
3640      (unrelated) current process.  */
3641   if (!target_has_execution)
3642     return;
3643
3644   if (remote_protocol_packets[PACKET_qSymbol].support == PACKET_DISABLE)
3645     return;
3646
3647   /* Make sure the remote is pointing at the right process.  Note
3648      there's no way to select "no process".  */
3649   set_general_process ();
3650
3651   /* Allocate a message buffer.  We can't reuse the input buffer in RS,
3652      because we need both at the same time.  */
3653   msg = alloca (get_remote_packet_size ());
3654
3655   /* Invite target to request symbol lookups.  */
3656
3657   putpkt ("qSymbol::");
3658   getpkt (&rs->buf, &rs->buf_size, 0);
3659   packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSymbol]);
3660   reply = rs->buf;
3661
3662   while (strncmp (reply, "qSymbol:", 8) == 0)
3663     {
3664       tmp = &reply[8];
3665       end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
3666       msg[end] = '\0';
3667       sym = lookup_minimal_symbol (msg, NULL, NULL);
3668       if (sym == NULL)
3669         xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
3670       else
3671         {
3672           int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
3673           CORE_ADDR sym_addr = SYMBOL_VALUE_ADDRESS (sym);
3674
3675           /* If this is a function address, return the start of code
3676              instead of any data function descriptor.  */
3677           sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
3678                                                          sym_addr,
3679                                                          &current_target);
3680
3681           xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
3682                      phex_nz (sym_addr, addr_size), &reply[8]);
3683         }
3684   
3685       putpkt (msg);
3686       getpkt (&rs->buf, &rs->buf_size, 0);
3687       reply = rs->buf;
3688     }
3689 }
3690
3691 static struct serial *
3692 remote_serial_open (char *name)
3693 {
3694   static int udp_warning = 0;
3695
3696   /* FIXME: Parsing NAME here is a hack.  But we want to warn here instead
3697      of in ser-tcp.c, because it is the remote protocol assuming that the
3698      serial connection is reliable and not the serial connection promising
3699      to be.  */
3700   if (!udp_warning && strncmp (name, "udp:", 4) == 0)
3701     {
3702       warning (_("The remote protocol may be unreliable over UDP.\n"
3703                  "Some events may be lost, rendering further debugging "
3704                  "impossible."));
3705       udp_warning = 1;
3706     }
3707
3708   return serial_open (name);
3709 }
3710
3711 /* Inform the target of our permission settings.  The permission flags
3712    work without this, but if the target knows the settings, it can do
3713    a couple things.  First, it can add its own check, to catch cases
3714    that somehow manage to get by the permissions checks in target
3715    methods.  Second, if the target is wired to disallow particular
3716    settings (for instance, a system in the field that is not set up to
3717    be able to stop at a breakpoint), it can object to any unavailable
3718    permissions.  */
3719
3720 void
3721 remote_set_permissions (void)
3722 {
3723   struct remote_state *rs = get_remote_state ();
3724
3725   xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
3726              "WriteReg:%x;WriteMem:%x;"
3727              "InsertBreak:%x;InsertTrace:%x;"
3728              "InsertFastTrace:%x;Stop:%x",
3729              may_write_registers, may_write_memory,
3730              may_insert_breakpoints, may_insert_tracepoints,
3731              may_insert_fast_tracepoints, may_stop);
3732   putpkt (rs->buf);
3733   getpkt (&rs->buf, &rs->buf_size, 0);
3734
3735   /* If the target didn't like the packet, warn the user.  Do not try
3736      to undo the user's settings, that would just be maddening.  */
3737   if (strcmp (rs->buf, "OK") != 0)
3738     warning (_("Remote refused setting permissions with: %s"), rs->buf);
3739 }
3740
3741 /* This type describes each known response to the qSupported
3742    packet.  */
3743 struct protocol_feature
3744 {
3745   /* The name of this protocol feature.  */
3746   const char *name;
3747
3748   /* The default for this protocol feature.  */
3749   enum packet_support default_support;
3750
3751   /* The function to call when this feature is reported, or after
3752      qSupported processing if the feature is not supported.
3753      The first argument points to this structure.  The second
3754      argument indicates whether the packet requested support be
3755      enabled, disabled, or probed (or the default, if this function
3756      is being called at the end of processing and this feature was
3757      not reported).  The third argument may be NULL; if not NULL, it
3758      is a NUL-terminated string taken from the packet following
3759      this feature's name and an equals sign.  */
3760   void (*func) (const struct protocol_feature *, enum packet_support,
3761                 const char *);
3762
3763   /* The corresponding packet for this feature.  Only used if
3764      FUNC is remote_supported_packet.  */
3765   int packet;
3766 };
3767
3768 static void
3769 remote_supported_packet (const struct protocol_feature *feature,
3770                          enum packet_support support,
3771                          const char *argument)
3772 {
3773   if (argument)
3774     {
3775       warning (_("Remote qSupported response supplied an unexpected value for"
3776                  " \"%s\"."), feature->name);
3777       return;
3778     }
3779
3780   if (remote_protocol_packets[feature->packet].support
3781       == PACKET_SUPPORT_UNKNOWN)
3782     remote_protocol_packets[feature->packet].support = support;
3783 }
3784
3785 static void
3786 remote_packet_size (const struct protocol_feature *feature,
3787                     enum packet_support support, const char *value)
3788 {
3789   struct remote_state *rs = get_remote_state ();
3790
3791   int packet_size;
3792   char *value_end;
3793
3794   if (support != PACKET_ENABLE)
3795     return;
3796
3797   if (value == NULL || *value == '\0')
3798     {
3799       warning (_("Remote target reported \"%s\" without a size."),
3800                feature->name);
3801       return;
3802     }
3803
3804   errno = 0;
3805   packet_size = strtol (value, &value_end, 16);
3806   if (errno != 0 || *value_end != '\0' || packet_size < 0)
3807     {
3808       warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
3809                feature->name, value);
3810       return;
3811     }
3812
3813   if (packet_size > MAX_REMOTE_PACKET_SIZE)
3814     {
3815       warning (_("limiting remote suggested packet size (%d bytes) to %d"),
3816                packet_size, MAX_REMOTE_PACKET_SIZE);
3817       packet_size = MAX_REMOTE_PACKET_SIZE;
3818     }
3819
3820   /* Record the new maximum packet size.  */
3821   rs->explicit_packet_size = packet_size;
3822 }
3823
3824 static void
3825 remote_multi_process_feature (const struct protocol_feature *feature,
3826                               enum packet_support support, const char *value)
3827 {
3828   struct remote_state *rs = get_remote_state ();
3829
3830   rs->multi_process_aware = (support == PACKET_ENABLE);
3831 }
3832
3833 static void
3834 remote_non_stop_feature (const struct protocol_feature *feature,
3835                               enum packet_support support, const char *value)
3836 {
3837   struct remote_state *rs = get_remote_state ();
3838
3839   rs->non_stop_aware = (support == PACKET_ENABLE);
3840 }
3841
3842 static void
3843 remote_cond_tracepoint_feature (const struct protocol_feature *feature,
3844                                        enum packet_support support,
3845                                        const char *value)
3846 {
3847   struct remote_state *rs = get_remote_state ();
3848
3849   rs->cond_tracepoints = (support == PACKET_ENABLE);
3850 }
3851
3852 static void
3853 remote_cond_breakpoint_feature (const struct protocol_feature *feature,
3854                                 enum packet_support support,
3855                                 const char *value)
3856 {
3857   struct remote_state *rs = get_remote_state ();
3858
3859   rs->cond_breakpoints = (support == PACKET_ENABLE);
3860 }
3861
3862 static void
3863 remote_breakpoint_commands_feature (const struct protocol_feature *feature,
3864                                     enum packet_support support,
3865                                     const char *value)
3866 {
3867   struct remote_state *rs = get_remote_state ();
3868
3869   rs->breakpoint_commands = (support == PACKET_ENABLE);
3870 }
3871
3872 static void
3873 remote_fast_tracepoint_feature (const struct protocol_feature *feature,
3874                                 enum packet_support support,
3875                                 const char *value)
3876 {
3877   struct remote_state *rs = get_remote_state ();
3878
3879   rs->fast_tracepoints = (support == PACKET_ENABLE);
3880 }
3881
3882 static void
3883 remote_static_tracepoint_feature (const struct protocol_feature *feature,
3884                                   enum packet_support support,
3885                                   const char *value)
3886 {
3887   struct remote_state *rs = get_remote_state ();
3888
3889   rs->static_tracepoints = (support == PACKET_ENABLE);
3890 }
3891
3892 static void
3893 remote_install_in_trace_feature (const struct protocol_feature *feature,
3894                                  enum packet_support support,
3895                                  const char *value)
3896 {
3897   struct remote_state *rs = get_remote_state ();
3898
3899   rs->install_in_trace = (support == PACKET_ENABLE);
3900 }
3901
3902 static void
3903 remote_disconnected_tracing_feature (const struct protocol_feature *feature,
3904                                      enum packet_support support,
3905                                      const char *value)
3906 {
3907   struct remote_state *rs = get_remote_state ();
3908
3909   rs->disconnected_tracing = (support == PACKET_ENABLE);
3910 }
3911
3912 static void
3913 remote_enable_disable_tracepoint_feature (const struct protocol_feature *feature,
3914                                           enum packet_support support,
3915                                           const char *value)
3916 {
3917   struct remote_state *rs = get_remote_state ();
3918
3919   rs->enable_disable_tracepoints = (support == PACKET_ENABLE);
3920 }
3921
3922 static void
3923 remote_string_tracing_feature (const struct protocol_feature *feature,
3924                                enum packet_support support,
3925                                const char *value)
3926 {
3927   struct remote_state *rs = get_remote_state ();
3928
3929   rs->string_tracing = (support == PACKET_ENABLE);
3930 }
3931
3932 static struct protocol_feature remote_protocol_features[] = {
3933   { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
3934   { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
3935     PACKET_qXfer_auxv },
3936   { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
3937     PACKET_qXfer_features },
3938   { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
3939     PACKET_qXfer_libraries },
3940   { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
3941     PACKET_qXfer_libraries_svr4 },
3942   { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
3943     PACKET_qXfer_memory_map },
3944   { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
3945     PACKET_qXfer_spu_read },
3946   { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
3947     PACKET_qXfer_spu_write },
3948   { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
3949     PACKET_qXfer_osdata },
3950   { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
3951     PACKET_qXfer_threads },
3952   { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
3953     PACKET_qXfer_traceframe_info },
3954   { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
3955     PACKET_QPassSignals },
3956   { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
3957     PACKET_QProgramSignals },
3958   { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
3959     PACKET_QStartNoAckMode },
3960   { "multiprocess", PACKET_DISABLE, remote_multi_process_feature, -1 },
3961   { "QNonStop", PACKET_DISABLE, remote_non_stop_feature, -1 },
3962   { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
3963     PACKET_qXfer_siginfo_read },
3964   { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
3965     PACKET_qXfer_siginfo_write },
3966   { "ConditionalTracepoints", PACKET_DISABLE, remote_cond_tracepoint_feature,
3967     PACKET_ConditionalTracepoints },
3968   { "ConditionalBreakpoints", PACKET_DISABLE, remote_cond_breakpoint_feature,
3969     PACKET_ConditionalBreakpoints },
3970   { "BreakpointCommands", PACKET_DISABLE, remote_breakpoint_commands_feature,
3971     PACKET_BreakpointCommands },
3972   { "FastTracepoints", PACKET_DISABLE, remote_fast_tracepoint_feature,
3973     PACKET_FastTracepoints },
3974   { "StaticTracepoints", PACKET_DISABLE, remote_static_tracepoint_feature,
3975     PACKET_StaticTracepoints },
3976   {"InstallInTrace", PACKET_DISABLE, remote_install_in_trace_feature,
3977    PACKET_InstallInTrace},
3978   { "DisconnectedTracing", PACKET_DISABLE, remote_disconnected_tracing_feature,
3979     -1 },
3980   { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
3981     PACKET_bc },
3982   { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
3983     PACKET_bs },
3984   { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
3985     PACKET_TracepointSource },
3986   { "QAllow", PACKET_DISABLE, remote_supported_packet,
3987     PACKET_QAllow },
3988   { "EnableDisableTracepoints", PACKET_DISABLE,
3989     remote_enable_disable_tracepoint_feature, -1 },
3990   { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
3991     PACKET_qXfer_fdpic },
3992   { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
3993     PACKET_qXfer_uib },
3994   { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
3995     PACKET_QDisableRandomization },
3996   { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
3997   { "QTBuffer:size", PACKET_DISABLE,
3998     remote_supported_packet, PACKET_QTBuffer_size},
3999   { "tracenz", PACKET_DISABLE,
4000     remote_string_tracing_feature, -1 },
4001   { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
4002   { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
4003   { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
4004     PACKET_qXfer_btrace }
4005 };
4006
4007 static char *remote_support_xml;
4008
4009 /* Register string appended to "xmlRegisters=" in qSupported query.  */
4010
4011 void
4012 register_remote_support_xml (const char *xml)
4013 {
4014 #if defined(HAVE_LIBEXPAT)
4015   if (remote_support_xml == NULL)
4016     remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
4017   else
4018     {
4019       char *copy = xstrdup (remote_support_xml + 13);
4020       char *p = strtok (copy, ",");
4021
4022       do
4023         {
4024           if (strcmp (p, xml) == 0)
4025             {
4026               /* already there */
4027               xfree (copy);
4028               return;
4029             }
4030         }
4031       while ((p = strtok (NULL, ",")) != NULL);
4032       xfree (copy);
4033
4034       remote_support_xml = reconcat (remote_support_xml,
4035                                      remote_support_xml, ",", xml,
4036                                      (char *) NULL);
4037     }
4038 #endif
4039 }
4040
4041 static char *
4042 remote_query_supported_append (char *msg, const char *append)
4043 {
4044   if (msg)
4045     return reconcat (msg, msg, ";", append, (char *) NULL);
4046   else
4047     return xstrdup (append);
4048 }
4049
4050 static void
4051 remote_query_supported (void)
4052 {
4053   struct remote_state *rs = get_remote_state ();
4054   char *next;
4055   int i;
4056   unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
4057
4058   /* The packet support flags are handled differently for this packet
4059      than for most others.  We treat an error, a disabled packet, and
4060      an empty response identically: any features which must be reported
4061      to be used will be automatically disabled.  An empty buffer
4062      accomplishes this, since that is also the representation for a list
4063      containing no features.  */
4064
4065   rs->buf[0] = 0;
4066   if (remote_protocol_packets[PACKET_qSupported].support != PACKET_DISABLE)
4067     {
4068       char *q = NULL;
4069       struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
4070
4071       q = remote_query_supported_append (q, "multiprocess+");
4072
4073       if (remote_support_xml)
4074         q = remote_query_supported_append (q, remote_support_xml);
4075
4076       q = remote_query_supported_append (q, "qRelocInsn+");
4077
4078       q = reconcat (q, "qSupported:", q, (char *) NULL);
4079       putpkt (q);
4080
4081       do_cleanups (old_chain);
4082
4083       getpkt (&rs->buf, &rs->buf_size, 0);
4084
4085       /* If an error occured, warn, but do not return - just reset the
4086          buffer to empty and go on to disable features.  */
4087       if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
4088           == PACKET_ERROR)
4089         {
4090           warning (_("Remote failure reply: %s"), rs->buf);
4091           rs->buf[0] = 0;
4092         }
4093     }
4094
4095   memset (seen, 0, sizeof (seen));
4096
4097   next = rs->buf;
4098   while (*next)
4099     {
4100       enum packet_support is_supported;
4101       char *p, *end, *name_end, *value;
4102
4103       /* First separate out this item from the rest of the packet.  If
4104          there's another item after this, we overwrite the separator
4105          (terminated strings are much easier to work with).  */
4106       p = next;
4107       end = strchr (p, ';');
4108       if (end == NULL)
4109         {
4110           end = p + strlen (p);
4111           next = end;
4112         }
4113       else
4114         {
4115           *end = '\0';
4116           next = end + 1;
4117
4118           if (end == p)
4119             {
4120               warning (_("empty item in \"qSupported\" response"));
4121               continue;
4122             }
4123         }
4124
4125       name_end = strchr (p, '=');
4126       if (name_end)
4127         {
4128           /* This is a name=value entry.  */
4129           is_supported = PACKET_ENABLE;
4130           value = name_end + 1;
4131           *name_end = '\0';
4132         }
4133       else
4134         {
4135           value = NULL;
4136           switch (end[-1])
4137             {
4138             case '+':
4139               is_supported = PACKET_ENABLE;
4140               break;
4141
4142             case '-':
4143               is_supported = PACKET_DISABLE;
4144               break;
4145
4146             case '?':
4147               is_supported = PACKET_SUPPORT_UNKNOWN;
4148               break;
4149
4150             default:
4151               warning (_("unrecognized item \"%s\" "
4152                          "in \"qSupported\" response"), p);
4153               continue;
4154             }
4155           end[-1] = '\0';
4156         }
4157
4158       for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4159         if (strcmp (remote_protocol_features[i].name, p) == 0)
4160           {
4161             const struct protocol_feature *feature;
4162
4163             seen[i] = 1;
4164             feature = &remote_protocol_features[i];
4165             feature->func (feature, is_supported, value);
4166             break;
4167           }
4168     }
4169
4170   /* If we increased the packet size, make sure to increase the global
4171      buffer size also.  We delay this until after parsing the entire
4172      qSupported packet, because this is the same buffer we were
4173      parsing.  */
4174   if (rs->buf_size < rs->explicit_packet_size)
4175     {
4176       rs->buf_size = rs->explicit_packet_size;
4177       rs->buf = xrealloc (rs->buf, rs->buf_size);
4178     }
4179
4180   /* Handle the defaults for unmentioned features.  */
4181   for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4182     if (!seen[i])
4183       {
4184         const struct protocol_feature *feature;
4185
4186         feature = &remote_protocol_features[i];
4187         feature->func (feature, feature->default_support, NULL);
4188       }
4189 }
4190
4191 /* Remove any of the remote.c targets from target stack.  Upper targets depend
4192    on it so remove them first.  */
4193
4194 static void
4195 remote_unpush_target (void)
4196 {
4197   pop_all_targets_above (process_stratum - 1, 0);
4198 }
4199
4200 static void
4201 remote_open_1 (char *name, int from_tty,
4202                struct target_ops *target, int extended_p)
4203 {
4204   struct remote_state *rs = get_remote_state ();
4205
4206   if (name == 0)
4207     error (_("To open a remote debug connection, you need to specify what\n"
4208            "serial device is attached to the remote system\n"
4209            "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
4210
4211   /* See FIXME above.  */
4212   if (!target_async_permitted)
4213     wait_forever_enabled_p = 1;
4214
4215   /* If we're connected to a running target, target_preopen will kill it.
4216      Ask this question first, before target_preopen has a chance to kill
4217      anything.  */
4218   if (remote_desc != NULL && !have_inferiors ())
4219     {
4220       if (from_tty
4221           && !query (_("Already connected to a remote target.  Disconnect? ")))
4222         error (_("Still connected."));
4223     }
4224
4225   /* Here the possibly existing remote target gets unpushed.  */
4226   target_preopen (from_tty);
4227
4228   /* Make sure we send the passed signals list the next time we resume.  */
4229   xfree (last_pass_packet);
4230   last_pass_packet = NULL;
4231
4232   /* Make sure we send the program signals list the next time we
4233      resume.  */
4234   xfree (last_program_signals_packet);
4235   last_program_signals_packet = NULL;
4236
4237   remote_fileio_reset ();
4238   reopen_exec_file ();
4239   reread_symbols ();
4240
4241   remote_desc = remote_serial_open (name);
4242   if (!remote_desc)
4243     perror_with_name (name);
4244
4245   if (baud_rate != -1)
4246     {
4247       if (serial_setbaudrate (remote_desc, baud_rate))
4248         {
4249           /* The requested speed could not be set.  Error out to
4250              top level after closing remote_desc.  Take care to
4251              set remote_desc to NULL to avoid closing remote_desc
4252              more than once.  */
4253           serial_close (remote_desc);
4254           remote_desc = NULL;
4255           perror_with_name (name);
4256         }
4257     }
4258
4259   serial_raw (remote_desc);
4260
4261   /* If there is something sitting in the buffer we might take it as a
4262      response to a command, which would be bad.  */
4263   serial_flush_input (remote_desc);
4264
4265   if (from_tty)
4266     {
4267       puts_filtered ("Remote debugging using ");
4268       puts_filtered (name);
4269       puts_filtered ("\n");
4270     }
4271   push_target (target);         /* Switch to using remote target now.  */
4272
4273   /* Register extra event sources in the event loop.  */
4274   remote_async_inferior_event_token
4275     = create_async_event_handler (remote_async_inferior_event_handler,
4276                                   NULL);
4277   remote_notif_register_async_event_handler ();
4278
4279   /* Reset the target state; these things will be queried either by
4280      remote_query_supported or as they are needed.  */
4281   init_all_packet_configs ();
4282   rs->cached_wait_status = 0;
4283   rs->explicit_packet_size = 0;
4284   rs->noack_mode = 0;
4285   rs->multi_process_aware = 0;
4286   rs->extended = extended_p;
4287   rs->non_stop_aware = 0;
4288   rs->waiting_for_stop_reply = 0;
4289   rs->ctrlc_pending_p = 0;
4290
4291   general_thread = not_sent_ptid;
4292   continue_thread = not_sent_ptid;
4293   remote_traceframe_number = -1;
4294
4295   /* Probe for ability to use "ThreadInfo" query, as required.  */
4296   use_threadinfo_query = 1;
4297   use_threadextra_query = 1;
4298
4299   if (target_async_permitted)
4300     {
4301       /* With this target we start out by owning the terminal.  */
4302       remote_async_terminal_ours_p = 1;
4303
4304       /* FIXME: cagney/1999-09-23: During the initial connection it is
4305          assumed that the target is already ready and able to respond to
4306          requests.  Unfortunately remote_start_remote() eventually calls
4307          wait_for_inferior() with no timeout.  wait_forever_enabled_p gets
4308          around this.  Eventually a mechanism that allows
4309          wait_for_inferior() to expect/get timeouts will be
4310          implemented.  */
4311       wait_forever_enabled_p = 0;
4312     }
4313
4314   /* First delete any symbols previously loaded from shared libraries.  */
4315   no_shared_libraries (NULL, 0);
4316
4317   /* Start afresh.  */
4318   init_thread_list ();
4319
4320   /* Start the remote connection.  If error() or QUIT, discard this
4321      target (we'd otherwise be in an inconsistent state) and then
4322      propogate the error on up the exception chain.  This ensures that
4323      the caller doesn't stumble along blindly assuming that the
4324      function succeeded.  The CLI doesn't have this problem but other
4325      UI's, such as MI do.
4326
4327      FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
4328      this function should return an error indication letting the
4329      caller restore the previous state.  Unfortunately the command
4330      ``target remote'' is directly wired to this function making that
4331      impossible.  On a positive note, the CLI side of this problem has
4332      been fixed - the function set_cmd_context() makes it possible for
4333      all the ``target ....'' commands to share a common callback
4334      function.  See cli-dump.c.  */
4335   {
4336     volatile struct gdb_exception ex;
4337
4338     TRY_CATCH (ex, RETURN_MASK_ALL)
4339       {
4340         remote_start_remote (from_tty, target, extended_p);
4341       }
4342     if (ex.reason < 0)
4343       {
4344         /* Pop the partially set up target - unless something else did
4345            already before throwing the exception.  */
4346         if (remote_desc != NULL)
4347           remote_unpush_target ();
4348         if (target_async_permitted)
4349           wait_forever_enabled_p = 1;
4350         throw_exception (ex);
4351       }
4352   }
4353
4354   if (target_async_permitted)