move use_threadinfo_query and use_threadextra_query into struct remote_state
[binutils-gdb:gdb.git] / 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 #include "filestuff.h"
48
49 #include <ctype.h>
50 #include <sys/time.h>
51
52 #include "event-loop.h"
53 #include "event-top.h"
54 #include "inf-loop.h"
55
56 #include <signal.h>
57 #include "serial.h"
58
59 #include "gdbcore.h" /* for exec_bfd */
60
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
63 #include "gdb_stat.h"
64 #include "xml-support.h"
65
66 #include "memory-map.h"
67
68 #include "tracepoint.h"
69 #include "ax.h"
70 #include "ax-gdb.h"
71 #include "agent.h"
72 #include "btrace.h"
73
74 /* Temp hacks for tracepoint encoding migration.  */
75 static char *target_buf;
76 static long target_buf_size;
77
78 /* The size to align memory write packets, when practical.  The protocol
79    does not guarantee any alignment, and gdb will generate short
80    writes and unaligned writes, but even as a best-effort attempt this
81    can improve bulk transfers.  For instance, if a write is misaligned
82    relative to the target's data bus, the stub may need to make an extra
83    round trip fetching data from the target.  This doesn't make a
84    huge difference, but it's easy to do, so we try to be helpful.
85
86    The alignment chosen is arbitrary; usually data bus width is
87    important here, not the possibly larger cache line size.  */
88 enum { REMOTE_ALIGN_WRITES = 16 };
89
90 /* Prototypes for local functions.  */
91 static void async_cleanup_sigint_signal_handler (void *dummy);
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 async_handle_remote_sigint (int);
97 static void async_handle_remote_sigint_twice (int);
98
99 static void remote_files_info (struct target_ops *ignore);
100
101 static void remote_prepare_to_store (struct regcache *regcache);
102
103 static void remote_open (char *name, int from_tty);
104
105 static void extended_remote_open (char *name, int from_tty);
106
107 static void remote_open_1 (char *, int, struct target_ops *, int extended_p);
108
109 static void remote_close (void);
110
111 static void remote_mourn (struct target_ops *ops);
112
113 static void extended_remote_restart (void);
114
115 static void extended_remote_mourn (struct target_ops *);
116
117 static void remote_mourn_1 (struct target_ops *);
118
119 static void remote_send (char **buf, long *sizeof_buf_p);
120
121 static int readchar (int timeout);
122
123 static void remote_serial_write (const char *str, int len);
124
125 static void remote_kill (struct target_ops *ops);
126
127 static int tohex (int nib);
128
129 static int remote_can_async_p (void);
130
131 static int remote_is_async_p (void);
132
133 static void remote_async (void (*callback) (enum inferior_event_type event_type,
134                                             void *context), void *context);
135
136 static void remote_detach (struct target_ops *ops, char *args, int from_tty);
137
138 static void sync_remote_interrupt_twice (int signo);
139
140 static void interrupt_query (void);
141
142 static void set_general_thread (struct ptid ptid);
143 static void set_continue_thread (struct ptid ptid);
144
145 static void get_offsets (void);
146
147 static void skip_frame (void);
148
149 static long read_frame (char **buf_p, long *sizeof_buf);
150
151 static int hexnumlen (ULONGEST num);
152
153 static void init_remote_ops (void);
154
155 static void init_extended_remote_ops (void);
156
157 static void remote_stop (ptid_t);
158
159 static int ishex (int ch, int *val);
160
161 static int stubhex (int ch);
162
163 static int hexnumstr (char *, ULONGEST);
164
165 static int hexnumnstr (char *, ULONGEST, int);
166
167 static CORE_ADDR remote_address_masked (CORE_ADDR);
168
169 static void print_packet (char *);
170
171 static void compare_sections_command (char *, int);
172
173 static void packet_command (char *, int);
174
175 static int stub_unpack_int (char *buff, int fieldlength);
176
177 static ptid_t remote_current_thread (ptid_t oldptid);
178
179 static void remote_find_new_threads (void);
180
181 static int fromhex (int a);
182
183 static int putpkt_binary (char *buf, int cnt);
184
185 static void check_binary_download (CORE_ADDR addr);
186
187 struct packet_config;
188
189 static void show_packet_config_cmd (struct packet_config *config);
190
191 static void update_packet_config (struct packet_config *config);
192
193 static void set_remote_protocol_packet_cmd (char *args, int from_tty,
194                                             struct cmd_list_element *c);
195
196 static void show_remote_protocol_packet_cmd (struct ui_file *file,
197                                              int from_tty,
198                                              struct cmd_list_element *c,
199                                              const char *value);
200
201 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
202 static ptid_t read_ptid (char *buf, char **obuf);
203
204 static void remote_set_permissions (void);
205
206 struct remote_state;
207 static int remote_get_trace_status (struct trace_status *ts);
208
209 static int remote_upload_tracepoints (struct uploaded_tp **utpp);
210
211 static int remote_upload_trace_state_variables (struct uploaded_tsv **utsvp);
212   
213 static void remote_query_supported (void);
214
215 static void remote_check_symbols (void);
216
217 void _initialize_remote (void);
218
219 struct stop_reply;
220 static void stop_reply_xfree (struct stop_reply *);
221 static void remote_parse_stop_reply (char *, struct stop_reply *);
222 static void push_stop_reply (struct stop_reply *);
223 static void discard_pending_stop_replies (struct inferior *);
224 static int peek_stop_reply (ptid_t ptid);
225
226 static void remote_async_inferior_event_handler (gdb_client_data);
227
228 static void remote_terminal_ours (void);
229
230 static int remote_read_description_p (struct target_ops *target);
231
232 static void remote_console_output (char *msg);
233
234 static int remote_supports_cond_breakpoints (void);
235
236 static int remote_can_run_breakpoint_commands (void);
237
238 /* For "remote".  */
239
240 static struct cmd_list_element *remote_cmdlist;
241
242 /* For "set remote" and "show remote".  */
243
244 static struct cmd_list_element *remote_set_cmdlist;
245 static struct cmd_list_element *remote_show_cmdlist;
246
247 /* Stub vCont actions support.
248
249    Each field is a boolean flag indicating whether the stub reports
250    support for the corresponding action.  */
251
252 struct vCont_action_support
253 {
254   /* vCont;t */
255   int t;
256
257   /* vCont;r */
258   int r;
259 };
260
261 /* Controls whether GDB is willing to use range stepping.  */
262
263 static int use_range_stepping = 1;
264
265 /* Description of the remote protocol state for the currently
266    connected target.  This is per-target state, and independent of the
267    selected architecture.  */
268
269 struct remote_state
270 {
271   /* A buffer to use for incoming packets, and its current size.  The
272      buffer is grown dynamically for larger incoming packets.
273      Outgoing packets may also be constructed in this buffer.
274      BUF_SIZE is always at least REMOTE_PACKET_SIZE;
275      REMOTE_PACKET_SIZE should be used to limit the length of outgoing
276      packets.  */
277   char *buf;
278   long buf_size;
279
280   /* True if we're going through initial connection setup (finding out
281      about the remote side's threads, relocating symbols, etc.).  */
282   int starting_up;
283
284   /* If we negotiated packet size explicitly (and thus can bypass
285      heuristics for the largest packet size that will not overflow
286      a buffer in the stub), this will be set to that packet size.
287      Otherwise zero, meaning to use the guessed size.  */
288   long explicit_packet_size;
289
290   /* remote_wait is normally called when the target is running and
291      waits for a stop reply packet.  But sometimes we need to call it
292      when the target is already stopped.  We can send a "?" packet
293      and have remote_wait read the response.  Or, if we already have
294      the response, we can stash it in BUF and tell remote_wait to
295      skip calling getpkt.  This flag is set when BUF contains a
296      stop reply packet and the target is not waiting.  */
297   int cached_wait_status;
298
299   /* True, if in no ack mode.  That is, neither GDB nor the stub will
300      expect acks from each other.  The connection is assumed to be
301      reliable.  */
302   int noack_mode;
303
304   /* True if we're connected in extended remote mode.  */
305   int extended;
306
307   /* True if the stub reported support for multi-process
308      extensions.  */
309   int multi_process_aware;
310
311   /* True if we resumed the target and we're waiting for the target to
312      stop.  In the mean time, we can't start another command/query.
313      The remote server wouldn't be ready to process it, so we'd
314      timeout waiting for a reply that would never come and eventually
315      we'd close the connection.  This can happen in asynchronous mode
316      because we allow GDB commands while the target is running.  */
317   int waiting_for_stop_reply;
318
319   /* True if the stub reports support for non-stop mode.  */
320   int non_stop_aware;
321
322   /* The status of the stub support for the various vCont actions.  */
323   struct vCont_action_support supports_vCont;
324
325   /* True if the stub reports support for conditional tracepoints.  */
326   int cond_tracepoints;
327
328   /* True if the stub reports support for target-side breakpoint
329      conditions.  */
330   int cond_breakpoints;
331
332   /* True if the stub reports support for target-side breakpoint
333      commands.  */
334   int breakpoint_commands;
335
336   /* True if the stub reports support for fast tracepoints.  */
337   int fast_tracepoints;
338
339   /* True if the stub reports support for static tracepoints.  */
340   int static_tracepoints;
341
342   /* True if the stub reports support for installing tracepoint while
343      tracing.  */
344   int install_in_trace;
345
346   /* True if the stub can continue running a trace while GDB is
347      disconnected.  */
348   int disconnected_tracing;
349
350   /* True if the stub reports support for enabling and disabling
351      tracepoints while a trace experiment is running.  */
352   int enable_disable_tracepoints;
353
354   /* True if the stub can collect strings using tracenz bytecode.  */
355   int string_tracing;
356
357   /* True if the stub supports qXfer:libraries-svr4:read with a
358      non-empty annex.  */
359   int augmented_libraries_svr4_read;
360
361   /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
362      responded to that.  */
363   int ctrlc_pending_p;
364
365   /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
366      remote_open knows that we don't have a file open when the program
367      starts.  */
368   struct serial *remote_desc;
369
370   /* These are the threads which we last sent to the remote system.  The
371      TID member will be -1 for all or -2 for not sent yet.  */
372   ptid_t general_thread;
373   ptid_t continue_thread;
374
375   /* This is the traceframe which we last selected on the remote system.
376      It will be -1 if no traceframe is selected.  */
377   int remote_traceframe_number;
378
379   char *last_pass_packet;
380
381   /* The last QProgramSignals packet sent to the target.  We bypass
382      sending a new program signals list down to the target if the new
383      packet is exactly the same as the last we sent.  IOW, we only let
384      the target know about program signals list changes.  */
385   char *last_program_signals_packet;
386
387   enum gdb_signal last_sent_signal;
388
389   int last_sent_step;
390
391   char *finished_object;
392   char *finished_annex;
393   ULONGEST finished_offset;
394
395   /* Should we try the 'ThreadInfo' query packet?
396
397      This variable (NOT available to the user: auto-detect only!)
398      determines whether GDB will use the new, simpler "ThreadInfo"
399      query or the older, more complex syntax for thread queries.
400      This is an auto-detect variable (set to true at each connect,
401      and set to false when the target fails to recognize it).  */
402   int use_threadinfo_query;
403   int use_threadextra_query;
404 };
405
406 /* Private data that we'll store in (struct thread_info)->private.  */
407 struct private_thread_info
408 {
409   char *extra;
410   int core;
411 };
412
413 static void
414 free_private_thread_info (struct private_thread_info *info)
415 {
416   xfree (info->extra);
417   xfree (info);
418 }
419
420 /* Returns true if the multi-process extensions are in effect.  */
421 static int
422 remote_multi_process_p (struct remote_state *rs)
423 {
424   return rs->multi_process_aware;
425 }
426
427 /* This data could be associated with a target, but we do not always
428    have access to the current target when we need it, so for now it is
429    static.  This will be fine for as long as only one target is in use
430    at a time.  */
431 static struct remote_state *remote_state;
432
433 static struct remote_state *
434 get_remote_state_raw (void)
435 {
436   return remote_state;
437 }
438
439 /* Allocate a new struct remote_state with xmalloc, initialize it, and
440    return it.  */
441
442 static struct remote_state *
443 new_remote_state (void)
444 {
445   struct remote_state *result = XCNEW (struct remote_state);
446
447   /* The default buffer size is unimportant; it will be expanded
448      whenever a larger buffer is needed. */
449   result->buf_size = 400;
450   result->buf = xmalloc (result->buf_size);
451   result->remote_traceframe_number = -1;
452   result->last_sent_signal = GDB_SIGNAL_0;
453
454   return result;
455 }
456
457 /* Description of the remote protocol for a given architecture.  */
458
459 struct packet_reg
460 {
461   long offset; /* Offset into G packet.  */
462   long regnum; /* GDB's internal register number.  */
463   LONGEST pnum; /* Remote protocol register number.  */
464   int in_g_packet; /* Always part of G packet.  */
465   /* long size in bytes;  == register_size (target_gdbarch (), regnum);
466      at present.  */
467   /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
468      at present.  */
469 };
470
471 struct remote_arch_state
472 {
473   /* Description of the remote protocol registers.  */
474   long sizeof_g_packet;
475
476   /* Description of the remote protocol registers indexed by REGNUM
477      (making an array gdbarch_num_regs in size).  */
478   struct packet_reg *regs;
479
480   /* This is the size (in chars) of the first response to the ``g''
481      packet.  It is used as a heuristic when determining the maximum
482      size of memory-read and memory-write packets.  A target will
483      typically only reserve a buffer large enough to hold the ``g''
484      packet.  The size does not include packet overhead (headers and
485      trailers).  */
486   long actual_register_packet_size;
487
488   /* This is the maximum size (in chars) of a non read/write packet.
489      It is also used as a cap on the size of read/write packets.  */
490   long remote_packet_size;
491 };
492
493 long sizeof_pkt = 2000;
494
495 /* Utility: generate error from an incoming stub packet.  */
496 static void
497 trace_error (char *buf)
498 {
499   if (*buf++ != 'E')
500     return;                     /* not an error msg */
501   switch (*buf)
502     {
503     case '1':                   /* malformed packet error */
504       if (*++buf == '0')        /*   general case: */
505         error (_("remote.c: error in outgoing packet."));
506       else
507         error (_("remote.c: error in outgoing packet at field #%ld."),
508                strtol (buf, NULL, 16));
509     default:
510       error (_("Target returns error code '%s'."), buf);
511     }
512 }
513
514 /* Utility: wait for reply from stub, while accepting "O" packets.  */
515 static char *
516 remote_get_noisy_reply (char **buf_p,
517                         long *sizeof_buf)
518 {
519   do                            /* Loop on reply from remote stub.  */
520     {
521       char *buf;
522
523       QUIT;                     /* Allow user to bail out with ^C.  */
524       getpkt (buf_p, sizeof_buf, 0);
525       buf = *buf_p;
526       if (buf[0] == 'E')
527         trace_error (buf);
528       else if (strncmp (buf, "qRelocInsn:", strlen ("qRelocInsn:")) == 0)
529         {
530           ULONGEST ul;
531           CORE_ADDR from, to, org_to;
532           char *p, *pp;
533           int adjusted_size = 0;
534           volatile struct gdb_exception ex;
535
536           p = buf + strlen ("qRelocInsn:");
537           pp = unpack_varlen_hex (p, &ul);
538           if (*pp != ';')
539             error (_("invalid qRelocInsn packet: %s"), buf);
540           from = ul;
541
542           p = pp + 1;
543           unpack_varlen_hex (p, &ul);
544           to = ul;
545
546           org_to = to;
547
548           TRY_CATCH (ex, RETURN_MASK_ALL)
549             {
550               gdbarch_relocate_instruction (target_gdbarch (), &to, from);
551             }
552           if (ex.reason >= 0)
553             {
554               adjusted_size = to - org_to;
555
556               xsnprintf (buf, *sizeof_buf, "qRelocInsn:%x", adjusted_size);
557               putpkt (buf);
558             }
559           else if (ex.reason < 0 && ex.error == MEMORY_ERROR)
560             {
561               /* Propagate memory errors silently back to the target.
562                  The stub may have limited the range of addresses we
563                  can write to, for example.  */
564               putpkt ("E01");
565             }
566           else
567             {
568               /* Something unexpectedly bad happened.  Be verbose so
569                  we can tell what, and propagate the error back to the
570                  stub, so it doesn't get stuck waiting for a
571                  response.  */
572               exception_fprintf (gdb_stderr, ex,
573                                  _("warning: relocating instruction: "));
574               putpkt ("E01");
575             }
576         }
577       else if (buf[0] == 'O' && buf[1] != 'K')
578         remote_console_output (buf + 1);        /* 'O' message from stub */
579       else
580         return buf;             /* Here's the actual reply.  */
581     }
582   while (1);
583 }
584
585 /* Handle for retreving the remote protocol data from gdbarch.  */
586 static struct gdbarch_data *remote_gdbarch_data_handle;
587
588 static struct remote_arch_state *
589 get_remote_arch_state (void)
590 {
591   return gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle);
592 }
593
594 /* Fetch the global remote target state.  */
595
596 static struct remote_state *
597 get_remote_state (void)
598 {
599   /* Make sure that the remote architecture state has been
600      initialized, because doing so might reallocate rs->buf.  Any
601      function which calls getpkt also needs to be mindful of changes
602      to rs->buf, but this call limits the number of places which run
603      into trouble.  */
604   get_remote_arch_state ();
605
606   return get_remote_state_raw ();
607 }
608
609 static int
610 compare_pnums (const void *lhs_, const void *rhs_)
611 {
612   const struct packet_reg * const *lhs = lhs_;
613   const struct packet_reg * const *rhs = rhs_;
614
615   if ((*lhs)->pnum < (*rhs)->pnum)
616     return -1;
617   else if ((*lhs)->pnum == (*rhs)->pnum)
618     return 0;
619   else
620     return 1;
621 }
622
623 static int
624 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
625 {
626   int regnum, num_remote_regs, offset;
627   struct packet_reg **remote_regs;
628
629   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
630     {
631       struct packet_reg *r = &regs[regnum];
632
633       if (register_size (gdbarch, regnum) == 0)
634         /* Do not try to fetch zero-sized (placeholder) registers.  */
635         r->pnum = -1;
636       else
637         r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
638
639       r->regnum = regnum;
640     }
641
642   /* Define the g/G packet format as the contents of each register
643      with a remote protocol number, in order of ascending protocol
644      number.  */
645
646   remote_regs = alloca (gdbarch_num_regs (gdbarch)
647                         * sizeof (struct packet_reg *));
648   for (num_remote_regs = 0, regnum = 0;
649        regnum < gdbarch_num_regs (gdbarch);
650        regnum++)
651     if (regs[regnum].pnum != -1)
652       remote_regs[num_remote_regs++] = &regs[regnum];
653
654   qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
655          compare_pnums);
656
657   for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
658     {
659       remote_regs[regnum]->in_g_packet = 1;
660       remote_regs[regnum]->offset = offset;
661       offset += register_size (gdbarch, remote_regs[regnum]->regnum);
662     }
663
664   return offset;
665 }
666
667 /* Given the architecture described by GDBARCH, return the remote
668    protocol register's number and the register's offset in the g/G
669    packets of GDB register REGNUM, in PNUM and POFFSET respectively.
670    If the target does not have a mapping for REGNUM, return false,
671    otherwise, return true.  */
672
673 int
674 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
675                                    int *pnum, int *poffset)
676 {
677   int sizeof_g_packet;
678   struct packet_reg *regs;
679   struct cleanup *old_chain;
680
681   gdb_assert (regnum < gdbarch_num_regs (gdbarch));
682
683   regs = xcalloc (gdbarch_num_regs (gdbarch), sizeof (struct packet_reg));
684   old_chain = make_cleanup (xfree, regs);
685
686   sizeof_g_packet = map_regcache_remote_table (gdbarch, regs);
687
688   *pnum = regs[regnum].pnum;
689   *poffset = regs[regnum].offset;
690
691   do_cleanups (old_chain);
692
693   return *pnum != -1;
694 }
695
696 static void *
697 init_remote_state (struct gdbarch *gdbarch)
698 {
699   struct remote_state *rs = get_remote_state_raw ();
700   struct remote_arch_state *rsa;
701
702   rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
703
704   /* Use the architecture to build a regnum<->pnum table, which will be
705      1:1 unless a feature set specifies otherwise.  */
706   rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
707                                       gdbarch_num_regs (gdbarch),
708                                       struct packet_reg);
709
710   /* Record the maximum possible size of the g packet - it may turn out
711      to be smaller.  */
712   rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
713
714   /* Default maximum number of characters in a packet body.  Many
715      remote stubs have a hardwired buffer size of 400 bytes
716      (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used
717      as the maximum packet-size to ensure that the packet and an extra
718      NUL character can always fit in the buffer.  This stops GDB
719      trashing stubs that try to squeeze an extra NUL into what is
720      already a full buffer (As of 1999-12-04 that was most stubs).  */
721   rsa->remote_packet_size = 400 - 1;
722
723   /* This one is filled in when a ``g'' packet is received.  */
724   rsa->actual_register_packet_size = 0;
725
726   /* Should rsa->sizeof_g_packet needs more space than the
727      default, adjust the size accordingly.  Remember that each byte is
728      encoded as two characters.  32 is the overhead for the packet
729      header / footer.  NOTE: cagney/1999-10-26: I suspect that 8
730      (``$NN:G...#NN'') is a better guess, the below has been padded a
731      little.  */
732   if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
733     rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
734
735   /* Make sure that the packet buffer is plenty big enough for
736      this architecture.  */
737   if (rs->buf_size < rsa->remote_packet_size)
738     {
739       rs->buf_size = 2 * rsa->remote_packet_size;
740       rs->buf = xrealloc (rs->buf, rs->buf_size);
741     }
742
743   return rsa;
744 }
745
746 /* Return the current allowed size of a remote packet.  This is
747    inferred from the current architecture, and should be used to
748    limit the length of outgoing packets.  */
749 static long
750 get_remote_packet_size (void)
751 {
752   struct remote_state *rs = get_remote_state ();
753   struct remote_arch_state *rsa = get_remote_arch_state ();
754
755   if (rs->explicit_packet_size)
756     return rs->explicit_packet_size;
757
758   return rsa->remote_packet_size;
759 }
760
761 static struct packet_reg *
762 packet_reg_from_regnum (struct remote_arch_state *rsa, long regnum)
763 {
764   if (regnum < 0 && regnum >= gdbarch_num_regs (target_gdbarch ()))
765     return NULL;
766   else
767     {
768       struct packet_reg *r = &rsa->regs[regnum];
769
770       gdb_assert (r->regnum == regnum);
771       return r;
772     }
773 }
774
775 static struct packet_reg *
776 packet_reg_from_pnum (struct remote_arch_state *rsa, LONGEST pnum)
777 {
778   int i;
779
780   for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
781     {
782       struct packet_reg *r = &rsa->regs[i];
783
784       if (r->pnum == pnum)
785         return r;
786     }
787   return NULL;
788 }
789
790 /* FIXME: graces/2002-08-08: These variables should eventually be
791    bound to an instance of the target object (as in gdbarch-tdep()),
792    when such a thing exists.  */
793
794 /* This is set to the data address of the access causing the target
795    to stop for a watchpoint.  */
796 static CORE_ADDR remote_watch_data_address;
797
798 /* This is non-zero if target stopped for a watchpoint.  */
799 static int remote_stopped_by_watchpoint_p;
800
801 static struct target_ops remote_ops;
802
803 static struct target_ops extended_remote_ops;
804
805 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
806    ``forever'' still use the normal timeout mechanism.  This is
807    currently used by the ASYNC code to guarentee that target reads
808    during the initial connect always time-out.  Once getpkt has been
809    modified to return a timeout indication and, in turn
810    remote_wait()/wait_for_inferior() have gained a timeout parameter
811    this can go away.  */
812 static int wait_forever_enabled_p = 1;
813
814 /* Allow the user to specify what sequence to send to the remote
815    when he requests a program interruption: Although ^C is usually
816    what remote systems expect (this is the default, here), it is
817    sometimes preferable to send a break.  On other systems such
818    as the Linux kernel, a break followed by g, which is Magic SysRq g
819    is required in order to interrupt the execution.  */
820 const char interrupt_sequence_control_c[] = "Ctrl-C";
821 const char interrupt_sequence_break[] = "BREAK";
822 const char interrupt_sequence_break_g[] = "BREAK-g";
823 static const char *const interrupt_sequence_modes[] =
824   {
825     interrupt_sequence_control_c,
826     interrupt_sequence_break,
827     interrupt_sequence_break_g,
828     NULL
829   };
830 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
831
832 static void
833 show_interrupt_sequence (struct ui_file *file, int from_tty,
834                          struct cmd_list_element *c,
835                          const char *value)
836 {
837   if (interrupt_sequence_mode == interrupt_sequence_control_c)
838     fprintf_filtered (file,
839                       _("Send the ASCII ETX character (Ctrl-c) "
840                         "to the remote target to interrupt the "
841                         "execution of the program.\n"));
842   else if (interrupt_sequence_mode == interrupt_sequence_break)
843     fprintf_filtered (file,
844                       _("send a break signal to the remote target "
845                         "to interrupt the execution of the program.\n"));
846   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
847     fprintf_filtered (file,
848                       _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
849                         "the remote target to interrupt the execution "
850                         "of Linux kernel.\n"));
851   else
852     internal_error (__FILE__, __LINE__,
853                     _("Invalid value for interrupt_sequence_mode: %s."),
854                     interrupt_sequence_mode);
855 }
856
857 /* This boolean variable specifies whether interrupt_sequence is sent
858    to the remote target when gdb connects to it.
859    This is mostly needed when you debug the Linux kernel: The Linux kernel
860    expects BREAK g which is Magic SysRq g for connecting gdb.  */
861 static int interrupt_on_connect = 0;
862
863 /* This variable is used to implement the "set/show remotebreak" commands.
864    Since these commands are now deprecated in favor of "set/show remote
865    interrupt-sequence", it no longer has any effect on the code.  */
866 static int remote_break;
867
868 static void
869 set_remotebreak (char *args, int from_tty, struct cmd_list_element *c)
870 {
871   if (remote_break)
872     interrupt_sequence_mode = interrupt_sequence_break;
873   else
874     interrupt_sequence_mode = interrupt_sequence_control_c;
875 }
876
877 static void
878 show_remotebreak (struct ui_file *file, int from_tty,
879                   struct cmd_list_element *c,
880                   const char *value)
881 {
882 }
883
884 /* This variable sets the number of bits in an address that are to be
885    sent in a memory ("M" or "m") packet.  Normally, after stripping
886    leading zeros, the entire address would be sent.  This variable
887    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
888    initial implementation of remote.c restricted the address sent in
889    memory packets to ``host::sizeof long'' bytes - (typically 32
890    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
891    address was never sent.  Since fixing this bug may cause a break in
892    some remote targets this variable is principly provided to
893    facilitate backward compatibility.  */
894
895 static unsigned int remote_address_size;
896
897 /* Temporary to track who currently owns the terminal.  See
898    remote_terminal_* for more details.  */
899
900 static int remote_async_terminal_ours_p;
901
902 /* The executable file to use for "run" on the remote side.  */
903
904 static char *remote_exec_file = "";
905
906 \f
907 /* User configurable variables for the number of characters in a
908    memory read/write packet.  MIN (rsa->remote_packet_size,
909    rsa->sizeof_g_packet) is the default.  Some targets need smaller
910    values (fifo overruns, et.al.) and some users need larger values
911    (speed up transfers).  The variables ``preferred_*'' (the user
912    request), ``current_*'' (what was actually set) and ``forced_*''
913    (Positive - a soft limit, negative - a hard limit).  */
914
915 struct memory_packet_config
916 {
917   char *name;
918   long size;
919   int fixed_p;
920 };
921
922 /* Compute the current size of a read/write packet.  Since this makes
923    use of ``actual_register_packet_size'' the computation is dynamic.  */
924
925 static long
926 get_memory_packet_size (struct memory_packet_config *config)
927 {
928   struct remote_state *rs = get_remote_state ();
929   struct remote_arch_state *rsa = get_remote_arch_state ();
930
931   /* NOTE: The somewhat arbitrary 16k comes from the knowledge (folk
932      law?) that some hosts don't cope very well with large alloca()
933      calls.  Eventually the alloca() code will be replaced by calls to
934      xmalloc() and make_cleanups() allowing this restriction to either
935      be lifted or removed.  */
936 #ifndef MAX_REMOTE_PACKET_SIZE
937 #define MAX_REMOTE_PACKET_SIZE 16384
938 #endif
939   /* NOTE: 20 ensures we can write at least one byte.  */
940 #ifndef MIN_REMOTE_PACKET_SIZE
941 #define MIN_REMOTE_PACKET_SIZE 20
942 #endif
943   long what_they_get;
944   if (config->fixed_p)
945     {
946       if (config->size <= 0)
947         what_they_get = MAX_REMOTE_PACKET_SIZE;
948       else
949         what_they_get = config->size;
950     }
951   else
952     {
953       what_they_get = get_remote_packet_size ();
954       /* Limit the packet to the size specified by the user.  */
955       if (config->size > 0
956           && what_they_get > config->size)
957         what_they_get = config->size;
958
959       /* Limit it to the size of the targets ``g'' response unless we have
960          permission from the stub to use a larger packet size.  */
961       if (rs->explicit_packet_size == 0
962           && rsa->actual_register_packet_size > 0
963           && what_they_get > rsa->actual_register_packet_size)
964         what_they_get = rsa->actual_register_packet_size;
965     }
966   if (what_they_get > MAX_REMOTE_PACKET_SIZE)
967     what_they_get = MAX_REMOTE_PACKET_SIZE;
968   if (what_they_get < MIN_REMOTE_PACKET_SIZE)
969     what_they_get = MIN_REMOTE_PACKET_SIZE;
970
971   /* Make sure there is room in the global buffer for this packet
972      (including its trailing NUL byte).  */
973   if (rs->buf_size < what_they_get + 1)
974     {
975       rs->buf_size = 2 * what_they_get;
976       rs->buf = xrealloc (rs->buf, 2 * what_they_get);
977     }
978
979   return what_they_get;
980 }
981
982 /* Update the size of a read/write packet.  If they user wants
983    something really big then do a sanity check.  */
984
985 static void
986 set_memory_packet_size (char *args, struct memory_packet_config *config)
987 {
988   int fixed_p = config->fixed_p;
989   long size = config->size;
990
991   if (args == NULL)
992     error (_("Argument required (integer, `fixed' or `limited')."));
993   else if (strcmp (args, "hard") == 0
994       || strcmp (args, "fixed") == 0)
995     fixed_p = 1;
996   else if (strcmp (args, "soft") == 0
997            || strcmp (args, "limit") == 0)
998     fixed_p = 0;
999   else
1000     {
1001       char *end;
1002
1003       size = strtoul (args, &end, 0);
1004       if (args == end)
1005         error (_("Invalid %s (bad syntax)."), config->name);
1006 #if 0
1007       /* Instead of explicitly capping the size of a packet to
1008          MAX_REMOTE_PACKET_SIZE or dissallowing it, the user is
1009          instead allowed to set the size to something arbitrarily
1010          large.  */
1011       if (size > MAX_REMOTE_PACKET_SIZE)
1012         error (_("Invalid %s (too large)."), config->name);
1013 #endif
1014     }
1015   /* Extra checks?  */
1016   if (fixed_p && !config->fixed_p)
1017     {
1018       if (! query (_("The target may not be able to correctly handle a %s\n"
1019                    "of %ld bytes. Change the packet size? "),
1020                    config->name, size))
1021         error (_("Packet size not changed."));
1022     }
1023   /* Update the config.  */
1024   config->fixed_p = fixed_p;
1025   config->size = size;
1026 }
1027
1028 static void
1029 show_memory_packet_size (struct memory_packet_config *config)
1030 {
1031   printf_filtered (_("The %s is %ld. "), config->name, config->size);
1032   if (config->fixed_p)
1033     printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1034                      get_memory_packet_size (config));
1035   else
1036     printf_filtered (_("Packets are limited to %ld bytes.\n"),
1037                      get_memory_packet_size (config));
1038 }
1039
1040 static struct memory_packet_config memory_write_packet_config =
1041 {
1042   "memory-write-packet-size",
1043 };
1044
1045 static void
1046 set_memory_write_packet_size (char *args, int from_tty)
1047 {
1048   set_memory_packet_size (args, &memory_write_packet_config);
1049 }
1050
1051 static void
1052 show_memory_write_packet_size (char *args, int from_tty)
1053 {
1054   show_memory_packet_size (&memory_write_packet_config);
1055 }
1056
1057 static long
1058 get_memory_write_packet_size (void)
1059 {
1060   return get_memory_packet_size (&memory_write_packet_config);
1061 }
1062
1063 static struct memory_packet_config memory_read_packet_config =
1064 {
1065   "memory-read-packet-size",
1066 };
1067
1068 static void
1069 set_memory_read_packet_size (char *args, int from_tty)
1070 {
1071   set_memory_packet_size (args, &memory_read_packet_config);
1072 }
1073
1074 static void
1075 show_memory_read_packet_size (char *args, int from_tty)
1076 {
1077   show_memory_packet_size (&memory_read_packet_config);
1078 }
1079
1080 static long
1081 get_memory_read_packet_size (void)
1082 {
1083   long size = get_memory_packet_size (&memory_read_packet_config);
1084
1085   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1086      extra buffer size argument before the memory read size can be
1087      increased beyond this.  */
1088   if (size > get_remote_packet_size ())
1089     size = get_remote_packet_size ();
1090   return size;
1091 }
1092
1093 \f
1094 /* Generic configuration support for packets the stub optionally
1095    supports.  Allows the user to specify the use of the packet as well
1096    as allowing GDB to auto-detect support in the remote stub.  */
1097
1098 enum packet_support
1099   {
1100     PACKET_SUPPORT_UNKNOWN = 0,
1101     PACKET_ENABLE,
1102     PACKET_DISABLE
1103   };
1104
1105 struct packet_config
1106   {
1107     const char *name;
1108     const char *title;
1109     enum auto_boolean detect;
1110     enum packet_support support;
1111   };
1112
1113 /* Analyze a packet's return value and update the packet config
1114    accordingly.  */
1115
1116 enum packet_result
1117 {
1118   PACKET_ERROR,
1119   PACKET_OK,
1120   PACKET_UNKNOWN
1121 };
1122
1123 static void
1124 update_packet_config (struct packet_config *config)
1125 {
1126   switch (config->detect)
1127     {
1128     case AUTO_BOOLEAN_TRUE:
1129       config->support = PACKET_ENABLE;
1130       break;
1131     case AUTO_BOOLEAN_FALSE:
1132       config->support = PACKET_DISABLE;
1133       break;
1134     case AUTO_BOOLEAN_AUTO:
1135       config->support = PACKET_SUPPORT_UNKNOWN;
1136       break;
1137     }
1138 }
1139
1140 static void
1141 show_packet_config_cmd (struct packet_config *config)
1142 {
1143   char *support = "internal-error";
1144
1145   switch (config->support)
1146     {
1147     case PACKET_ENABLE:
1148       support = "enabled";
1149       break;
1150     case PACKET_DISABLE:
1151       support = "disabled";
1152       break;
1153     case PACKET_SUPPORT_UNKNOWN:
1154       support = "unknown";
1155       break;
1156     }
1157   switch (config->detect)
1158     {
1159     case AUTO_BOOLEAN_AUTO:
1160       printf_filtered (_("Support for the `%s' packet "
1161                          "is auto-detected, currently %s.\n"),
1162                        config->name, support);
1163       break;
1164     case AUTO_BOOLEAN_TRUE:
1165     case AUTO_BOOLEAN_FALSE:
1166       printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1167                        config->name, support);
1168       break;
1169     }
1170 }
1171
1172 static void
1173 add_packet_config_cmd (struct packet_config *config, const char *name,
1174                        const char *title, int legacy)
1175 {
1176   char *set_doc;
1177   char *show_doc;
1178   char *cmd_name;
1179
1180   config->name = name;
1181   config->title = title;
1182   config->detect = AUTO_BOOLEAN_AUTO;
1183   config->support = PACKET_SUPPORT_UNKNOWN;
1184   set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1185                         name, title);
1186   show_doc = xstrprintf ("Show current use of remote "
1187                          "protocol `%s' (%s) packet",
1188                          name, title);
1189   /* set/show TITLE-packet {auto,on,off} */
1190   cmd_name = xstrprintf ("%s-packet", title);
1191   add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1192                                 &config->detect, set_doc,
1193                                 show_doc, NULL, /* help_doc */
1194                                 set_remote_protocol_packet_cmd,
1195                                 show_remote_protocol_packet_cmd,
1196                                 &remote_set_cmdlist, &remote_show_cmdlist);
1197   /* The command code copies the documentation strings.  */
1198   xfree (set_doc);
1199   xfree (show_doc);
1200   /* set/show remote NAME-packet {auto,on,off} -- legacy.  */
1201   if (legacy)
1202     {
1203       char *legacy_name;
1204
1205       legacy_name = xstrprintf ("%s-packet", name);
1206       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1207                      &remote_set_cmdlist);
1208       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1209                      &remote_show_cmdlist);
1210     }
1211 }
1212
1213 static enum packet_result
1214 packet_check_result (const char *buf)
1215 {
1216   if (buf[0] != '\0')
1217     {
1218       /* The stub recognized the packet request.  Check that the
1219          operation succeeded.  */
1220       if (buf[0] == 'E'
1221           && isxdigit (buf[1]) && isxdigit (buf[2])
1222           && buf[3] == '\0')
1223         /* "Enn"  - definitly an error.  */
1224         return PACKET_ERROR;
1225
1226       /* Always treat "E." as an error.  This will be used for
1227          more verbose error messages, such as E.memtypes.  */
1228       if (buf[0] == 'E' && buf[1] == '.')
1229         return PACKET_ERROR;
1230
1231       /* The packet may or may not be OK.  Just assume it is.  */
1232       return PACKET_OK;
1233     }
1234   else
1235     /* The stub does not support the packet.  */
1236     return PACKET_UNKNOWN;
1237 }
1238
1239 static enum packet_result
1240 packet_ok (const char *buf, struct packet_config *config)
1241 {
1242   enum packet_result result;
1243
1244   result = packet_check_result (buf);
1245   switch (result)
1246     {
1247     case PACKET_OK:
1248     case PACKET_ERROR:
1249       /* The stub recognized the packet request.  */
1250       switch (config->support)
1251         {
1252         case PACKET_SUPPORT_UNKNOWN:
1253           if (remote_debug)
1254             fprintf_unfiltered (gdb_stdlog,
1255                                     "Packet %s (%s) is supported\n",
1256                                     config->name, config->title);
1257           config->support = PACKET_ENABLE;
1258           break;
1259         case PACKET_DISABLE:
1260           internal_error (__FILE__, __LINE__,
1261                           _("packet_ok: attempt to use a disabled packet"));
1262           break;
1263         case PACKET_ENABLE:
1264           break;
1265         }
1266       break;
1267     case PACKET_UNKNOWN:
1268       /* The stub does not support the packet.  */
1269       switch (config->support)
1270         {
1271         case PACKET_ENABLE:
1272           if (config->detect == AUTO_BOOLEAN_AUTO)
1273             /* If the stub previously indicated that the packet was
1274                supported then there is a protocol error..  */
1275             error (_("Protocol error: %s (%s) conflicting enabled responses."),
1276                    config->name, config->title);
1277           else
1278             /* The user set it wrong.  */
1279             error (_("Enabled packet %s (%s) not recognized by stub"),
1280                    config->name, config->title);
1281           break;
1282         case PACKET_SUPPORT_UNKNOWN:
1283           if (remote_debug)
1284             fprintf_unfiltered (gdb_stdlog,
1285                                 "Packet %s (%s) is NOT supported\n",
1286                                 config->name, config->title);
1287           config->support = PACKET_DISABLE;
1288           break;
1289         case PACKET_DISABLE:
1290           break;
1291         }
1292       break;
1293     }
1294
1295   return result;
1296 }
1297
1298 enum {
1299   PACKET_vCont = 0,
1300   PACKET_X,
1301   PACKET_qSymbol,
1302   PACKET_P,
1303   PACKET_p,
1304   PACKET_Z0,
1305   PACKET_Z1,
1306   PACKET_Z2,
1307   PACKET_Z3,
1308   PACKET_Z4,
1309   PACKET_vFile_open,
1310   PACKET_vFile_pread,
1311   PACKET_vFile_pwrite,
1312   PACKET_vFile_close,
1313   PACKET_vFile_unlink,
1314   PACKET_vFile_readlink,
1315   PACKET_qXfer_auxv,
1316   PACKET_qXfer_features,
1317   PACKET_qXfer_libraries,
1318   PACKET_qXfer_libraries_svr4,
1319   PACKET_qXfer_memory_map,
1320   PACKET_qXfer_spu_read,
1321   PACKET_qXfer_spu_write,
1322   PACKET_qXfer_osdata,
1323   PACKET_qXfer_threads,
1324   PACKET_qXfer_statictrace_read,
1325   PACKET_qXfer_traceframe_info,
1326   PACKET_qXfer_uib,
1327   PACKET_qGetTIBAddr,
1328   PACKET_qGetTLSAddr,
1329   PACKET_qSupported,
1330   PACKET_qTStatus,
1331   PACKET_QPassSignals,
1332   PACKET_QProgramSignals,
1333   PACKET_qSearch_memory,
1334   PACKET_vAttach,
1335   PACKET_vRun,
1336   PACKET_QStartNoAckMode,
1337   PACKET_vKill,
1338   PACKET_qXfer_siginfo_read,
1339   PACKET_qXfer_siginfo_write,
1340   PACKET_qAttached,
1341   PACKET_ConditionalTracepoints,
1342   PACKET_ConditionalBreakpoints,
1343   PACKET_BreakpointCommands,
1344   PACKET_FastTracepoints,
1345   PACKET_StaticTracepoints,
1346   PACKET_InstallInTrace,
1347   PACKET_bc,
1348   PACKET_bs,
1349   PACKET_TracepointSource,
1350   PACKET_QAllow,
1351   PACKET_qXfer_fdpic,
1352   PACKET_QDisableRandomization,
1353   PACKET_QAgent,
1354   PACKET_QTBuffer_size,
1355   PACKET_Qbtrace_off,
1356   PACKET_Qbtrace_bts,
1357   PACKET_qXfer_btrace,
1358   PACKET_MAX
1359 };
1360
1361 static struct packet_config remote_protocol_packets[PACKET_MAX];
1362
1363 static void
1364 set_remote_protocol_packet_cmd (char *args, int from_tty,
1365                                 struct cmd_list_element *c)
1366 {
1367   struct packet_config *packet;
1368
1369   for (packet = remote_protocol_packets;
1370        packet < &remote_protocol_packets[PACKET_MAX];
1371        packet++)
1372     {
1373       if (&packet->detect == c->var)
1374         {
1375           update_packet_config (packet);
1376           return;
1377         }
1378     }
1379   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1380                   c->name);
1381 }
1382
1383 static void
1384 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
1385                                  struct cmd_list_element *c,
1386                                  const char *value)
1387 {
1388   struct packet_config *packet;
1389
1390   for (packet = remote_protocol_packets;
1391        packet < &remote_protocol_packets[PACKET_MAX];
1392        packet++)
1393     {
1394       if (&packet->detect == c->var)
1395         {
1396           show_packet_config_cmd (packet);
1397           return;
1398         }
1399     }
1400   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1401                   c->name);
1402 }
1403
1404 /* Should we try one of the 'Z' requests?  */
1405
1406 enum Z_packet_type
1407 {
1408   Z_PACKET_SOFTWARE_BP,
1409   Z_PACKET_HARDWARE_BP,
1410   Z_PACKET_WRITE_WP,
1411   Z_PACKET_READ_WP,
1412   Z_PACKET_ACCESS_WP,
1413   NR_Z_PACKET_TYPES
1414 };
1415
1416 /* For compatibility with older distributions.  Provide a ``set remote
1417    Z-packet ...'' command that updates all the Z packet types.  */
1418
1419 static enum auto_boolean remote_Z_packet_detect;
1420
1421 static void
1422 set_remote_protocol_Z_packet_cmd (char *args, int from_tty,
1423                                   struct cmd_list_element *c)
1424 {
1425   int i;
1426
1427   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1428     {
1429       remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1430       update_packet_config (&remote_protocol_packets[PACKET_Z0 + i]);
1431     }
1432 }
1433
1434 static void
1435 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1436                                    struct cmd_list_element *c,
1437                                    const char *value)
1438 {
1439   int i;
1440
1441   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1442     {
1443       show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1444     }
1445 }
1446
1447 /* Tokens for use by the asynchronous signal handlers for SIGINT.  */
1448 static struct async_signal_handler *async_sigint_remote_twice_token;
1449 static struct async_signal_handler *async_sigint_remote_token;
1450
1451 \f
1452 /* Asynchronous signal handle registered as event loop source for
1453    when we have pending events ready to be passed to the core.  */
1454
1455 static struct async_event_handler *remote_async_inferior_event_token;
1456
1457 \f
1458
1459 static ptid_t magic_null_ptid;
1460 static ptid_t not_sent_ptid;
1461 static ptid_t any_thread_ptid;
1462
1463 /* Find out if the stub attached to PID (and hence GDB should offer to
1464    detach instead of killing it when bailing out).  */
1465
1466 static int
1467 remote_query_attached (int pid)
1468 {
1469   struct remote_state *rs = get_remote_state ();
1470   size_t size = get_remote_packet_size ();
1471
1472   if (remote_protocol_packets[PACKET_qAttached].support == PACKET_DISABLE)
1473     return 0;
1474
1475   if (remote_multi_process_p (rs))
1476     xsnprintf (rs->buf, size, "qAttached:%x", pid);
1477   else
1478     xsnprintf (rs->buf, size, "qAttached");
1479
1480   putpkt (rs->buf);
1481   getpkt (&rs->buf, &rs->buf_size, 0);
1482
1483   switch (packet_ok (rs->buf,
1484                      &remote_protocol_packets[PACKET_qAttached]))
1485     {
1486     case PACKET_OK:
1487       if (strcmp (rs->buf, "1") == 0)
1488         return 1;
1489       break;
1490     case PACKET_ERROR:
1491       warning (_("Remote failure reply: %s"), rs->buf);
1492       break;
1493     case PACKET_UNKNOWN:
1494       break;
1495     }
1496
1497   return 0;
1498 }
1499
1500 /* Add PID to GDB's inferior table.  If FAKE_PID_P is true, then PID
1501    has been invented by GDB, instead of reported by the target.  Since
1502    we can be connected to a remote system before before knowing about
1503    any inferior, mark the target with execution when we find the first
1504    inferior.  If ATTACHED is 1, then we had just attached to this
1505    inferior.  If it is 0, then we just created this inferior.  If it
1506    is -1, then try querying the remote stub to find out if it had
1507    attached to the inferior or not.  */
1508
1509 static struct inferior *
1510 remote_add_inferior (int fake_pid_p, int pid, int attached)
1511 {
1512   struct inferior *inf;
1513
1514   /* Check whether this process we're learning about is to be
1515      considered attached, or if is to be considered to have been
1516      spawned by the stub.  */
1517   if (attached == -1)
1518     attached = remote_query_attached (pid);
1519
1520   if (gdbarch_has_global_solist (target_gdbarch ()))
1521     {
1522       /* If the target shares code across all inferiors, then every
1523          attach adds a new inferior.  */
1524       inf = add_inferior (pid);
1525
1526       /* ... and every inferior is bound to the same program space.
1527          However, each inferior may still have its own address
1528          space.  */
1529       inf->aspace = maybe_new_address_space ();
1530       inf->pspace = current_program_space;
1531     }
1532   else
1533     {
1534       /* In the traditional debugging scenario, there's a 1-1 match
1535          between program/address spaces.  We simply bind the inferior
1536          to the program space's address space.  */
1537       inf = current_inferior ();
1538       inferior_appeared (inf, pid);
1539     }
1540
1541   inf->attach_flag = attached;
1542   inf->fake_pid_p = fake_pid_p;
1543
1544   return inf;
1545 }
1546
1547 /* Add thread PTID to GDB's thread list.  Tag it as executing/running
1548    according to RUNNING.  */
1549
1550 static void
1551 remote_add_thread (ptid_t ptid, int running)
1552 {
1553   add_thread (ptid);
1554
1555   set_executing (ptid, running);
1556   set_running (ptid, running);
1557 }
1558
1559 /* Come here when we learn about a thread id from the remote target.
1560    It may be the first time we hear about such thread, so take the
1561    opportunity to add it to GDB's thread list.  In case this is the
1562    first time we're noticing its corresponding inferior, add it to
1563    GDB's inferior list as well.  */
1564
1565 static void
1566 remote_notice_new_inferior (ptid_t currthread, int running)
1567 {
1568   /* If this is a new thread, add it to GDB's thread list.
1569      If we leave it up to WFI to do this, bad things will happen.  */
1570
1571   if (in_thread_list (currthread) && is_exited (currthread))
1572     {
1573       /* We're seeing an event on a thread id we knew had exited.
1574          This has to be a new thread reusing the old id.  Add it.  */
1575       remote_add_thread (currthread, running);
1576       return;
1577     }
1578
1579   if (!in_thread_list (currthread))
1580     {
1581       struct inferior *inf = NULL;
1582       int pid = ptid_get_pid (currthread);
1583
1584       if (ptid_is_pid (inferior_ptid)
1585           && pid == ptid_get_pid (inferior_ptid))
1586         {
1587           /* inferior_ptid has no thread member yet.  This can happen
1588              with the vAttach -> remote_wait,"TAAthread:" path if the
1589              stub doesn't support qC.  This is the first stop reported
1590              after an attach, so this is the main thread.  Update the
1591              ptid in the thread list.  */
1592           if (in_thread_list (pid_to_ptid (pid)))
1593             thread_change_ptid (inferior_ptid, currthread);
1594           else
1595             {
1596               remote_add_thread (currthread, running);
1597               inferior_ptid = currthread;
1598             }
1599           return;
1600         }
1601
1602       if (ptid_equal (magic_null_ptid, inferior_ptid))
1603         {
1604           /* inferior_ptid is not set yet.  This can happen with the
1605              vRun -> remote_wait,"TAAthread:" path if the stub
1606              doesn't support qC.  This is the first stop reported
1607              after an attach, so this is the main thread.  Update the
1608              ptid in the thread list.  */
1609           thread_change_ptid (inferior_ptid, currthread);
1610           return;
1611         }
1612
1613       /* When connecting to a target remote, or to a target
1614          extended-remote which already was debugging an inferior, we
1615          may not know about it yet.  Add it before adding its child
1616          thread, so notifications are emitted in a sensible order.  */
1617       if (!in_inferior_list (ptid_get_pid (currthread)))
1618         {
1619           struct remote_state *rs = get_remote_state ();
1620           int fake_pid_p = !remote_multi_process_p (rs);
1621
1622           inf = remote_add_inferior (fake_pid_p,
1623                                      ptid_get_pid (currthread), -1);
1624         }
1625
1626       /* This is really a new thread.  Add it.  */
1627       remote_add_thread (currthread, running);
1628
1629       /* If we found a new inferior, let the common code do whatever
1630          it needs to with it (e.g., read shared libraries, insert
1631          breakpoints).  */
1632       if (inf != NULL)
1633         notice_new_inferior (currthread, running, 0);
1634     }
1635 }
1636
1637 /* Return the private thread data, creating it if necessary.  */
1638
1639 static struct private_thread_info *
1640 demand_private_info (ptid_t ptid)
1641 {
1642   struct thread_info *info = find_thread_ptid (ptid);
1643
1644   gdb_assert (info);
1645
1646   if (!info->private)
1647     {
1648       info->private = xmalloc (sizeof (*(info->private)));
1649       info->private_dtor = free_private_thread_info;
1650       info->private->core = -1;
1651       info->private->extra = 0;
1652     }
1653
1654   return info->private;
1655 }
1656
1657 /* Call this function as a result of
1658    1) A halt indication (T packet) containing a thread id
1659    2) A direct query of currthread
1660    3) Successful execution of set thread */
1661
1662 static void
1663 record_currthread (struct remote_state *rs, ptid_t currthread)
1664 {
1665   rs->general_thread = currthread;
1666 }
1667
1668 /* If 'QPassSignals' is supported, tell the remote stub what signals
1669    it can simply pass through to the inferior without reporting.  */
1670
1671 static void
1672 remote_pass_signals (int numsigs, unsigned char *pass_signals)
1673 {
1674   if (remote_protocol_packets[PACKET_QPassSignals].support != PACKET_DISABLE)
1675     {
1676       char *pass_packet, *p;
1677       int count = 0, i;
1678       struct remote_state *rs = get_remote_state ();
1679
1680       gdb_assert (numsigs < 256);
1681       for (i = 0; i < numsigs; i++)
1682         {
1683           if (pass_signals[i])
1684             count++;
1685         }
1686       pass_packet = xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
1687       strcpy (pass_packet, "QPassSignals:");
1688       p = pass_packet + strlen (pass_packet);
1689       for (i = 0; i < numsigs; i++)
1690         {
1691           if (pass_signals[i])
1692             {
1693               if (i >= 16)
1694                 *p++ = tohex (i >> 4);
1695               *p++ = tohex (i & 15);
1696               if (count)
1697                 *p++ = ';';
1698               else
1699                 break;
1700               count--;
1701             }
1702         }
1703       *p = 0;
1704       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
1705         {
1706           char *buf = rs->buf;
1707
1708           putpkt (pass_packet);
1709           getpkt (&rs->buf, &rs->buf_size, 0);
1710           packet_ok (buf, &remote_protocol_packets[PACKET_QPassSignals]);
1711           if (rs->last_pass_packet)
1712             xfree (rs->last_pass_packet);
1713           rs->last_pass_packet = pass_packet;
1714         }
1715       else
1716         xfree (pass_packet);
1717     }
1718 }
1719
1720 /* If 'QProgramSignals' is supported, tell the remote stub what
1721    signals it should pass through to the inferior when detaching.  */
1722
1723 static void
1724 remote_program_signals (int numsigs, unsigned char *signals)
1725 {
1726   if (remote_protocol_packets[PACKET_QProgramSignals].support != PACKET_DISABLE)
1727     {
1728       char *packet, *p;
1729       int count = 0, i;
1730       struct remote_state *rs = get_remote_state ();
1731
1732       gdb_assert (numsigs < 256);
1733       for (i = 0; i < numsigs; i++)
1734         {
1735           if (signals[i])
1736             count++;
1737         }
1738       packet = xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
1739       strcpy (packet, "QProgramSignals:");
1740       p = packet + strlen (packet);
1741       for (i = 0; i < numsigs; i++)
1742         {
1743           if (signal_pass_state (i))
1744             {
1745               if (i >= 16)
1746                 *p++ = tohex (i >> 4);
1747               *p++ = tohex (i & 15);
1748               if (count)
1749                 *p++ = ';';
1750               else
1751                 break;
1752               count--;
1753             }
1754         }
1755       *p = 0;
1756       if (!rs->last_program_signals_packet
1757           || strcmp (rs->last_program_signals_packet, packet) != 0)
1758         {
1759           char *buf = rs->buf;
1760
1761           putpkt (packet);
1762           getpkt (&rs->buf, &rs->buf_size, 0);
1763           packet_ok (buf, &remote_protocol_packets[PACKET_QProgramSignals]);
1764           xfree (rs->last_program_signals_packet);
1765           rs->last_program_signals_packet = packet;
1766         }
1767       else
1768         xfree (packet);
1769     }
1770 }
1771
1772 /* If PTID is MAGIC_NULL_PTID, don't set any thread.  If PTID is
1773    MINUS_ONE_PTID, set the thread to -1, so the stub returns the
1774    thread.  If GEN is set, set the general thread, if not, then set
1775    the step/continue thread.  */
1776 static void
1777 set_thread (struct ptid ptid, int gen)
1778 {
1779   struct remote_state *rs = get_remote_state ();
1780   ptid_t state = gen ? rs->general_thread : rs->continue_thread;
1781   char *buf = rs->buf;
1782   char *endbuf = rs->buf + get_remote_packet_size ();
1783
1784   if (ptid_equal (state, ptid))
1785     return;
1786
1787   *buf++ = 'H';
1788   *buf++ = gen ? 'g' : 'c';
1789   if (ptid_equal (ptid, magic_null_ptid))
1790     xsnprintf (buf, endbuf - buf, "0");
1791   else if (ptid_equal (ptid, any_thread_ptid))
1792     xsnprintf (buf, endbuf - buf, "0");
1793   else if (ptid_equal (ptid, minus_one_ptid))
1794     xsnprintf (buf, endbuf - buf, "-1");
1795   else
1796     write_ptid (buf, endbuf, ptid);
1797   putpkt (rs->buf);
1798   getpkt (&rs->buf, &rs->buf_size, 0);
1799   if (gen)
1800     rs->general_thread = ptid;
1801   else
1802     rs->continue_thread = ptid;
1803 }
1804
1805 static void
1806 set_general_thread (struct ptid ptid)
1807 {
1808   set_thread (ptid, 1);
1809 }
1810
1811 static void
1812 set_continue_thread (struct ptid ptid)
1813 {
1814   set_thread (ptid, 0);
1815 }
1816
1817 /* Change the remote current process.  Which thread within the process
1818    ends up selected isn't important, as long as it is the same process
1819    as what INFERIOR_PTID points to.
1820
1821    This comes from that fact that there is no explicit notion of
1822    "selected process" in the protocol.  The selected process for
1823    general operations is the process the selected general thread
1824    belongs to.  */
1825
1826 static void
1827 set_general_process (void)
1828 {
1829   struct remote_state *rs = get_remote_state ();
1830
1831   /* If the remote can't handle multiple processes, don't bother.  */
1832   if (!rs->extended || !remote_multi_process_p (rs))
1833     return;
1834
1835   /* We only need to change the remote current thread if it's pointing
1836      at some other process.  */
1837   if (ptid_get_pid (rs->general_thread) != ptid_get_pid (inferior_ptid))
1838     set_general_thread (inferior_ptid);
1839 }
1840
1841 \f
1842 /*  Return nonzero if the thread PTID is still alive on the remote
1843     system.  */
1844
1845 static int
1846 remote_thread_alive (struct target_ops *ops, ptid_t ptid)
1847 {
1848   struct remote_state *rs = get_remote_state ();
1849   char *p, *endp;
1850
1851   if (ptid_equal (ptid, magic_null_ptid))
1852     /* The main thread is always alive.  */
1853     return 1;
1854
1855   if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0)
1856     /* The main thread is always alive.  This can happen after a
1857        vAttach, if the remote side doesn't support
1858        multi-threading.  */
1859     return 1;
1860
1861   p = rs->buf;
1862   endp = rs->buf + get_remote_packet_size ();
1863
1864   *p++ = 'T';
1865   write_ptid (p, endp, ptid);
1866
1867   putpkt (rs->buf);
1868   getpkt (&rs->buf, &rs->buf_size, 0);
1869   return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
1870 }
1871
1872 /* About these extended threadlist and threadinfo packets.  They are
1873    variable length packets but, the fields within them are often fixed
1874    length.  They are redundent enough to send over UDP as is the
1875    remote protocol in general.  There is a matching unit test module
1876    in libstub.  */
1877
1878 #define OPAQUETHREADBYTES 8
1879
1880 /* a 64 bit opaque identifier */
1881 typedef unsigned char threadref[OPAQUETHREADBYTES];
1882
1883 /* WARNING: This threadref data structure comes from the remote O.S.,
1884    libstub protocol encoding, and remote.c.  It is not particularly
1885    changable.  */
1886
1887 /* Right now, the internal structure is int. We want it to be bigger.
1888    Plan to fix this.  */
1889
1890 typedef int gdb_threadref;      /* Internal GDB thread reference.  */
1891
1892 /* gdb_ext_thread_info is an internal GDB data structure which is
1893    equivalent to the reply of the remote threadinfo packet.  */
1894
1895 struct gdb_ext_thread_info
1896   {
1897     threadref threadid;         /* External form of thread reference.  */
1898     int active;                 /* Has state interesting to GDB?
1899                                    regs, stack.  */
1900     char display[256];          /* Brief state display, name,
1901                                    blocked/suspended.  */
1902     char shortname[32];         /* To be used to name threads.  */
1903     char more_display[256];     /* Long info, statistics, queue depth,
1904                                    whatever.  */
1905   };
1906
1907 /* The volume of remote transfers can be limited by submitting
1908    a mask containing bits specifying the desired information.
1909    Use a union of these values as the 'selection' parameter to
1910    get_thread_info.  FIXME: Make these TAG names more thread specific.  */
1911
1912 #define TAG_THREADID 1
1913 #define TAG_EXISTS 2
1914 #define TAG_DISPLAY 4
1915 #define TAG_THREADNAME 8
1916 #define TAG_MOREDISPLAY 16
1917
1918 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
1919
1920 char *unpack_varlen_hex (char *buff, ULONGEST *result);
1921
1922 static char *unpack_nibble (char *buf, int *val);
1923
1924 static char *pack_nibble (char *buf, int nibble);
1925
1926 static char *pack_hex_byte (char *pkt, int /* unsigned char */ byte);
1927
1928 static char *unpack_byte (char *buf, int *value);
1929
1930 static char *pack_int (char *buf, int value);
1931
1932 static char *unpack_int (char *buf, int *value);
1933
1934 static char *unpack_string (char *src, char *dest, int length);
1935
1936 static char *pack_threadid (char *pkt, threadref *id);
1937
1938 static char *unpack_threadid (char *inbuf, threadref *id);
1939
1940 void int_to_threadref (threadref *id, int value);
1941
1942 static int threadref_to_int (threadref *ref);
1943
1944 static void copy_threadref (threadref *dest, threadref *src);
1945
1946 static int threadmatch (threadref *dest, threadref *src);
1947
1948 static char *pack_threadinfo_request (char *pkt, int mode,
1949                                       threadref *id);
1950
1951 static int remote_unpack_thread_info_response (char *pkt,
1952                                                threadref *expectedref,
1953                                                struct gdb_ext_thread_info
1954                                                *info);
1955
1956
1957 static int remote_get_threadinfo (threadref *threadid,
1958                                   int fieldset, /*TAG mask */
1959                                   struct gdb_ext_thread_info *info);
1960
1961 static char *pack_threadlist_request (char *pkt, int startflag,
1962                                       int threadcount,
1963                                       threadref *nextthread);
1964
1965 static int parse_threadlist_response (char *pkt,
1966                                       int result_limit,
1967                                       threadref *original_echo,
1968                                       threadref *resultlist,
1969                                       int *doneflag);
1970
1971 static int remote_get_threadlist (int startflag,
1972                                   threadref *nextthread,
1973                                   int result_limit,
1974                                   int *done,
1975                                   int *result_count,
1976                                   threadref *threadlist);
1977
1978 typedef int (*rmt_thread_action) (threadref *ref, void *context);
1979
1980 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
1981                                        void *context, int looplimit);
1982
1983 static int remote_newthread_step (threadref *ref, void *context);
1984
1985
1986 /* Write a PTID to BUF.  ENDBUF points to one-passed-the-end of the
1987    buffer we're allowed to write to.  Returns
1988    BUF+CHARACTERS_WRITTEN.  */
1989
1990 static char *
1991 write_ptid (char *buf, const char *endbuf, ptid_t ptid)
1992 {
1993   int pid, tid;
1994   struct remote_state *rs = get_remote_state ();
1995
1996   if (remote_multi_process_p (rs))
1997     {
1998       pid = ptid_get_pid (ptid);
1999       if (pid < 0)
2000         buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2001       else
2002         buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2003     }
2004   tid = ptid_get_tid (ptid);
2005   if (tid < 0)
2006     buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2007   else
2008     buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2009
2010   return buf;
2011 }
2012
2013 /* Extract a PTID from BUF.  If non-null, OBUF is set to the to one
2014    passed the last parsed char.  Returns null_ptid on error.  */
2015
2016 static ptid_t
2017 read_ptid (char *buf, char **obuf)
2018 {
2019   char *p = buf;
2020   char *pp;
2021   ULONGEST pid = 0, tid = 0;
2022
2023   if (*p == 'p')
2024     {
2025       /* Multi-process ptid.  */
2026       pp = unpack_varlen_hex (p + 1, &pid);
2027       if (*pp != '.')
2028         error (_("invalid remote ptid: %s"), p);
2029
2030       p = pp;
2031       pp = unpack_varlen_hex (p + 1, &tid);
2032       if (obuf)
2033         *obuf = pp;
2034       return ptid_build (pid, 0, tid);
2035     }
2036
2037   /* No multi-process.  Just a tid.  */
2038   pp = unpack_varlen_hex (p, &tid);
2039
2040   /* Since the stub is not sending a process id, then default to
2041      what's in inferior_ptid, unless it's null at this point.  If so,
2042      then since there's no way to know the pid of the reported
2043      threads, use the magic number.  */
2044   if (ptid_equal (inferior_ptid, null_ptid))
2045     pid = ptid_get_pid (magic_null_ptid);
2046   else
2047     pid = ptid_get_pid (inferior_ptid);
2048
2049   if (obuf)
2050     *obuf = pp;
2051   return ptid_build (pid, 0, tid);
2052 }
2053
2054 /* Encode 64 bits in 16 chars of hex.  */
2055
2056 static const char hexchars[] = "0123456789abcdef";
2057
2058 static int
2059 ishex (int ch, int *val)
2060 {
2061   if ((ch >= 'a') && (ch <= 'f'))
2062     {
2063       *val = ch - 'a' + 10;
2064       return 1;
2065     }
2066   if ((ch >= 'A') && (ch <= 'F'))
2067     {
2068       *val = ch - 'A' + 10;
2069       return 1;
2070     }
2071   if ((ch >= '0') && (ch <= '9'))
2072     {
2073       *val = ch - '0';
2074       return 1;
2075     }
2076   return 0;
2077 }
2078
2079 static int
2080 stubhex (int ch)
2081 {
2082   if (ch >= 'a' && ch <= 'f')
2083     return ch - 'a' + 10;
2084   if (ch >= '0' && ch <= '9')
2085     return ch - '0';
2086   if (ch >= 'A' && ch <= 'F')
2087     return ch - 'A' + 10;
2088   return -1;
2089 }
2090
2091 static int
2092 stub_unpack_int (char *buff, int fieldlength)
2093 {
2094   int nibble;
2095   int retval = 0;
2096
2097   while (fieldlength)
2098     {
2099       nibble = stubhex (*buff++);
2100       retval |= nibble;
2101       fieldlength--;
2102       if (fieldlength)
2103         retval = retval << 4;
2104     }
2105   return retval;
2106 }
2107
2108 char *
2109 unpack_varlen_hex (char *buff,  /* packet to parse */
2110                    ULONGEST *result)
2111 {
2112   int nibble;
2113   ULONGEST retval = 0;
2114
2115   while (ishex (*buff, &nibble))
2116     {
2117       buff++;
2118       retval = retval << 4;
2119       retval |= nibble & 0x0f;
2120     }
2121   *result = retval;
2122   return buff;
2123 }
2124
2125 static char *
2126 unpack_nibble (char *buf, int *val)
2127 {
2128   *val = fromhex (*buf++);
2129   return buf;
2130 }
2131
2132 static char *
2133 pack_nibble (char *buf, int nibble)
2134 {
2135   *buf++ = hexchars[(nibble & 0x0f)];
2136   return buf;
2137 }
2138
2139 static char *
2140 pack_hex_byte (char *pkt, int byte)
2141 {
2142   *pkt++ = hexchars[(byte >> 4) & 0xf];
2143   *pkt++ = hexchars[(byte & 0xf)];
2144   return pkt;
2145 }
2146
2147 static char *
2148 unpack_byte (char *buf, int *value)
2149 {
2150   *value = stub_unpack_int (buf, 2);
2151   return buf + 2;
2152 }
2153
2154 static char *
2155 pack_int (char *buf, int value)
2156 {
2157   buf = pack_hex_byte (buf, (value >> 24) & 0xff);
2158   buf = pack_hex_byte (buf, (value >> 16) & 0xff);
2159   buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
2160   buf = pack_hex_byte (buf, (value & 0xff));
2161   return buf;
2162 }
2163
2164 static char *
2165 unpack_int (char *buf, int *value)
2166 {
2167   *value = stub_unpack_int (buf, 8);
2168   return buf + 8;
2169 }
2170
2171 #if 0                   /* Currently unused, uncomment when needed.  */
2172 static char *pack_string (char *pkt, char *string);
2173
2174 static char *
2175 pack_string (char *pkt, char *string)
2176 {
2177   char ch;
2178   int len;
2179
2180   len = strlen (string);
2181   if (len > 200)
2182     len = 200;          /* Bigger than most GDB packets, junk???  */
2183   pkt = pack_hex_byte (pkt, len);
2184   while (len-- > 0)
2185     {
2186       ch = *string++;
2187       if ((ch == '\0') || (ch == '#'))
2188         ch = '*';               /* Protect encapsulation.  */
2189       *pkt++ = ch;
2190     }
2191   return pkt;
2192 }
2193 #endif /* 0 (unused) */
2194
2195 static char *
2196 unpack_string (char *src, char *dest, int length)
2197 {
2198   while (length--)
2199     *dest++ = *src++;
2200   *dest = '\0';
2201   return src;
2202 }
2203
2204 static char *
2205 pack_threadid (char *pkt, threadref *id)
2206 {
2207   char *limit;
2208   unsigned char *altid;
2209
2210   altid = (unsigned char *) id;
2211   limit = pkt + BUF_THREAD_ID_SIZE;
2212   while (pkt < limit)
2213     pkt = pack_hex_byte (pkt, *altid++);
2214   return pkt;
2215 }
2216
2217
2218 static char *
2219 unpack_threadid (char *inbuf, threadref *id)
2220 {
2221   char *altref;
2222   char *limit = inbuf + BUF_THREAD_ID_SIZE;
2223   int x, y;
2224
2225   altref = (char *) id;
2226
2227   while (inbuf < limit)
2228     {
2229       x = stubhex (*inbuf++);
2230       y = stubhex (*inbuf++);
2231       *altref++ = (x << 4) | y;
2232     }
2233   return inbuf;
2234 }
2235
2236 /* Externally, threadrefs are 64 bits but internally, they are still
2237    ints.  This is due to a mismatch of specifications.  We would like
2238    to use 64bit thread references internally.  This is an adapter
2239    function.  */
2240
2241 void
2242 int_to_threadref (threadref *id, int value)
2243 {
2244   unsigned char *scan;
2245
2246   scan = (unsigned char *) id;
2247   {
2248     int i = 4;
2249     while (i--)
2250       *scan++ = 0;
2251   }
2252   *scan++ = (value >> 24) & 0xff;
2253   *scan++ = (value >> 16) & 0xff;
2254   *scan++ = (value >> 8) & 0xff;
2255   *scan++ = (value & 0xff);
2256 }
2257
2258 static int
2259 threadref_to_int (threadref *ref)
2260 {
2261   int i, value = 0;
2262   unsigned char *scan;
2263
2264   scan = *ref;
2265   scan += 4;
2266   i = 4;
2267   while (i-- > 0)
2268     value = (value << 8) | ((*scan++) & 0xff);
2269   return value;
2270 }
2271
2272 static void
2273 copy_threadref (threadref *dest, threadref *src)
2274 {
2275   int i;
2276   unsigned char *csrc, *cdest;
2277
2278   csrc = (unsigned char *) src;
2279   cdest = (unsigned char *) dest;
2280   i = 8;
2281   while (i--)
2282     *cdest++ = *csrc++;
2283 }
2284
2285 static int
2286 threadmatch (threadref *dest, threadref *src)
2287 {
2288   /* Things are broken right now, so just assume we got a match.  */
2289 #if 0
2290   unsigned char *srcp, *destp;
2291   int i, result;
2292   srcp = (char *) src;
2293   destp = (char *) dest;
2294
2295   result = 1;
2296   while (i-- > 0)
2297     result &= (*srcp++ == *destp++) ? 1 : 0;
2298   return result;
2299 #endif
2300   return 1;
2301 }
2302
2303 /*
2304    threadid:1,        # always request threadid
2305    context_exists:2,
2306    display:4,
2307    unique_name:8,
2308    more_display:16
2309  */
2310
2311 /* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
2312
2313 static char *
2314 pack_threadinfo_request (char *pkt, int mode, threadref *id)
2315 {
2316   *pkt++ = 'q';                         /* Info Query */
2317   *pkt++ = 'P';                         /* process or thread info */
2318   pkt = pack_int (pkt, mode);           /* mode */
2319   pkt = pack_threadid (pkt, id);        /* threadid */
2320   *pkt = '\0';                          /* terminate */
2321   return pkt;
2322 }
2323
2324 /* These values tag the fields in a thread info response packet.  */
2325 /* Tagging the fields allows us to request specific fields and to
2326    add more fields as time goes by.  */
2327
2328 #define TAG_THREADID 1          /* Echo the thread identifier.  */
2329 #define TAG_EXISTS 2            /* Is this process defined enough to
2330                                    fetch registers and its stack?  */
2331 #define TAG_DISPLAY 4           /* A short thing maybe to put on a window */
2332 #define TAG_THREADNAME 8        /* string, maps 1-to-1 with a thread is.  */
2333 #define TAG_MOREDISPLAY 16      /* Whatever the kernel wants to say about
2334                                    the process.  */
2335
2336 static int
2337 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
2338                                     struct gdb_ext_thread_info *info)
2339 {
2340   struct remote_state *rs = get_remote_state ();
2341   int mask, length;
2342   int tag;
2343   threadref ref;
2344   char *limit = pkt + rs->buf_size; /* Plausible parsing limit.  */
2345   int retval = 1;
2346
2347   /* info->threadid = 0; FIXME: implement zero_threadref.  */
2348   info->active = 0;
2349   info->display[0] = '\0';
2350   info->shortname[0] = '\0';
2351   info->more_display[0] = '\0';
2352
2353   /* Assume the characters indicating the packet type have been
2354      stripped.  */
2355   pkt = unpack_int (pkt, &mask);        /* arg mask */
2356   pkt = unpack_threadid (pkt, &ref);
2357
2358   if (mask == 0)
2359     warning (_("Incomplete response to threadinfo request."));
2360   if (!threadmatch (&ref, expectedref))
2361     {                   /* This is an answer to a different request.  */
2362       warning (_("ERROR RMT Thread info mismatch."));
2363       return 0;
2364     }
2365   copy_threadref (&info->threadid, &ref);
2366
2367   /* Loop on tagged fields , try to bail if somthing goes wrong.  */
2368
2369   /* Packets are terminated with nulls.  */
2370   while ((pkt < limit) && mask && *pkt)
2371     {
2372       pkt = unpack_int (pkt, &tag);     /* tag */
2373       pkt = unpack_byte (pkt, &length); /* length */
2374       if (!(tag & mask))                /* Tags out of synch with mask.  */
2375         {
2376           warning (_("ERROR RMT: threadinfo tag mismatch."));
2377           retval = 0;
2378           break;
2379         }
2380       if (tag == TAG_THREADID)
2381         {
2382           if (length != 16)
2383             {
2384               warning (_("ERROR RMT: length of threadid is not 16."));
2385               retval = 0;
2386               break;
2387             }
2388           pkt = unpack_threadid (pkt, &ref);
2389           mask = mask & ~TAG_THREADID;
2390           continue;
2391         }
2392       if (tag == TAG_EXISTS)
2393         {
2394           info->active = stub_unpack_int (pkt, length);
2395           pkt += length;
2396           mask = mask & ~(TAG_EXISTS);
2397           if (length > 8)
2398             {
2399               warning (_("ERROR RMT: 'exists' length too long."));
2400               retval = 0;
2401               break;
2402             }
2403           continue;
2404         }
2405       if (tag == TAG_THREADNAME)
2406         {
2407           pkt = unpack_string (pkt, &info->shortname[0], length);
2408           mask = mask & ~TAG_THREADNAME;
2409           continue;
2410         }
2411       if (tag == TAG_DISPLAY)
2412         {
2413           pkt = unpack_string (pkt, &info->display[0], length);
2414           mask = mask & ~TAG_DISPLAY;
2415           continue;
2416         }
2417       if (tag == TAG_MOREDISPLAY)
2418         {
2419           pkt = unpack_string (pkt, &info->more_display[0], length);
2420           mask = mask & ~TAG_MOREDISPLAY;
2421           continue;
2422         }
2423       warning (_("ERROR RMT: unknown thread info tag."));
2424       break;                    /* Not a tag we know about.  */
2425     }
2426   return retval;
2427 }
2428
2429 static int
2430 remote_get_threadinfo (threadref *threadid, int fieldset,       /* TAG mask */
2431                        struct gdb_ext_thread_info *info)
2432 {
2433   struct remote_state *rs = get_remote_state ();
2434   int result;
2435
2436   pack_threadinfo_request (rs->buf, fieldset, threadid);
2437   putpkt (rs->buf);
2438   getpkt (&rs->buf, &rs->buf_size, 0);
2439
2440   if (rs->buf[0] == '\0')
2441     return 0;
2442
2443   result = remote_unpack_thread_info_response (rs->buf + 2,
2444                                                threadid, info);
2445   return result;
2446 }
2447
2448 /*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
2449
2450 static char *
2451 pack_threadlist_request (char *pkt, int startflag, int threadcount,
2452                          threadref *nextthread)
2453 {
2454   *pkt++ = 'q';                 /* info query packet */
2455   *pkt++ = 'L';                 /* Process LIST or threadLIST request */
2456   pkt = pack_nibble (pkt, startflag);           /* initflag 1 bytes */
2457   pkt = pack_hex_byte (pkt, threadcount);       /* threadcount 2 bytes */
2458   pkt = pack_threadid (pkt, nextthread);        /* 64 bit thread identifier */
2459   *pkt = '\0';
2460   return pkt;
2461 }
2462
2463 /* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2464
2465 static int
2466 parse_threadlist_response (char *pkt, int result_limit,
2467                            threadref *original_echo, threadref *resultlist,
2468                            int *doneflag)
2469 {
2470   struct remote_state *rs = get_remote_state ();
2471   char *limit;
2472   int count, resultcount, done;
2473
2474   resultcount = 0;
2475   /* Assume the 'q' and 'M chars have been stripped.  */
2476   limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
2477   /* done parse past here */
2478   pkt = unpack_byte (pkt, &count);      /* count field */
2479   pkt = unpack_nibble (pkt, &done);
2480   /* The first threadid is the argument threadid.  */
2481   pkt = unpack_threadid (pkt, original_echo);   /* should match query packet */
2482   while ((count-- > 0) && (pkt < limit))
2483     {
2484       pkt = unpack_threadid (pkt, resultlist++);
2485       if (resultcount++ >= result_limit)
2486         break;
2487     }
2488   if (doneflag)
2489     *doneflag = done;
2490   return resultcount;
2491 }
2492
2493 static int
2494 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
2495                        int *done, int *result_count, threadref *threadlist)
2496 {
2497   struct remote_state *rs = get_remote_state ();
2498   static threadref echo_nextthread;
2499   int result = 1;
2500
2501   /* Trancate result limit to be smaller than the packet size.  */
2502   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
2503       >= get_remote_packet_size ())
2504     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
2505
2506   pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
2507   putpkt (rs->buf);
2508   getpkt (&rs->buf, &rs->buf_size, 0);
2509
2510   if (*rs->buf == '\0')
2511     return 0;
2512   else
2513     *result_count =
2514       parse_threadlist_response (rs->buf + 2, result_limit, &echo_nextthread,
2515                                  threadlist, done);
2516
2517   if (!threadmatch (&echo_nextthread, nextthread))
2518     {
2519       /* FIXME: This is a good reason to drop the packet.  */
2520       /* Possably, there is a duplicate response.  */
2521       /* Possabilities :
2522          retransmit immediatly - race conditions
2523          retransmit after timeout - yes
2524          exit
2525          wait for packet, then exit
2526        */
2527       warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2528       return 0;                 /* I choose simply exiting.  */
2529     }
2530   if (*result_count <= 0)
2531     {
2532       if (*done != 1)
2533         {
2534           warning (_("RMT ERROR : failed to get remote thread list."));
2535           result = 0;
2536         }
2537       return result;            /* break; */
2538     }
2539   if (*result_count > result_limit)
2540     {
2541       *result_count = 0;
2542       warning (_("RMT ERROR: threadlist response longer than requested."));
2543       return 0;
2544     }
2545   return result;
2546 }
2547
2548 /* This is the interface between remote and threads, remotes upper
2549    interface.  */
2550
2551 /* remote_find_new_threads retrieves the thread list and for each
2552    thread in the list, looks up the thread in GDB's internal list,
2553    adding the thread if it does not already exist.  This involves
2554    getting partial thread lists from the remote target so, polling the
2555    quit_flag is required.  */
2556
2557
2558 /* About this many threadisds fit in a packet.  */
2559
2560 #define MAXTHREADLISTRESULTS 32
2561
2562 static int
2563 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
2564                             int looplimit)
2565 {
2566   int done, i, result_count;
2567   int startflag = 1;
2568   int result = 1;
2569   int loopcount = 0;
2570   static threadref nextthread;
2571   static threadref resultthreadlist[MAXTHREADLISTRESULTS];
2572
2573   done = 0;
2574   while (!done)
2575     {
2576       if (loopcount++ > looplimit)
2577         {
2578           result = 0;
2579           warning (_("Remote fetch threadlist -infinite loop-."));
2580           break;
2581         }
2582       if (!remote_get_threadlist (startflag, &nextthread, MAXTHREADLISTRESULTS,
2583                                   &done, &result_count, resultthreadlist))
2584         {
2585           result = 0;
2586           break;
2587         }
2588       /* Clear for later iterations.  */
2589       startflag = 0;
2590       /* Setup to resume next batch of thread references, set nextthread.  */
2591       if (result_count >= 1)
2592         copy_threadref (&nextthread, &resultthreadlist[result_count - 1]);
2593       i = 0;
2594       while (result_count--)
2595         if (!(result = (*stepfunction) (&resultthreadlist[i++], context)))
2596           break;
2597     }
2598   return result;
2599 }
2600
2601 static int
2602 remote_newthread_step (threadref *ref, void *context)
2603 {
2604   int pid = ptid_get_pid (inferior_ptid);
2605   ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref));
2606
2607   if (!in_thread_list (ptid))
2608     add_thread (ptid);
2609   return 1;                     /* continue iterator */
2610 }
2611
2612 #define CRAZY_MAX_THREADS 1000
2613
2614 static ptid_t
2615 remote_current_thread (ptid_t oldpid)
2616 {
2617   struct remote_state *rs = get_remote_state ();
2618
2619   putpkt ("qC");
2620   getpkt (&rs->buf, &rs->buf_size, 0);
2621   if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
2622     return read_ptid (&rs->buf[2], NULL);
2623   else
2624     return oldpid;
2625 }
2626
2627 /* Find new threads for info threads command.
2628  * Original version, using John Metzler's thread protocol.
2629  */
2630
2631 static void
2632 remote_find_new_threads (void)
2633 {
2634   remote_threadlist_iterator (remote_newthread_step, 0,
2635                               CRAZY_MAX_THREADS);
2636 }
2637
2638 #if defined(HAVE_LIBEXPAT)
2639
2640 typedef struct thread_item
2641 {
2642   ptid_t ptid;
2643   char *extra;
2644   int core;
2645 } thread_item_t;
2646 DEF_VEC_O(thread_item_t);
2647
2648 struct threads_parsing_context
2649 {
2650   VEC (thread_item_t) *items;
2651 };
2652
2653 static void
2654 start_thread (struct gdb_xml_parser *parser,
2655               const struct gdb_xml_element *element,
2656               void *user_data, VEC(gdb_xml_value_s) *attributes)
2657 {
2658   struct threads_parsing_context *data = user_data;
2659
2660   struct thread_item item;
2661   char *id;
2662   struct gdb_xml_value *attr;
2663
2664   id = xml_find_attribute (attributes, "id")->value;
2665   item.ptid = read_ptid (id, NULL);
2666
2667   attr = xml_find_attribute (attributes, "core");
2668   if (attr != NULL)
2669     item.core = *(ULONGEST *) attr->value;
2670   else
2671     item.core = -1;
2672
2673   item.extra = 0;
2674
2675   VEC_safe_push (thread_item_t, data->items, &item);
2676 }
2677
2678 static void
2679 end_thread (struct gdb_xml_parser *parser,
2680             const struct gdb_xml_element *element,
2681             void *user_data, const char *body_text)
2682 {
2683   struct threads_parsing_context *data = user_data;
2684
2685   if (body_text && *body_text)
2686     VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text);
2687 }
2688
2689 const struct gdb_xml_attribute thread_attributes[] = {
2690   { "id", GDB_XML_AF_NONE, NULL, NULL },
2691   { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
2692   { NULL, GDB_XML_AF_NONE, NULL, NULL }
2693 };
2694
2695 const struct gdb_xml_element thread_children[] = {
2696   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2697 };
2698
2699 const struct gdb_xml_element threads_children[] = {
2700   { "thread", thread_attributes, thread_children,
2701     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
2702     start_thread, end_thread },
2703   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2704 };
2705
2706 const struct gdb_xml_element threads_elements[] = {
2707   { "threads", NULL, threads_children,
2708     GDB_XML_EF_NONE, NULL, NULL },
2709   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
2710 };
2711
2712 /* Discard the contents of the constructed thread info context.  */
2713
2714 static void
2715 clear_threads_parsing_context (void *p)
2716 {
2717   struct threads_parsing_context *context = p;
2718   int i;
2719   struct thread_item *item;
2720
2721   for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
2722     xfree (item->extra);
2723
2724   VEC_free (thread_item_t, context->items);
2725 }
2726
2727 #endif
2728
2729 /*
2730  * Find all threads for info threads command.
2731  * Uses new thread protocol contributed by Cisco.
2732  * Falls back and attempts to use the older method (above)
2733  * if the target doesn't respond to the new method.
2734  */
2735
2736 static void
2737 remote_threads_info (struct target_ops *ops)
2738 {
2739   struct remote_state *rs = get_remote_state ();
2740   char *bufp;
2741   ptid_t new_thread;
2742
2743   if (rs->remote_desc == 0)             /* paranoia */
2744     error (_("Command can only be used when connected to the remote target."));
2745
2746 #if defined(HAVE_LIBEXPAT)
2747   if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2748     {
2749       char *xml = target_read_stralloc (&current_target,
2750                                          TARGET_OBJECT_THREADS, NULL);
2751
2752       struct cleanup *back_to = make_cleanup (xfree, xml);
2753
2754       if (xml && *xml)
2755         {
2756           struct threads_parsing_context context;
2757
2758           context.items = NULL;
2759           make_cleanup (clear_threads_parsing_context, &context);
2760
2761           if (gdb_xml_parse_quick (_("threads"), "threads.dtd",
2762                                    threads_elements, xml, &context) == 0)
2763             {
2764               int i;
2765               struct thread_item *item;
2766
2767               for (i = 0;
2768                    VEC_iterate (thread_item_t, context.items, i, item);
2769                    ++i)
2770                 {
2771                   if (!ptid_equal (item->ptid, null_ptid))
2772                     {
2773                       struct private_thread_info *info;
2774                       /* In non-stop mode, we assume new found threads
2775                          are running until proven otherwise with a
2776                          stop reply.  In all-stop, we can only get
2777                          here if all threads are stopped.  */
2778                       int running = non_stop ? 1 : 0;
2779
2780                       remote_notice_new_inferior (item->ptid, running);
2781
2782                       info = demand_private_info (item->ptid);
2783                       info->core = item->core;
2784                       info->extra = item->extra;
2785                       item->extra = NULL;
2786                     }
2787                 }
2788             }
2789         }
2790
2791       do_cleanups (back_to);
2792       return;
2793     }
2794 #endif
2795
2796   if (rs->use_threadinfo_query)
2797     {
2798       putpkt ("qfThreadInfo");
2799       getpkt (&rs->buf, &rs->buf_size, 0);
2800       bufp = rs->buf;
2801       if (bufp[0] != '\0')              /* q packet recognized */
2802         {
2803           struct cleanup *old_chain;
2804           char *saved_reply;
2805
2806           /* remote_notice_new_inferior (in the loop below) may make
2807              new RSP calls, which clobber rs->buf.  Work with a
2808              copy.  */
2809           bufp = saved_reply = xstrdup (rs->buf);
2810           old_chain = make_cleanup (free_current_contents, &saved_reply);
2811
2812           while (*bufp++ == 'm')        /* reply contains one or more TID */
2813             {
2814               do
2815                 {
2816                   new_thread = read_ptid (bufp, &bufp);
2817                   if (!ptid_equal (new_thread, null_ptid))
2818                     {
2819                       /* In non-stop mode, we assume new found threads
2820                          are running until proven otherwise with a
2821                          stop reply.  In all-stop, we can only get
2822                          here if all threads are stopped.  */
2823                       int running = non_stop ? 1 : 0;
2824
2825                       remote_notice_new_inferior (new_thread, running);
2826                     }
2827                 }
2828               while (*bufp++ == ',');   /* comma-separated list */
2829               free_current_contents (&saved_reply);
2830               putpkt ("qsThreadInfo");
2831               getpkt (&rs->buf, &rs->buf_size, 0);
2832               bufp = saved_reply = xstrdup (rs->buf);
2833             }
2834           do_cleanups (old_chain);
2835           return;       /* done */
2836         }
2837     }
2838
2839   /* Only qfThreadInfo is supported in non-stop mode.  */
2840   if (non_stop)
2841     return;
2842
2843   /* Else fall back to old method based on jmetzler protocol.  */
2844   rs->use_threadinfo_query = 0;
2845   remote_find_new_threads ();
2846   return;
2847 }
2848
2849 /*
2850  * Collect a descriptive string about the given thread.
2851  * The target may say anything it wants to about the thread
2852  * (typically info about its blocked / runnable state, name, etc.).
2853  * This string will appear in the info threads display.
2854  *
2855  * Optional: targets are not required to implement this function.
2856  */
2857
2858 static char *
2859 remote_threads_extra_info (struct thread_info *tp)
2860 {
2861   struct remote_state *rs = get_remote_state ();
2862   int result;
2863   int set;
2864   threadref id;
2865   struct gdb_ext_thread_info threadinfo;
2866   static char display_buf[100]; /* arbitrary...  */
2867   int n = 0;                    /* position in display_buf */
2868
2869   if (rs->remote_desc == 0)             /* paranoia */
2870     internal_error (__FILE__, __LINE__,
2871                     _("remote_threads_extra_info"));
2872
2873   if (ptid_equal (tp->ptid, magic_null_ptid)
2874       || (ptid_get_pid (tp->ptid) != 0 && ptid_get_tid (tp->ptid) == 0))
2875     /* This is the main thread which was added by GDB.  The remote
2876        server doesn't know about it.  */
2877     return NULL;
2878
2879   if (remote_protocol_packets[PACKET_qXfer_threads].support == PACKET_ENABLE)
2880     {
2881       struct thread_info *info = find_thread_ptid (tp->ptid);
2882
2883       if (info && info->private)
2884         return info->private->extra;
2885       else
2886         return NULL;
2887     }
2888
2889   if (rs->use_threadextra_query)
2890     {
2891       char *b = rs->buf;
2892       char *endb = rs->buf + get_remote_packet_size ();
2893
2894       xsnprintf (b, endb - b, "qThreadExtraInfo,");
2895       b += strlen (b);
2896       write_ptid (b, endb, tp->ptid);
2897
2898       putpkt (rs->buf);
2899       getpkt (&rs->buf, &rs->buf_size, 0);
2900       if (rs->buf[0] != 0)
2901         {
2902           n = min (strlen (rs->buf) / 2, sizeof (display_buf));
2903           result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
2904           display_buf [result] = '\0';
2905           return display_buf;
2906         }
2907     }
2908
2909   /* If the above query fails, fall back to the old method.  */
2910   rs->use_threadextra_query = 0;
2911   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
2912     | TAG_MOREDISPLAY | TAG_DISPLAY;
2913   int_to_threadref (&id, ptid_get_tid (tp->ptid));
2914   if (remote_get_threadinfo (&id, set, &threadinfo))
2915     if (threadinfo.active)
2916       {
2917         if (*threadinfo.shortname)
2918           n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
2919                           " Name: %s,", threadinfo.shortname);
2920         if (*threadinfo.display)
2921           n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2922                           " State: %s,", threadinfo.display);
2923         if (*threadinfo.more_display)
2924           n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
2925                           " Priority: %s", threadinfo.more_display);
2926
2927         if (n > 0)
2928           {
2929             /* For purely cosmetic reasons, clear up trailing commas.  */
2930             if (',' == display_buf[n-1])
2931               display_buf[n-1] = ' ';
2932             return display_buf;
2933           }
2934       }
2935   return NULL;
2936 }
2937 \f
2938
2939 static int
2940 remote_static_tracepoint_marker_at (CORE_ADDR addr,
2941                                     struct static_tracepoint_marker *marker)
2942 {
2943   struct remote_state *rs = get_remote_state ();
2944   char *p = rs->buf;
2945
2946   xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
2947   p += strlen (p);
2948   p += hexnumstr (p, addr);
2949   putpkt (rs->buf);
2950   getpkt (&rs->buf, &rs->buf_size, 0);
2951   p = rs->buf;
2952
2953   if (*p == 'E')
2954     error (_("Remote failure reply: %s"), p);
2955
2956   if (*p++ == 'm')
2957     {
2958       parse_static_tracepoint_marker_definition (p, &p, marker);
2959       return 1;
2960     }
2961
2962   return 0;
2963 }
2964
2965 static VEC(static_tracepoint_marker_p) *
2966 remote_static_tracepoint_markers_by_strid (const char *strid)
2967 {
2968   struct remote_state *rs = get_remote_state ();
2969   VEC(static_tracepoint_marker_p) *markers = NULL;
2970   struct static_tracepoint_marker *marker = NULL;
2971   struct cleanup *old_chain;
2972   char *p;
2973
2974   /* Ask for a first packet of static tracepoint marker
2975      definition.  */
2976   putpkt ("qTfSTM");
2977   getpkt (&rs->buf, &rs->buf_size, 0);
2978   p = rs->buf;
2979   if (*p == 'E')
2980     error (_("Remote failure reply: %s"), p);
2981
2982   old_chain = make_cleanup (free_current_marker, &marker);
2983
2984   while (*p++ == 'm')
2985     {
2986       if (marker == NULL)
2987         marker = XCNEW (struct static_tracepoint_marker);
2988
2989       do
2990         {
2991           parse_static_tracepoint_marker_definition (p, &p, marker);
2992
2993           if (strid == NULL || strcmp (strid, marker->str_id) == 0)
2994             {
2995               VEC_safe_push (static_tracepoint_marker_p,
2996                              markers, marker);
2997               marker = NULL;
2998             }
2999           else
3000             {
3001               release_static_tracepoint_marker (marker);
3002               memset (marker, 0, sizeof (*marker));
3003             }
3004         }
3005       while (*p++ == ',');      /* comma-separated list */
3006       /* Ask for another packet of static tracepoint definition.  */
3007       putpkt ("qTsSTM");
3008       getpkt (&rs->buf, &rs->buf_size, 0);
3009       p = rs->buf;
3010     }
3011
3012   do_cleanups (old_chain);
3013   return markers;
3014 }
3015
3016 \f
3017 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
3018
3019 static ptid_t
3020 remote_get_ada_task_ptid (long lwp, long thread)
3021 {
3022   return ptid_build (ptid_get_pid (inferior_ptid), 0, lwp);
3023 }
3024 \f
3025
3026 /* Restart the remote side; this is an extended protocol operation.  */
3027
3028 static void
3029 extended_remote_restart (void)
3030 {
3031   struct remote_state *rs = get_remote_state ();
3032
3033   /* Send the restart command; for reasons I don't understand the
3034      remote side really expects a number after the "R".  */
3035   xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
3036   putpkt (rs->buf);
3037
3038   remote_fileio_reset ();
3039 }
3040 \f
3041 /* Clean up connection to a remote debugger.  */
3042
3043 static void
3044 remote_close (void)
3045 {
3046   struct remote_state *rs = get_remote_state ();
3047
3048   if (rs->remote_desc == NULL)
3049     return; /* already closed */
3050
3051   /* Make sure we leave stdin registered in the event loop, and we
3052      don't leave the async SIGINT signal handler installed.  */
3053   remote_terminal_ours ();
3054
3055   serial_close (rs->remote_desc);
3056   rs->remote_desc = NULL;
3057
3058   /* We don't have a connection to the remote stub anymore.  Get rid
3059      of all the inferiors and their threads we were controlling.
3060      Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3061      will be unable to find the thread corresponding to (pid, 0, 0).  */
3062   inferior_ptid = null_ptid;
3063   discard_all_inferiors ();
3064
3065   /* Stop replies may from inferiors which are still unknown to GDB.
3066      We are closing the remote target, so we should discard
3067      everything, including the stop replies from GDB-unknown
3068      inferiors.  */
3069   discard_pending_stop_replies (NULL);
3070
3071   if (remote_async_inferior_event_token)
3072     delete_async_event_handler (&remote_async_inferior_event_token);
3073
3074   remote_notif_unregister_async_event_handler ();
3075
3076   trace_reset_local_state ();
3077 }
3078
3079 /* Query the remote side for the text, data and bss offsets.  */
3080
3081 static void
3082 get_offsets (void)
3083 {
3084   struct remote_state *rs = get_remote_state ();
3085   char *buf;
3086   char *ptr;
3087   int lose, num_segments = 0, do_sections, do_segments;
3088   CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
3089   struct section_offsets *offs;
3090   struct symfile_segment_data *data;
3091
3092   if (symfile_objfile == NULL)
3093     return;
3094
3095   putpkt ("qOffsets");
3096   getpkt (&rs->buf, &rs->buf_size, 0);
3097   buf = rs->buf;