Suppress SIGTTOU when handling errors
[external/binutils.git] / gdb / remote.c
1 /* Remote target communications for serial-line targets in custom GDB protocol
2
3    Copyright (C) 1988-2019 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 <ctype.h>
24 #include <fcntl.h>
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "bfd.h"
28 #include "symfile.h"
29 #include "target.h"
30 #include "process-stratum-target.h"
31 #include "gdbcmd.h"
32 #include "objfiles.h"
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
35 #include "remote.h"
36 #include "remote-notif.h"
37 #include "regcache.h"
38 #include "value.h"
39 #include "observable.h"
40 #include "solib.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
44 #include "gdb_bfd.h"
45 #include "common/filestuff.h"
46 #include "common/rsp-low.h"
47 #include "disasm.h"
48 #include "location.h"
49
50 #include "common/gdb_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 <sys/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 "common/agent.h"
72 #include "btrace.h"
73 #include "record-btrace.h"
74 #include <algorithm>
75 #include "common/scoped_restore.h"
76 #include "common/environ.h"
77 #include "common/byte-vector.h"
78 #include <unordered_map>
79
80 /* The remote target.  */
81
82 static const char remote_doc[] = N_("\
83 Use a remote computer via a serial line, using a gdb-specific protocol.\n\
84 Specify the serial device it is connected to\n\
85 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).");
86
87 #define OPAQUETHREADBYTES 8
88
89 /* a 64 bit opaque identifier */
90 typedef unsigned char threadref[OPAQUETHREADBYTES];
91
92 struct gdb_ext_thread_info;
93 struct threads_listing_context;
94 typedef int (*rmt_thread_action) (threadref *ref, void *context);
95 struct protocol_feature;
96 struct packet_reg;
97
98 struct stop_reply;
99 static void stop_reply_xfree (struct stop_reply *);
100
101 struct stop_reply_deleter
102 {
103   void operator() (stop_reply *r) const
104   {
105     stop_reply_xfree (r);
106   }
107 };
108
109 typedef std::unique_ptr<stop_reply, stop_reply_deleter> stop_reply_up;
110
111 /* Generic configuration support for packets the stub optionally
112    supports.  Allows the user to specify the use of the packet as well
113    as allowing GDB to auto-detect support in the remote stub.  */
114
115 enum packet_support
116   {
117     PACKET_SUPPORT_UNKNOWN = 0,
118     PACKET_ENABLE,
119     PACKET_DISABLE
120   };
121
122 /* Analyze a packet's return value and update the packet config
123    accordingly.  */
124
125 enum packet_result
126 {
127   PACKET_ERROR,
128   PACKET_OK,
129   PACKET_UNKNOWN
130 };
131
132 struct threads_listing_context;
133
134 /* Stub vCont actions support.
135
136    Each field is a boolean flag indicating whether the stub reports
137    support for the corresponding action.  */
138
139 struct vCont_action_support
140 {
141   /* vCont;t */
142   bool t = false;
143
144   /* vCont;r */
145   bool r = false;
146
147   /* vCont;s */
148   bool s = false;
149
150   /* vCont;S */
151   bool S = false;
152 };
153
154 /* About this many threadisds fit in a packet.  */
155
156 #define MAXTHREADLISTRESULTS 32
157
158 /* Data for the vFile:pread readahead cache.  */
159
160 struct readahead_cache
161 {
162   /* Invalidate the readahead cache.  */
163   void invalidate ();
164
165   /* Invalidate the readahead cache if it is holding data for FD.  */
166   void invalidate_fd (int fd);
167
168   /* Serve pread from the readahead cache.  Returns number of bytes
169      read, or 0 if the request can't be served from the cache.  */
170   int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset);
171
172   /* The file descriptor for the file that is being cached.  -1 if the
173      cache is invalid.  */
174   int fd = -1;
175
176   /* The offset into the file that the cache buffer corresponds
177      to.  */
178   ULONGEST offset = 0;
179
180   /* The buffer holding the cache contents.  */
181   gdb_byte *buf = nullptr;
182   /* The buffer's size.  We try to read as much as fits into a packet
183      at a time.  */
184   size_t bufsize = 0;
185
186   /* Cache hit and miss counters.  */
187   ULONGEST hit_count = 0;
188   ULONGEST miss_count = 0;
189 };
190
191 /* Description of the remote protocol for a given architecture.  */
192
193 struct packet_reg
194 {
195   long offset; /* Offset into G packet.  */
196   long regnum; /* GDB's internal register number.  */
197   LONGEST pnum; /* Remote protocol register number.  */
198   int in_g_packet; /* Always part of G packet.  */
199   /* long size in bytes;  == register_size (target_gdbarch (), regnum);
200      at present.  */
201   /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
202      at present.  */
203 };
204
205 struct remote_arch_state
206 {
207   explicit remote_arch_state (struct gdbarch *gdbarch);
208
209   /* Description of the remote protocol registers.  */
210   long sizeof_g_packet;
211
212   /* Description of the remote protocol registers indexed by REGNUM
213      (making an array gdbarch_num_regs in size).  */
214   std::unique_ptr<packet_reg[]> regs;
215
216   /* This is the size (in chars) of the first response to the ``g''
217      packet.  It is used as a heuristic when determining the maximum
218      size of memory-read and memory-write packets.  A target will
219      typically only reserve a buffer large enough to hold the ``g''
220      packet.  The size does not include packet overhead (headers and
221      trailers).  */
222   long actual_register_packet_size;
223
224   /* This is the maximum size (in chars) of a non read/write packet.
225      It is also used as a cap on the size of read/write packets.  */
226   long remote_packet_size;
227 };
228
229 /* Description of the remote protocol state for the currently
230    connected target.  This is per-target state, and independent of the
231    selected architecture.  */
232
233 class remote_state
234 {
235 public:
236
237   remote_state ();
238   ~remote_state ();
239
240   /* Get the remote arch state for GDBARCH.  */
241   struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);
242
243 public: /* data */
244
245   /* A buffer to use for incoming packets, and its current size.  The
246      buffer is grown dynamically for larger incoming packets.
247      Outgoing packets may also be constructed in this buffer.
248      The size of the buffer is always at least REMOTE_PACKET_SIZE;
249      REMOTE_PACKET_SIZE should be used to limit the length of outgoing
250      packets.  */
251   gdb::char_vector buf;
252
253   /* True if we're going through initial connection setup (finding out
254      about the remote side's threads, relocating symbols, etc.).  */
255   bool starting_up = false;
256
257   /* If we negotiated packet size explicitly (and thus can bypass
258      heuristics for the largest packet size that will not overflow
259      a buffer in the stub), this will be set to that packet size.
260      Otherwise zero, meaning to use the guessed size.  */
261   long explicit_packet_size = 0;
262
263   /* remote_wait is normally called when the target is running and
264      waits for a stop reply packet.  But sometimes we need to call it
265      when the target is already stopped.  We can send a "?" packet
266      and have remote_wait read the response.  Or, if we already have
267      the response, we can stash it in BUF and tell remote_wait to
268      skip calling getpkt.  This flag is set when BUF contains a
269      stop reply packet and the target is not waiting.  */
270   int cached_wait_status = 0;
271
272   /* True, if in no ack mode.  That is, neither GDB nor the stub will
273      expect acks from each other.  The connection is assumed to be
274      reliable.  */
275   bool noack_mode = false;
276
277   /* True if we're connected in extended remote mode.  */
278   bool extended = false;
279
280   /* True if we resumed the target and we're waiting for the target to
281      stop.  In the mean time, we can't start another command/query.
282      The remote server wouldn't be ready to process it, so we'd
283      timeout waiting for a reply that would never come and eventually
284      we'd close the connection.  This can happen in asynchronous mode
285      because we allow GDB commands while the target is running.  */
286   bool waiting_for_stop_reply = false;
287
288   /* The status of the stub support for the various vCont actions.  */
289   vCont_action_support supports_vCont;
290
291   /* True if the user has pressed Ctrl-C, but the target hasn't
292      responded to that.  */
293   bool ctrlc_pending_p = false;
294
295   /* True if we saw a Ctrl-C while reading or writing from/to the
296      remote descriptor.  At that point it is not safe to send a remote
297      interrupt packet, so we instead remember we saw the Ctrl-C and
298      process it once we're done with sending/receiving the current
299      packet, which should be shortly.  If however that takes too long,
300      and the user presses Ctrl-C again, we offer to disconnect.  */
301   bool got_ctrlc_during_io = false;
302
303   /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
304      remote_open knows that we don't have a file open when the program
305      starts.  */
306   struct serial *remote_desc = nullptr;
307
308   /* These are the threads which we last sent to the remote system.  The
309      TID member will be -1 for all or -2 for not sent yet.  */
310   ptid_t general_thread = null_ptid;
311   ptid_t continue_thread = null_ptid;
312
313   /* This is the traceframe which we last selected on the remote system.
314      It will be -1 if no traceframe is selected.  */
315   int remote_traceframe_number = -1;
316
317   char *last_pass_packet = nullptr;
318
319   /* The last QProgramSignals packet sent to the target.  We bypass
320      sending a new program signals list down to the target if the new
321      packet is exactly the same as the last we sent.  IOW, we only let
322      the target know about program signals list changes.  */
323   char *last_program_signals_packet = nullptr;
324
325   gdb_signal last_sent_signal = GDB_SIGNAL_0;
326
327   bool last_sent_step = false;
328
329   /* The execution direction of the last resume we got.  */
330   exec_direction_kind last_resume_exec_dir = EXEC_FORWARD;
331
332   char *finished_object = nullptr;
333   char *finished_annex = nullptr;
334   ULONGEST finished_offset = 0;
335
336   /* Should we try the 'ThreadInfo' query packet?
337
338      This variable (NOT available to the user: auto-detect only!)
339      determines whether GDB will use the new, simpler "ThreadInfo"
340      query or the older, more complex syntax for thread queries.
341      This is an auto-detect variable (set to true at each connect,
342      and set to false when the target fails to recognize it).  */
343   bool use_threadinfo_query = false;
344   bool use_threadextra_query = false;
345
346   threadref echo_nextthread {};
347   threadref nextthread {};
348   threadref resultthreadlist[MAXTHREADLISTRESULTS] {};
349
350   /* The state of remote notification.  */
351   struct remote_notif_state *notif_state = nullptr;
352
353   /* The branch trace configuration.  */
354   struct btrace_config btrace_config {};
355
356   /* The argument to the last "vFile:setfs:" packet we sent, used
357      to avoid sending repeated unnecessary "vFile:setfs:" packets.
358      Initialized to -1 to indicate that no "vFile:setfs:" packet
359      has yet been sent.  */
360   int fs_pid = -1;
361
362   /* A readahead cache for vFile:pread.  Often, reading a binary
363      involves a sequence of small reads.  E.g., when parsing an ELF
364      file.  A readahead cache helps mostly the case of remote
365      debugging on a connection with higher latency, due to the
366      request/reply nature of the RSP.  We only cache data for a single
367      file descriptor at a time.  */
368   struct readahead_cache readahead_cache;
369
370   /* The list of already fetched and acknowledged stop events.  This
371      queue is used for notification Stop, and other notifications
372      don't need queue for their events, because the notification
373      events of Stop can't be consumed immediately, so that events
374      should be queued first, and be consumed by remote_wait_{ns,as}
375      one per time.  Other notifications can consume their events
376      immediately, so queue is not needed for them.  */
377   std::vector<stop_reply_up> stop_reply_queue;
378
379   /* Asynchronous signal handle registered as event loop source for
380      when we have pending events ready to be passed to the core.  */
381   struct async_event_handler *remote_async_inferior_event_token = nullptr;
382
383   /* FIXME: cagney/1999-09-23: Even though getpkt was called with
384      ``forever'' still use the normal timeout mechanism.  This is
385      currently used by the ASYNC code to guarentee that target reads
386      during the initial connect always time-out.  Once getpkt has been
387      modified to return a timeout indication and, in turn
388      remote_wait()/wait_for_inferior() have gained a timeout parameter
389      this can go away.  */
390   int wait_forever_enabled_p = 1;
391
392 private:
393   /* Mapping of remote protocol data for each gdbarch.  Usually there
394      is only one entry here, though we may see more with stubs that
395      support multi-process.  */
396   std::unordered_map<struct gdbarch *, remote_arch_state>
397     m_arch_states;
398 };
399
400 static const target_info remote_target_info = {
401   "remote",
402   N_("Remote serial target in gdb-specific protocol"),
403   remote_doc
404 };
405
406 class remote_target : public process_stratum_target
407 {
408 public:
409   remote_target () = default;
410   ~remote_target () override;
411
412   const target_info &info () const override
413   { return remote_target_info; }
414
415   thread_control_capabilities get_thread_control_capabilities () override
416   { return tc_schedlock; }
417
418   /* Open a remote connection.  */
419   static void open (const char *, int);
420
421   void close () override;
422
423   void detach (inferior *, int) override;
424   void disconnect (const char *, int) override;
425
426   void commit_resume () override;
427   void resume (ptid_t, int, enum gdb_signal) override;
428   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
429
430   void fetch_registers (struct regcache *, int) override;
431   void store_registers (struct regcache *, int) override;
432   void prepare_to_store (struct regcache *) override;
433
434   void files_info () override;
435
436   int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
437
438   int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
439                          enum remove_bp_reason) override;
440
441
442   bool stopped_by_sw_breakpoint () override;
443   bool supports_stopped_by_sw_breakpoint () override;
444
445   bool stopped_by_hw_breakpoint () override;
446
447   bool supports_stopped_by_hw_breakpoint () override;
448
449   bool stopped_by_watchpoint () override;
450
451   bool stopped_data_address (CORE_ADDR *) override;
452
453   bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
454
455   int can_use_hw_breakpoint (enum bptype, int, int) override;
456
457   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
458
459   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
460
461   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
462
463   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
464                          struct expression *) override;
465
466   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
467                          struct expression *) override;
468
469   void kill () override;
470
471   void load (const char *, int) override;
472
473   void mourn_inferior () override;
474
475   void pass_signals (gdb::array_view<const unsigned char>) override;
476
477   int set_syscall_catchpoint (int, bool, int,
478                               gdb::array_view<const int>) override;
479
480   void program_signals (gdb::array_view<const unsigned char>) override;
481
482   bool thread_alive (ptid_t ptid) override;
483
484   const char *thread_name (struct thread_info *) override;
485
486   void update_thread_list () override;
487
488   const char *pid_to_str (ptid_t) override;
489
490   const char *extra_thread_info (struct thread_info *) override;
491
492   ptid_t get_ada_task_ptid (long lwp, long thread) override;
493
494   thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
495                                              int handle_len,
496                                              inferior *inf) override;
497
498   void stop (ptid_t) override;
499
500   void interrupt () override;
501
502   void pass_ctrlc () override;
503
504   enum target_xfer_status xfer_partial (enum target_object object,
505                                         const char *annex,
506                                         gdb_byte *readbuf,
507                                         const gdb_byte *writebuf,
508                                         ULONGEST offset, ULONGEST len,
509                                         ULONGEST *xfered_len) override;
510
511   ULONGEST get_memory_xfer_limit () override;
512
513   void rcmd (const char *command, struct ui_file *output) override;
514
515   char *pid_to_exec_file (int pid) override;
516
517   void log_command (const char *cmd) override
518   {
519     serial_log_command (this, cmd);
520   }
521
522   CORE_ADDR get_thread_local_address (ptid_t ptid,
523                                       CORE_ADDR load_module_addr,
524                                       CORE_ADDR offset) override;
525
526   bool can_execute_reverse () override;
527
528   std::vector<mem_region> memory_map () override;
529
530   void flash_erase (ULONGEST address, LONGEST length) override;
531
532   void flash_done () override;
533
534   const struct target_desc *read_description () override;
535
536   int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
537                      const gdb_byte *pattern, ULONGEST pattern_len,
538                      CORE_ADDR *found_addrp) override;
539
540   bool can_async_p () override;
541
542   bool is_async_p () override;
543
544   void async (int) override;
545
546   void thread_events (int) override;
547
548   int can_do_single_step () override;
549
550   void terminal_inferior () override;
551
552   void terminal_ours () override;
553
554   bool supports_non_stop () override;
555
556   bool supports_multi_process () override;
557
558   bool supports_disable_randomization () override;
559
560   bool filesystem_is_local () override;
561
562
563   int fileio_open (struct inferior *inf, const char *filename,
564                    int flags, int mode, int warn_if_slow,
565                    int *target_errno) override;
566
567   int fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
568                      ULONGEST offset, int *target_errno) override;
569
570   int fileio_pread (int fd, gdb_byte *read_buf, int len,
571                     ULONGEST offset, int *target_errno) override;
572
573   int fileio_fstat (int fd, struct stat *sb, int *target_errno) override;
574
575   int fileio_close (int fd, int *target_errno) override;
576
577   int fileio_unlink (struct inferior *inf,
578                      const char *filename,
579                      int *target_errno) override;
580
581   gdb::optional<std::string>
582     fileio_readlink (struct inferior *inf,
583                      const char *filename,
584                      int *target_errno) override;
585
586   bool supports_enable_disable_tracepoint () override;
587
588   bool supports_string_tracing () override;
589
590   bool supports_evaluation_of_breakpoint_conditions () override;
591
592   bool can_run_breakpoint_commands () override;
593
594   void trace_init () override;
595
596   void download_tracepoint (struct bp_location *location) override;
597
598   bool can_download_tracepoint () override;
599
600   void download_trace_state_variable (const trace_state_variable &tsv) override;
601
602   void enable_tracepoint (struct bp_location *location) override;
603
604   void disable_tracepoint (struct bp_location *location) override;
605
606   void trace_set_readonly_regions () override;
607
608   void trace_start () override;
609
610   int get_trace_status (struct trace_status *ts) override;
611
612   void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
613     override;
614
615   void trace_stop () override;
616
617   int trace_find (enum trace_find_type type, int num,
618                   CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
619
620   bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
621
622   int save_trace_data (const char *filename) override;
623
624   int upload_tracepoints (struct uploaded_tp **utpp) override;
625
626   int upload_trace_state_variables (struct uploaded_tsv **utsvp) override;
627
628   LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override;
629
630   int get_min_fast_tracepoint_insn_len () override;
631
632   void set_disconnected_tracing (int val) override;
633
634   void set_circular_trace_buffer (int val) override;
635
636   void set_trace_buffer_size (LONGEST val) override;
637
638   bool set_trace_notes (const char *user, const char *notes,
639                         const char *stopnotes) override;
640
641   int core_of_thread (ptid_t ptid) override;
642
643   int verify_memory (const gdb_byte *data,
644                      CORE_ADDR memaddr, ULONGEST size) override;
645
646
647   bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
648
649   void set_permissions () override;
650
651   bool static_tracepoint_marker_at (CORE_ADDR,
652                                     struct static_tracepoint_marker *marker)
653     override;
654
655   std::vector<static_tracepoint_marker>
656     static_tracepoint_markers_by_strid (const char *id) override;
657
658   traceframe_info_up traceframe_info () override;
659
660   bool use_agent (bool use) override;
661   bool can_use_agent () override;
662
663   struct btrace_target_info *enable_btrace (ptid_t ptid,
664                                             const struct btrace_config *conf) override;
665
666   void disable_btrace (struct btrace_target_info *tinfo) override;
667
668   void teardown_btrace (struct btrace_target_info *tinfo) override;
669
670   enum btrace_error read_btrace (struct btrace_data *data,
671                                  struct btrace_target_info *btinfo,
672                                  enum btrace_read_type type) override;
673
674   const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
675   bool augmented_libraries_svr4_read () override;
676   int follow_fork (int, int) override;
677   void follow_exec (struct inferior *, char *) override;
678   int insert_fork_catchpoint (int) override;
679   int remove_fork_catchpoint (int) override;
680   int insert_vfork_catchpoint (int) override;
681   int remove_vfork_catchpoint (int) override;
682   int insert_exec_catchpoint (int) override;
683   int remove_exec_catchpoint (int) override;
684   enum exec_direction_kind execution_direction () override;
685
686 public: /* Remote specific methods.  */
687
688   void remote_download_command_source (int num, ULONGEST addr,
689                                        struct command_line *cmds);
690
691   void remote_file_put (const char *local_file, const char *remote_file,
692                         int from_tty);
693   void remote_file_get (const char *remote_file, const char *local_file,
694                         int from_tty);
695   void remote_file_delete (const char *remote_file, int from_tty);
696
697   int remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
698                            ULONGEST offset, int *remote_errno);
699   int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
700                             ULONGEST offset, int *remote_errno);
701   int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
702                                  ULONGEST offset, int *remote_errno);
703
704   int remote_hostio_send_command (int command_bytes, int which_packet,
705                                   int *remote_errno, char **attachment,
706                                   int *attachment_len);
707   int remote_hostio_set_filesystem (struct inferior *inf,
708                                     int *remote_errno);
709   /* We should get rid of this and use fileio_open directly.  */
710   int remote_hostio_open (struct inferior *inf, const char *filename,
711                           int flags, int mode, int warn_if_slow,
712                           int *remote_errno);
713   int remote_hostio_close (int fd, int *remote_errno);
714
715   int remote_hostio_unlink (inferior *inf, const char *filename,
716                             int *remote_errno);
717
718   struct remote_state *get_remote_state ();
719
720   long get_remote_packet_size (void);
721   long get_memory_packet_size (struct memory_packet_config *config);
722
723   long get_memory_write_packet_size ();
724   long get_memory_read_packet_size ();
725
726   char *append_pending_thread_resumptions (char *p, char *endp,
727                                            ptid_t ptid);
728   static void open_1 (const char *name, int from_tty, int extended_p);
729   void start_remote (int from_tty, int extended_p);
730   void remote_detach_1 (struct inferior *inf, int from_tty);
731
732   char *append_resumption (char *p, char *endp,
733                            ptid_t ptid, int step, gdb_signal siggnal);
734   int remote_resume_with_vcont (ptid_t ptid, int step,
735                                 gdb_signal siggnal);
736
737   void add_current_inferior_and_thread (char *wait_status);
738
739   ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
740                   int options);
741   ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
742                   int options);
743
744   ptid_t process_stop_reply (struct stop_reply *stop_reply,
745                              target_waitstatus *status);
746
747   void remote_notice_new_inferior (ptid_t currthread, int executing);
748
749   void process_initial_stop_replies (int from_tty);
750
751   thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing);
752
753   void btrace_sync_conf (const btrace_config *conf);
754
755   void remote_btrace_maybe_reopen ();
756
757   void remove_new_fork_children (threads_listing_context *context);
758   void kill_new_fork_children (int pid);
759   void discard_pending_stop_replies (struct inferior *inf);
760   int stop_reply_queue_length ();
761
762   void check_pending_events_prevent_wildcard_vcont
763     (int *may_global_wildcard_vcont);
764
765   void discard_pending_stop_replies_in_queue ();
766   struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
767   struct stop_reply *queued_stop_reply (ptid_t ptid);
768   int peek_stop_reply (ptid_t ptid);
769   void remote_parse_stop_reply (const char *buf, stop_reply *event);
770
771   void remote_stop_ns (ptid_t ptid);
772   void remote_interrupt_as ();
773   void remote_interrupt_ns ();
774
775   char *remote_get_noisy_reply ();
776   int remote_query_attached (int pid);
777   inferior *remote_add_inferior (int fake_pid_p, int pid, int attached,
778                                  int try_open_exec);
779
780   ptid_t remote_current_thread (ptid_t oldpid);
781   ptid_t get_current_thread (char *wait_status);
782
783   void set_thread (ptid_t ptid, int gen);
784   void set_general_thread (ptid_t ptid);
785   void set_continue_thread (ptid_t ptid);
786   void set_general_process ();
787
788   char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
789
790   int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
791                                           gdb_ext_thread_info *info);
792   int remote_get_threadinfo (threadref *threadid, int fieldset,
793                              gdb_ext_thread_info *info);
794
795   int parse_threadlist_response (char *pkt, int result_limit,
796                                  threadref *original_echo,
797                                  threadref *resultlist,
798                                  int *doneflag);
799   int remote_get_threadlist (int startflag, threadref *nextthread,
800                              int result_limit, int *done, int *result_count,
801                              threadref *threadlist);
802
803   int remote_threadlist_iterator (rmt_thread_action stepfunction,
804                                   void *context, int looplimit);
805
806   int remote_get_threads_with_ql (threads_listing_context *context);
807   int remote_get_threads_with_qxfer (threads_listing_context *context);
808   int remote_get_threads_with_qthreadinfo (threads_listing_context *context);
809
810   void extended_remote_restart ();
811
812   void get_offsets ();
813
814   void remote_check_symbols ();
815
816   void remote_supported_packet (const struct protocol_feature *feature,
817                                 enum packet_support support,
818                                 const char *argument);
819
820   void remote_query_supported ();
821
822   void remote_packet_size (const protocol_feature *feature,
823                            packet_support support, const char *value);
824
825   void remote_serial_quit_handler ();
826
827   void remote_detach_pid (int pid);
828
829   void remote_vcont_probe ();
830
831   void remote_resume_with_hc (ptid_t ptid, int step,
832                               gdb_signal siggnal);
833
834   void send_interrupt_sequence ();
835   void interrupt_query ();
836
837   void remote_notif_get_pending_events (notif_client *nc);
838
839   int fetch_register_using_p (struct regcache *regcache,
840                               packet_reg *reg);
841   int send_g_packet ();
842   void process_g_packet (struct regcache *regcache);
843   void fetch_registers_using_g (struct regcache *regcache);
844   int store_register_using_P (const struct regcache *regcache,
845                               packet_reg *reg);
846   void store_registers_using_G (const struct regcache *regcache);
847
848   void set_remote_traceframe ();
849
850   void check_binary_download (CORE_ADDR addr);
851
852   target_xfer_status remote_write_bytes_aux (const char *header,
853                                              CORE_ADDR memaddr,
854                                              const gdb_byte *myaddr,
855                                              ULONGEST len_units,
856                                              int unit_size,
857                                              ULONGEST *xfered_len_units,
858                                              char packet_format,
859                                              int use_length);
860
861   target_xfer_status remote_write_bytes (CORE_ADDR memaddr,
862                                          const gdb_byte *myaddr, ULONGEST len,
863                                          int unit_size, ULONGEST *xfered_len);
864
865   target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
866                                           ULONGEST len_units,
867                                           int unit_size, ULONGEST *xfered_len_units);
868
869   target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf,
870                                                         ULONGEST memaddr,
871                                                         ULONGEST len,
872                                                         int unit_size,
873                                                         ULONGEST *xfered_len);
874
875   target_xfer_status remote_read_bytes (CORE_ADDR memaddr,
876                                         gdb_byte *myaddr, ULONGEST len,
877                                         int unit_size,
878                                         ULONGEST *xfered_len);
879
880   packet_result remote_send_printf (const char *format, ...)
881     ATTRIBUTE_PRINTF (2, 3);
882
883   target_xfer_status remote_flash_write (ULONGEST address,
884                                          ULONGEST length, ULONGEST *xfered_len,
885                                          const gdb_byte *data);
886
887   int readchar (int timeout);
888
889   void remote_serial_write (const char *str, int len);
890
891   int putpkt (const char *buf);
892   int putpkt_binary (const char *buf, int cnt);
893
894   int putpkt (const gdb::char_vector &buf)
895   {
896     return putpkt (buf.data ());
897   }
898
899   void skip_frame ();
900   long read_frame (gdb::char_vector *buf_p);
901   void getpkt (gdb::char_vector *buf, int forever);
902   int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever,
903                               int expecting_notif, int *is_notif);
904   int getpkt_sane (gdb::char_vector *buf, int forever);
905   int getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
906                             int *is_notif);
907   int remote_vkill (int pid);
908   void remote_kill_k ();
909
910   void extended_remote_disable_randomization (int val);
911   int extended_remote_run (const std::string &args);
912
913   void send_environment_packet (const char *action,
914                                 const char *packet,
915                                 const char *value);
916
917   void extended_remote_environment_support ();
918   void extended_remote_set_inferior_cwd ();
919
920   target_xfer_status remote_write_qxfer (const char *object_name,
921                                          const char *annex,
922                                          const gdb_byte *writebuf,
923                                          ULONGEST offset, LONGEST len,
924                                          ULONGEST *xfered_len,
925                                          struct packet_config *packet);
926
927   target_xfer_status remote_read_qxfer (const char *object_name,
928                                         const char *annex,
929                                         gdb_byte *readbuf, ULONGEST offset,
930                                         LONGEST len,
931                                         ULONGEST *xfered_len,
932                                         struct packet_config *packet);
933
934   void push_stop_reply (struct stop_reply *new_event);
935
936   bool vcont_r_supported ();
937
938   void packet_command (const char *args, int from_tty);
939
940 private: /* data fields */
941
942   /* The remote state.  Don't reference this directly.  Use the
943      get_remote_state method instead.  */
944   remote_state m_remote_state;
945 };
946
947 static const target_info extended_remote_target_info = {
948   "extended-remote",
949   N_("Extended remote serial target in gdb-specific protocol"),
950   remote_doc
951 };
952
953 /* Set up the extended remote target by extending the standard remote
954    target and adding to it.  */
955
956 class extended_remote_target final : public remote_target
957 {
958 public:
959   const target_info &info () const override
960   { return extended_remote_target_info; }
961
962   /* Open an extended-remote connection.  */
963   static void open (const char *, int);
964
965   bool can_create_inferior () override { return true; }
966   void create_inferior (const char *, const std::string &,
967                         char **, int) override;
968
969   void detach (inferior *, int) override;
970
971   bool can_attach () override { return true; }
972   void attach (const char *, int) override;
973
974   void post_attach (int) override;
975   bool supports_disable_randomization () override;
976 };
977
978 /* Per-program-space data key.  */
979 static const struct program_space_data *remote_pspace_data;
980
981 /* The variable registered as the control variable used by the
982    remote exec-file commands.  While the remote exec-file setting is
983    per-program-space, the set/show machinery uses this as the 
984    location of the remote exec-file value.  */
985 static char *remote_exec_file_var;
986
987 /* The size to align memory write packets, when practical.  The protocol
988    does not guarantee any alignment, and gdb will generate short
989    writes and unaligned writes, but even as a best-effort attempt this
990    can improve bulk transfers.  For instance, if a write is misaligned
991    relative to the target's data bus, the stub may need to make an extra
992    round trip fetching data from the target.  This doesn't make a
993    huge difference, but it's easy to do, so we try to be helpful.
994
995    The alignment chosen is arbitrary; usually data bus width is
996    important here, not the possibly larger cache line size.  */
997 enum { REMOTE_ALIGN_WRITES = 16 };
998
999 /* Prototypes for local functions.  */
1000
1001 static int hexnumlen (ULONGEST num);
1002
1003 static int stubhex (int ch);
1004
1005 static int hexnumstr (char *, ULONGEST);
1006
1007 static int hexnumnstr (char *, ULONGEST, int);
1008
1009 static CORE_ADDR remote_address_masked (CORE_ADDR);
1010
1011 static void print_packet (const char *);
1012
1013 static int stub_unpack_int (char *buff, int fieldlength);
1014
1015 struct packet_config;
1016
1017 static void show_packet_config_cmd (struct packet_config *config);
1018
1019 static void show_remote_protocol_packet_cmd (struct ui_file *file,
1020                                              int from_tty,
1021                                              struct cmd_list_element *c,
1022                                              const char *value);
1023
1024 static ptid_t read_ptid (const char *buf, const char **obuf);
1025
1026 static void remote_async_inferior_event_handler (gdb_client_data);
1027
1028 static bool remote_read_description_p (struct target_ops *target);
1029
1030 static void remote_console_output (const char *msg);
1031
1032 static void remote_btrace_reset (remote_state *rs);
1033
1034 static void remote_unpush_and_throw (void);
1035
1036 /* For "remote".  */
1037
1038 static struct cmd_list_element *remote_cmdlist;
1039
1040 /* For "set remote" and "show remote".  */
1041
1042 static struct cmd_list_element *remote_set_cmdlist;
1043 static struct cmd_list_element *remote_show_cmdlist;
1044
1045 /* Controls whether GDB is willing to use range stepping.  */
1046
1047 static int use_range_stepping = 1;
1048
1049 /* The max number of chars in debug output.  The rest of chars are
1050    omitted.  */
1051
1052 #define REMOTE_DEBUG_MAX_CHAR 512
1053
1054 /* Private data that we'll store in (struct thread_info)->priv.  */
1055 struct remote_thread_info : public private_thread_info
1056 {
1057   std::string extra;
1058   std::string name;
1059   int core = -1;
1060
1061   /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1062      sequence of bytes.  */
1063   gdb::byte_vector thread_handle;
1064
1065   /* Whether the target stopped for a breakpoint/watchpoint.  */
1066   enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON;
1067
1068   /* This is set to the data address of the access causing the target
1069      to stop for a watchpoint.  */
1070   CORE_ADDR watch_data_address = 0;
1071
1072   /* Fields used by the vCont action coalescing implemented in
1073      remote_resume / remote_commit_resume.  remote_resume stores each
1074      thread's last resume request in these fields, so that a later
1075      remote_commit_resume knows which is the proper action for this
1076      thread to include in the vCont packet.  */
1077
1078   /* True if the last target_resume call for this thread was a step
1079      request, false if a continue request.  */
1080   int last_resume_step = 0;
1081
1082   /* The signal specified in the last target_resume call for this
1083      thread.  */
1084   gdb_signal last_resume_sig = GDB_SIGNAL_0;
1085
1086   /* Whether this thread was already vCont-resumed on the remote
1087      side.  */
1088   int vcont_resumed = 0;
1089 };
1090
1091 remote_state::remote_state ()
1092   : buf (400)
1093 {
1094 }
1095
1096 remote_state::~remote_state ()
1097 {
1098   xfree (this->last_pass_packet);
1099   xfree (this->last_program_signals_packet);
1100   xfree (this->finished_object);
1101   xfree (this->finished_annex);
1102 }
1103
1104 /* Utility: generate error from an incoming stub packet.  */
1105 static void
1106 trace_error (char *buf)
1107 {
1108   if (*buf++ != 'E')
1109     return;                     /* not an error msg */
1110   switch (*buf)
1111     {
1112     case '1':                   /* malformed packet error */
1113       if (*++buf == '0')        /*   general case: */
1114         error (_("remote.c: error in outgoing packet."));
1115       else
1116         error (_("remote.c: error in outgoing packet at field #%ld."),
1117                strtol (buf, NULL, 16));
1118     default:
1119       error (_("Target returns error code '%s'."), buf);
1120     }
1121 }
1122
1123 /* Utility: wait for reply from stub, while accepting "O" packets.  */
1124
1125 char *
1126 remote_target::remote_get_noisy_reply ()
1127 {
1128   struct remote_state *rs = get_remote_state ();
1129
1130   do                            /* Loop on reply from remote stub.  */
1131     {
1132       char *buf;
1133
1134       QUIT;                     /* Allow user to bail out with ^C.  */
1135       getpkt (&rs->buf, 0);
1136       buf = rs->buf.data ();
1137       if (buf[0] == 'E')
1138         trace_error (buf);
1139       else if (startswith (buf, "qRelocInsn:"))
1140         {
1141           ULONGEST ul;
1142           CORE_ADDR from, to, org_to;
1143           const char *p, *pp;
1144           int adjusted_size = 0;
1145           int relocated = 0;
1146
1147           p = buf + strlen ("qRelocInsn:");
1148           pp = unpack_varlen_hex (p, &ul);
1149           if (*pp != ';')
1150             error (_("invalid qRelocInsn packet: %s"), buf);
1151           from = ul;
1152
1153           p = pp + 1;
1154           unpack_varlen_hex (p, &ul);
1155           to = ul;
1156
1157           org_to = to;
1158
1159           TRY
1160             {
1161               gdbarch_relocate_instruction (target_gdbarch (), &to, from);
1162               relocated = 1;
1163             }
1164           CATCH (ex, RETURN_MASK_ALL)
1165             {
1166               if (ex.error == MEMORY_ERROR)
1167                 {
1168                   /* Propagate memory errors silently back to the
1169                      target.  The stub may have limited the range of
1170                      addresses we can write to, for example.  */
1171                 }
1172               else
1173                 {
1174                   /* Something unexpectedly bad happened.  Be verbose
1175                      so we can tell what, and propagate the error back
1176                      to the stub, so it doesn't get stuck waiting for
1177                      a response.  */
1178                   exception_fprintf (gdb_stderr, ex,
1179                                      _("warning: relocating instruction: "));
1180                 }
1181               putpkt ("E01");
1182             }
1183           END_CATCH
1184
1185           if (relocated)
1186             {
1187               adjusted_size = to - org_to;
1188
1189               xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size);
1190               putpkt (buf);
1191             }
1192         }
1193       else if (buf[0] == 'O' && buf[1] != 'K')
1194         remote_console_output (buf + 1);        /* 'O' message from stub */
1195       else
1196         return buf;             /* Here's the actual reply.  */
1197     }
1198   while (1);
1199 }
1200
1201 struct remote_arch_state *
1202 remote_state::get_remote_arch_state (struct gdbarch *gdbarch)
1203 {
1204   remote_arch_state *rsa;
1205
1206   auto it = this->m_arch_states.find (gdbarch);
1207   if (it == this->m_arch_states.end ())
1208     {
1209       auto p = this->m_arch_states.emplace (std::piecewise_construct,
1210                                             std::forward_as_tuple (gdbarch),
1211                                             std::forward_as_tuple (gdbarch));
1212       rsa = &p.first->second;
1213
1214       /* Make sure that the packet buffer is plenty big enough for
1215          this architecture.  */
1216       if (this->buf.size () < rsa->remote_packet_size)
1217         this->buf.resize (2 * rsa->remote_packet_size);
1218     }
1219   else
1220     rsa = &it->second;
1221
1222   return rsa;
1223 }
1224
1225 /* Fetch the global remote target state.  */
1226
1227 remote_state *
1228 remote_target::get_remote_state ()
1229 {
1230   /* Make sure that the remote architecture state has been
1231      initialized, because doing so might reallocate rs->buf.  Any
1232      function which calls getpkt also needs to be mindful of changes
1233      to rs->buf, but this call limits the number of places which run
1234      into trouble.  */
1235   m_remote_state.get_remote_arch_state (target_gdbarch ());
1236
1237   return &m_remote_state;
1238 }
1239
1240 /* Cleanup routine for the remote module's pspace data.  */
1241
1242 static void
1243 remote_pspace_data_cleanup (struct program_space *pspace, void *arg)
1244 {
1245   char *remote_exec_file = (char *) arg;
1246
1247   xfree (remote_exec_file);
1248 }
1249
1250 /* Fetch the remote exec-file from the current program space.  */
1251
1252 static const char *
1253 get_remote_exec_file (void)
1254 {
1255   char *remote_exec_file;
1256
1257   remote_exec_file
1258     = (char *) program_space_data (current_program_space,
1259                                    remote_pspace_data);
1260   if (remote_exec_file == NULL)
1261     return "";
1262
1263   return remote_exec_file;
1264 }
1265
1266 /* Set the remote exec file for PSPACE.  */
1267
1268 static void
1269 set_pspace_remote_exec_file (struct program_space *pspace,
1270                         char *remote_exec_file)
1271 {
1272   char *old_file = (char *) program_space_data (pspace, remote_pspace_data);
1273
1274   xfree (old_file);
1275   set_program_space_data (pspace, remote_pspace_data,
1276                           xstrdup (remote_exec_file));
1277 }
1278
1279 /* The "set/show remote exec-file" set command hook.  */
1280
1281 static void
1282 set_remote_exec_file (const char *ignored, int from_tty,
1283                       struct cmd_list_element *c)
1284 {
1285   gdb_assert (remote_exec_file_var != NULL);
1286   set_pspace_remote_exec_file (current_program_space, remote_exec_file_var);
1287 }
1288
1289 /* The "set/show remote exec-file" show command hook.  */
1290
1291 static void
1292 show_remote_exec_file (struct ui_file *file, int from_tty,
1293                        struct cmd_list_element *cmd, const char *value)
1294 {
1295   fprintf_filtered (file, "%s\n", remote_exec_file_var);
1296 }
1297
1298 static int
1299 compare_pnums (const void *lhs_, const void *rhs_)
1300 {
1301   const struct packet_reg * const *lhs
1302     = (const struct packet_reg * const *) lhs_;
1303   const struct packet_reg * const *rhs
1304     = (const struct packet_reg * const *) rhs_;
1305
1306   if ((*lhs)->pnum < (*rhs)->pnum)
1307     return -1;
1308   else if ((*lhs)->pnum == (*rhs)->pnum)
1309     return 0;
1310   else
1311     return 1;
1312 }
1313
1314 static int
1315 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
1316 {
1317   int regnum, num_remote_regs, offset;
1318   struct packet_reg **remote_regs;
1319
1320   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
1321     {
1322       struct packet_reg *r = &regs[regnum];
1323
1324       if (register_size (gdbarch, regnum) == 0)
1325         /* Do not try to fetch zero-sized (placeholder) registers.  */
1326         r->pnum = -1;
1327       else
1328         r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
1329
1330       r->regnum = regnum;
1331     }
1332
1333   /* Define the g/G packet format as the contents of each register
1334      with a remote protocol number, in order of ascending protocol
1335      number.  */
1336
1337   remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch));
1338   for (num_remote_regs = 0, regnum = 0;
1339        regnum < gdbarch_num_regs (gdbarch);
1340        regnum++)
1341     if (regs[regnum].pnum != -1)
1342       remote_regs[num_remote_regs++] = &regs[regnum];
1343
1344   qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
1345          compare_pnums);
1346
1347   for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
1348     {
1349       remote_regs[regnum]->in_g_packet = 1;
1350       remote_regs[regnum]->offset = offset;
1351       offset += register_size (gdbarch, remote_regs[regnum]->regnum);
1352     }
1353
1354   return offset;
1355 }
1356
1357 /* Given the architecture described by GDBARCH, return the remote
1358    protocol register's number and the register's offset in the g/G
1359    packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1360    If the target does not have a mapping for REGNUM, return false,
1361    otherwise, return true.  */
1362
1363 int
1364 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
1365                                    int *pnum, int *poffset)
1366 {
1367   gdb_assert (regnum < gdbarch_num_regs (gdbarch));
1368
1369   std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch));
1370
1371   map_regcache_remote_table (gdbarch, regs.data ());
1372
1373   *pnum = regs[regnum].pnum;
1374   *poffset = regs[regnum].offset;
1375
1376   return *pnum != -1;
1377 }
1378
1379 remote_arch_state::remote_arch_state (struct gdbarch *gdbarch)
1380 {
1381   /* Use the architecture to build a regnum<->pnum table, which will be
1382      1:1 unless a feature set specifies otherwise.  */
1383   this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ());
1384
1385   /* Record the maximum possible size of the g packet - it may turn out
1386      to be smaller.  */
1387   this->sizeof_g_packet
1388     = map_regcache_remote_table (gdbarch, this->regs.get ());
1389
1390   /* Default maximum number of characters in a packet body.  Many
1391      remote stubs have a hardwired buffer size of 400 bytes
1392      (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used
1393      as the maximum packet-size to ensure that the packet and an extra
1394      NUL character can always fit in the buffer.  This stops GDB
1395      trashing stubs that try to squeeze an extra NUL into what is
1396      already a full buffer (As of 1999-12-04 that was most stubs).  */
1397   this->remote_packet_size = 400 - 1;
1398
1399   /* This one is filled in when a ``g'' packet is received.  */
1400   this->actual_register_packet_size = 0;
1401
1402   /* Should rsa->sizeof_g_packet needs more space than the
1403      default, adjust the size accordingly.  Remember that each byte is
1404      encoded as two characters.  32 is the overhead for the packet
1405      header / footer.  NOTE: cagney/1999-10-26: I suspect that 8
1406      (``$NN:G...#NN'') is a better guess, the below has been padded a
1407      little.  */
1408   if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2))
1409     this->remote_packet_size = (this->sizeof_g_packet * 2 + 32);
1410 }
1411
1412 /* Get a pointer to the current remote target.  If not connected to a
1413    remote target, return NULL.  */
1414
1415 static remote_target *
1416 get_current_remote_target ()
1417 {
1418   target_ops *proc_target = find_target_at (process_stratum);
1419   return dynamic_cast<remote_target *> (proc_target);
1420 }
1421
1422 /* Return the current allowed size of a remote packet.  This is
1423    inferred from the current architecture, and should be used to
1424    limit the length of outgoing packets.  */
1425 long
1426 remote_target::get_remote_packet_size ()
1427 {
1428   struct remote_state *rs = get_remote_state ();
1429   remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1430
1431   if (rs->explicit_packet_size)
1432     return rs->explicit_packet_size;
1433
1434   return rsa->remote_packet_size;
1435 }
1436
1437 static struct packet_reg *
1438 packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1439                         long regnum)
1440 {
1441   if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch))
1442     return NULL;
1443   else
1444     {
1445       struct packet_reg *r = &rsa->regs[regnum];
1446
1447       gdb_assert (r->regnum == regnum);
1448       return r;
1449     }
1450 }
1451
1452 static struct packet_reg *
1453 packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1454                       LONGEST pnum)
1455 {
1456   int i;
1457
1458   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
1459     {
1460       struct packet_reg *r = &rsa->regs[i];
1461
1462       if (r->pnum == pnum)
1463         return r;
1464     }
1465   return NULL;
1466 }
1467
1468 /* Allow the user to specify what sequence to send to the remote
1469    when he requests a program interruption: Although ^C is usually
1470    what remote systems expect (this is the default, here), it is
1471    sometimes preferable to send a break.  On other systems such
1472    as the Linux kernel, a break followed by g, which is Magic SysRq g
1473    is required in order to interrupt the execution.  */
1474 const char interrupt_sequence_control_c[] = "Ctrl-C";
1475 const char interrupt_sequence_break[] = "BREAK";
1476 const char interrupt_sequence_break_g[] = "BREAK-g";
1477 static const char *const interrupt_sequence_modes[] =
1478   {
1479     interrupt_sequence_control_c,
1480     interrupt_sequence_break,
1481     interrupt_sequence_break_g,
1482     NULL
1483   };
1484 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
1485
1486 static void
1487 show_interrupt_sequence (struct ui_file *file, int from_tty,
1488                          struct cmd_list_element *c,
1489                          const char *value)
1490 {
1491   if (interrupt_sequence_mode == interrupt_sequence_control_c)
1492     fprintf_filtered (file,
1493                       _("Send the ASCII ETX character (Ctrl-c) "
1494                         "to the remote target to interrupt the "
1495                         "execution of the program.\n"));
1496   else if (interrupt_sequence_mode == interrupt_sequence_break)
1497     fprintf_filtered (file,
1498                       _("send a break signal to the remote target "
1499                         "to interrupt the execution of the program.\n"));
1500   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
1501     fprintf_filtered (file,
1502                       _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1503                         "the remote target to interrupt the execution "
1504                         "of Linux kernel.\n"));
1505   else
1506     internal_error (__FILE__, __LINE__,
1507                     _("Invalid value for interrupt_sequence_mode: %s."),
1508                     interrupt_sequence_mode);
1509 }
1510
1511 /* This boolean variable specifies whether interrupt_sequence is sent
1512    to the remote target when gdb connects to it.
1513    This is mostly needed when you debug the Linux kernel: The Linux kernel
1514    expects BREAK g which is Magic SysRq g for connecting gdb.  */
1515 static int interrupt_on_connect = 0;
1516
1517 /* This variable is used to implement the "set/show remotebreak" commands.
1518    Since these commands are now deprecated in favor of "set/show remote
1519    interrupt-sequence", it no longer has any effect on the code.  */
1520 static int remote_break;
1521
1522 static void
1523 set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
1524 {
1525   if (remote_break)
1526     interrupt_sequence_mode = interrupt_sequence_break;
1527   else
1528     interrupt_sequence_mode = interrupt_sequence_control_c;
1529 }
1530
1531 static void
1532 show_remotebreak (struct ui_file *file, int from_tty,
1533                   struct cmd_list_element *c,
1534                   const char *value)
1535 {
1536 }
1537
1538 /* This variable sets the number of bits in an address that are to be
1539    sent in a memory ("M" or "m") packet.  Normally, after stripping
1540    leading zeros, the entire address would be sent.  This variable
1541    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
1542    initial implementation of remote.c restricted the address sent in
1543    memory packets to ``host::sizeof long'' bytes - (typically 32
1544    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
1545    address was never sent.  Since fixing this bug may cause a break in
1546    some remote targets this variable is principly provided to
1547    facilitate backward compatibility.  */
1548
1549 static unsigned int remote_address_size;
1550
1551 \f
1552 /* User configurable variables for the number of characters in a
1553    memory read/write packet.  MIN (rsa->remote_packet_size,
1554    rsa->sizeof_g_packet) is the default.  Some targets need smaller
1555    values (fifo overruns, et.al.) and some users need larger values
1556    (speed up transfers).  The variables ``preferred_*'' (the user
1557    request), ``current_*'' (what was actually set) and ``forced_*''
1558    (Positive - a soft limit, negative - a hard limit).  */
1559
1560 struct memory_packet_config
1561 {
1562   const char *name;
1563   long size;
1564   int fixed_p;
1565 };
1566
1567 /* The default max memory-write-packet-size, when the setting is
1568    "fixed".  The 16k is historical.  (It came from older GDB's using
1569    alloca for buffers and the knowledge (folklore?) that some hosts
1570    don't cope very well with large alloca calls.)  */
1571 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1572
1573 /* The minimum remote packet size for memory transfers.  Ensures we
1574    can write at least one byte.  */
1575 #define MIN_MEMORY_PACKET_SIZE 20
1576
1577 /* Get the memory packet size, assuming it is fixed.  */
1578
1579 static long
1580 get_fixed_memory_packet_size (struct memory_packet_config *config)
1581 {
1582   gdb_assert (config->fixed_p);
1583
1584   if (config->size <= 0)
1585     return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED;
1586   else
1587     return config->size;
1588 }
1589
1590 /* Compute the current size of a read/write packet.  Since this makes
1591    use of ``actual_register_packet_size'' the computation is dynamic.  */
1592
1593 long
1594 remote_target::get_memory_packet_size (struct memory_packet_config *config)
1595 {
1596   struct remote_state *rs = get_remote_state ();
1597   remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1598
1599   long what_they_get;
1600   if (config->fixed_p)
1601     what_they_get = get_fixed_memory_packet_size (config);
1602   else
1603     {
1604       what_they_get = get_remote_packet_size ();
1605       /* Limit the packet to the size specified by the user.  */
1606       if (config->size > 0
1607           && what_they_get > config->size)
1608         what_they_get = config->size;
1609
1610       /* Limit it to the size of the targets ``g'' response unless we have
1611          permission from the stub to use a larger packet size.  */
1612       if (rs->explicit_packet_size == 0
1613           && rsa->actual_register_packet_size > 0
1614           && what_they_get > rsa->actual_register_packet_size)
1615         what_they_get = rsa->actual_register_packet_size;
1616     }
1617   if (what_they_get < MIN_MEMORY_PACKET_SIZE)
1618     what_they_get = MIN_MEMORY_PACKET_SIZE;
1619
1620   /* Make sure there is room in the global buffer for this packet
1621      (including its trailing NUL byte).  */
1622   if (rs->buf.size () < what_they_get + 1)
1623     rs->buf.resize (2 * what_they_get);
1624
1625   return what_they_get;
1626 }
1627
1628 /* Update the size of a read/write packet.  If they user wants
1629    something really big then do a sanity check.  */
1630
1631 static void
1632 set_memory_packet_size (const char *args, struct memory_packet_config *config)
1633 {
1634   int fixed_p = config->fixed_p;
1635   long size = config->size;
1636
1637   if (args == NULL)
1638     error (_("Argument required (integer, `fixed' or `limited')."));
1639   else if (strcmp (args, "hard") == 0
1640       || strcmp (args, "fixed") == 0)
1641     fixed_p = 1;
1642   else if (strcmp (args, "soft") == 0
1643            || strcmp (args, "limit") == 0)
1644     fixed_p = 0;
1645   else
1646     {
1647       char *end;
1648
1649       size = strtoul (args, &end, 0);
1650       if (args == end)
1651         error (_("Invalid %s (bad syntax)."), config->name);
1652
1653       /* Instead of explicitly capping the size of a packet to or
1654          disallowing it, the user is allowed to set the size to
1655          something arbitrarily large.  */
1656     }
1657
1658   /* Extra checks?  */
1659   if (fixed_p && !config->fixed_p)
1660     {
1661       /* So that the query shows the correct value.  */
1662       long query_size = (size <= 0
1663                          ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1664                          : size);
1665
1666       if (! query (_("The target may not be able to correctly handle a %s\n"
1667                    "of %ld bytes. Change the packet size? "),
1668                    config->name, query_size))
1669         error (_("Packet size not changed."));
1670     }
1671   /* Update the config.  */
1672   config->fixed_p = fixed_p;
1673   config->size = size;
1674 }
1675
1676 static void
1677 show_memory_packet_size (struct memory_packet_config *config)
1678 {
1679   if (config->size == 0)
1680     printf_filtered (_("The %s is 0 (default). "), config->name);
1681   else
1682     printf_filtered (_("The %s is %ld. "), config->name, config->size);
1683   if (config->fixed_p)
1684     printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1685                      get_fixed_memory_packet_size (config));
1686   else
1687     {
1688       remote_target *remote = get_current_remote_target ();
1689
1690       if (remote != NULL)
1691         printf_filtered (_("Packets are limited to %ld bytes.\n"),
1692                          remote->get_memory_packet_size (config));
1693       else
1694         puts_filtered ("The actual limit will be further reduced "
1695                        "dependent on the target.\n");
1696     }
1697 }
1698
1699 static struct memory_packet_config memory_write_packet_config =
1700 {
1701   "memory-write-packet-size",
1702 };
1703
1704 static void
1705 set_memory_write_packet_size (const char *args, int from_tty)
1706 {
1707   set_memory_packet_size (args, &memory_write_packet_config);
1708 }
1709
1710 static void
1711 show_memory_write_packet_size (const char *args, int from_tty)
1712 {
1713   show_memory_packet_size (&memory_write_packet_config);
1714 }
1715
1716 /* Show the number of hardware watchpoints that can be used.  */
1717
1718 static void
1719 show_hardware_watchpoint_limit (struct ui_file *file, int from_tty,
1720                                 struct cmd_list_element *c,
1721                                 const char *value)
1722 {
1723   fprintf_filtered (file, _("The maximum number of target hardware "
1724                             "watchpoints is %s.\n"), value);
1725 }
1726
1727 /* Show the length limit (in bytes) for hardware watchpoints.  */
1728
1729 static void
1730 show_hardware_watchpoint_length_limit (struct ui_file *file, int from_tty,
1731                                        struct cmd_list_element *c,
1732                                        const char *value)
1733 {
1734   fprintf_filtered (file, _("The maximum length (in bytes) of a target "
1735                             "hardware watchpoint is %s.\n"), value);
1736 }
1737
1738 /* Show the number of hardware breakpoints that can be used.  */
1739
1740 static void
1741 show_hardware_breakpoint_limit (struct ui_file *file, int from_tty,
1742                                 struct cmd_list_element *c,
1743                                 const char *value)
1744 {
1745   fprintf_filtered (file, _("The maximum number of target hardware "
1746                             "breakpoints is %s.\n"), value);
1747 }
1748
1749 long
1750 remote_target::get_memory_write_packet_size ()
1751 {
1752   return get_memory_packet_size (&memory_write_packet_config);
1753 }
1754
1755 static struct memory_packet_config memory_read_packet_config =
1756 {
1757   "memory-read-packet-size",
1758 };
1759
1760 static void
1761 set_memory_read_packet_size (const char *args, int from_tty)
1762 {
1763   set_memory_packet_size (args, &memory_read_packet_config);
1764 }
1765
1766 static void
1767 show_memory_read_packet_size (const char *args, int from_tty)
1768 {
1769   show_memory_packet_size (&memory_read_packet_config);
1770 }
1771
1772 long
1773 remote_target::get_memory_read_packet_size ()
1774 {
1775   long size = get_memory_packet_size (&memory_read_packet_config);
1776
1777   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1778      extra buffer size argument before the memory read size can be
1779      increased beyond this.  */
1780   if (size > get_remote_packet_size ())
1781     size = get_remote_packet_size ();
1782   return size;
1783 }
1784
1785 \f
1786
1787 struct packet_config
1788   {
1789     const char *name;
1790     const char *title;
1791
1792     /* If auto, GDB auto-detects support for this packet or feature,
1793        either through qSupported, or by trying the packet and looking
1794        at the response.  If true, GDB assumes the target supports this
1795        packet.  If false, the packet is disabled.  Configs that don't
1796        have an associated command always have this set to auto.  */
1797     enum auto_boolean detect;
1798
1799     /* Does the target support this packet?  */
1800     enum packet_support support;
1801   };
1802
1803 static enum packet_support packet_config_support (struct packet_config *config);
1804 static enum packet_support packet_support (int packet);
1805
1806 static void
1807 show_packet_config_cmd (struct packet_config *config)
1808 {
1809   const char *support = "internal-error";
1810
1811   switch (packet_config_support (config))
1812     {
1813     case PACKET_ENABLE:
1814       support = "enabled";
1815       break;
1816     case PACKET_DISABLE:
1817       support = "disabled";
1818       break;
1819     case PACKET_SUPPORT_UNKNOWN:
1820       support = "unknown";
1821       break;
1822     }
1823   switch (config->detect)
1824     {
1825     case AUTO_BOOLEAN_AUTO:
1826       printf_filtered (_("Support for the `%s' packet "
1827                          "is auto-detected, currently %s.\n"),
1828                        config->name, support);
1829       break;
1830     case AUTO_BOOLEAN_TRUE:
1831     case AUTO_BOOLEAN_FALSE:
1832       printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1833                        config->name, support);
1834       break;
1835     }
1836 }
1837
1838 static void
1839 add_packet_config_cmd (struct packet_config *config, const char *name,
1840                        const char *title, int legacy)
1841 {
1842   char *set_doc;
1843   char *show_doc;
1844   char *cmd_name;
1845
1846   config->name = name;
1847   config->title = title;
1848   set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1849                         name, title);
1850   show_doc = xstrprintf ("Show current use of remote "
1851                          "protocol `%s' (%s) packet",
1852                          name, title);
1853   /* set/show TITLE-packet {auto,on,off} */
1854   cmd_name = xstrprintf ("%s-packet", title);
1855   add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1856                                 &config->detect, set_doc,
1857                                 show_doc, NULL, /* help_doc */
1858                                 NULL,
1859                                 show_remote_protocol_packet_cmd,
1860                                 &remote_set_cmdlist, &remote_show_cmdlist);
1861   /* The command code copies the documentation strings.  */
1862   xfree (set_doc);
1863   xfree (show_doc);
1864   /* set/show remote NAME-packet {auto,on,off} -- legacy.  */
1865   if (legacy)
1866     {
1867       char *legacy_name;
1868
1869       legacy_name = xstrprintf ("%s-packet", name);
1870       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1871                      &remote_set_cmdlist);
1872       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1873                      &remote_show_cmdlist);
1874     }
1875 }
1876
1877 static enum packet_result
1878 packet_check_result (const char *buf)
1879 {
1880   if (buf[0] != '\0')
1881     {
1882       /* The stub recognized the packet request.  Check that the
1883          operation succeeded.  */
1884       if (buf[0] == 'E'
1885           && isxdigit (buf[1]) && isxdigit (buf[2])
1886           && buf[3] == '\0')
1887         /* "Enn"  - definitly an error.  */
1888         return PACKET_ERROR;
1889
1890       /* Always treat "E." as an error.  This will be used for
1891          more verbose error messages, such as E.memtypes.  */
1892       if (buf[0] == 'E' && buf[1] == '.')
1893         return PACKET_ERROR;
1894
1895       /* The packet may or may not be OK.  Just assume it is.  */
1896       return PACKET_OK;
1897     }
1898   else
1899     /* The stub does not support the packet.  */
1900     return PACKET_UNKNOWN;
1901 }
1902
1903 static enum packet_result
1904 packet_check_result (const gdb::char_vector &buf)
1905 {
1906   return packet_check_result (buf.data ());
1907 }
1908
1909 static enum packet_result
1910 packet_ok (const char *buf, struct packet_config *config)
1911 {
1912   enum packet_result result;
1913
1914   if (config->detect != AUTO_BOOLEAN_TRUE
1915       && config->support == PACKET_DISABLE)
1916     internal_error (__FILE__, __LINE__,
1917                     _("packet_ok: attempt to use a disabled packet"));
1918
1919   result = packet_check_result (buf);
1920   switch (result)
1921     {
1922     case PACKET_OK:
1923     case PACKET_ERROR:
1924       /* The stub recognized the packet request.  */
1925       if (config->support == PACKET_SUPPORT_UNKNOWN)
1926         {
1927           if (remote_debug)
1928             fprintf_unfiltered (gdb_stdlog,
1929                                 "Packet %s (%s) is supported\n",
1930                                 config->name, config->title);
1931           config->support = PACKET_ENABLE;
1932         }
1933       break;
1934     case PACKET_UNKNOWN:
1935       /* The stub does not support the packet.  */
1936       if (config->detect == AUTO_BOOLEAN_AUTO
1937           && config->support == PACKET_ENABLE)
1938         {
1939           /* If the stub previously indicated that the packet was
1940              supported then there is a protocol error.  */
1941           error (_("Protocol error: %s (%s) conflicting enabled responses."),
1942                  config->name, config->title);
1943         }
1944       else if (config->detect == AUTO_BOOLEAN_TRUE)
1945         {
1946           /* The user set it wrong.  */
1947           error (_("Enabled packet %s (%s) not recognized by stub"),
1948                  config->name, config->title);
1949         }
1950
1951       if (remote_debug)
1952         fprintf_unfiltered (gdb_stdlog,
1953                             "Packet %s (%s) is NOT supported\n",
1954                             config->name, config->title);
1955       config->support = PACKET_DISABLE;
1956       break;
1957     }
1958
1959   return result;
1960 }
1961
1962 static enum packet_result
1963 packet_ok (const gdb::char_vector &buf, struct packet_config *config)
1964 {
1965   return packet_ok (buf.data (), config);
1966 }
1967
1968 enum {
1969   PACKET_vCont = 0,
1970   PACKET_X,
1971   PACKET_qSymbol,
1972   PACKET_P,
1973   PACKET_p,
1974   PACKET_Z0,
1975   PACKET_Z1,
1976   PACKET_Z2,
1977   PACKET_Z3,
1978   PACKET_Z4,
1979   PACKET_vFile_setfs,
1980   PACKET_vFile_open,
1981   PACKET_vFile_pread,
1982   PACKET_vFile_pwrite,
1983   PACKET_vFile_close,
1984   PACKET_vFile_unlink,
1985   PACKET_vFile_readlink,
1986   PACKET_vFile_fstat,
1987   PACKET_qXfer_auxv,
1988   PACKET_qXfer_features,
1989   PACKET_qXfer_exec_file,
1990   PACKET_qXfer_libraries,
1991   PACKET_qXfer_libraries_svr4,
1992   PACKET_qXfer_memory_map,
1993   PACKET_qXfer_spu_read,
1994   PACKET_qXfer_spu_write,
1995   PACKET_qXfer_osdata,
1996   PACKET_qXfer_threads,
1997   PACKET_qXfer_statictrace_read,
1998   PACKET_qXfer_traceframe_info,
1999   PACKET_qXfer_uib,
2000   PACKET_qGetTIBAddr,
2001   PACKET_qGetTLSAddr,
2002   PACKET_qSupported,
2003   PACKET_qTStatus,
2004   PACKET_QPassSignals,
2005   PACKET_QCatchSyscalls,
2006   PACKET_QProgramSignals,
2007   PACKET_QSetWorkingDir,
2008   PACKET_QStartupWithShell,
2009   PACKET_QEnvironmentHexEncoded,
2010   PACKET_QEnvironmentReset,
2011   PACKET_QEnvironmentUnset,
2012   PACKET_qCRC,
2013   PACKET_qSearch_memory,
2014   PACKET_vAttach,
2015   PACKET_vRun,
2016   PACKET_QStartNoAckMode,
2017   PACKET_vKill,
2018   PACKET_qXfer_siginfo_read,
2019   PACKET_qXfer_siginfo_write,
2020   PACKET_qAttached,
2021
2022   /* Support for conditional tracepoints.  */
2023   PACKET_ConditionalTracepoints,
2024
2025   /* Support for target-side breakpoint conditions.  */
2026   PACKET_ConditionalBreakpoints,
2027
2028   /* Support for target-side breakpoint commands.  */
2029   PACKET_BreakpointCommands,
2030
2031   /* Support for fast tracepoints.  */
2032   PACKET_FastTracepoints,
2033
2034   /* Support for static tracepoints.  */
2035   PACKET_StaticTracepoints,
2036
2037   /* Support for installing tracepoints while a trace experiment is
2038      running.  */
2039   PACKET_InstallInTrace,
2040
2041   PACKET_bc,
2042   PACKET_bs,
2043   PACKET_TracepointSource,
2044   PACKET_QAllow,
2045   PACKET_qXfer_fdpic,
2046   PACKET_QDisableRandomization,
2047   PACKET_QAgent,
2048   PACKET_QTBuffer_size,
2049   PACKET_Qbtrace_off,
2050   PACKET_Qbtrace_bts,
2051   PACKET_Qbtrace_pt,
2052   PACKET_qXfer_btrace,
2053
2054   /* Support for the QNonStop packet.  */
2055   PACKET_QNonStop,
2056
2057   /* Support for the QThreadEvents packet.  */
2058   PACKET_QThreadEvents,
2059
2060   /* Support for multi-process extensions.  */
2061   PACKET_multiprocess_feature,
2062
2063   /* Support for enabling and disabling tracepoints while a trace
2064      experiment is running.  */
2065   PACKET_EnableDisableTracepoints_feature,
2066
2067   /* Support for collecting strings using the tracenz bytecode.  */
2068   PACKET_tracenz_feature,
2069
2070   /* Support for continuing to run a trace experiment while GDB is
2071      disconnected.  */
2072   PACKET_DisconnectedTracing_feature,
2073
2074   /* Support for qXfer:libraries-svr4:read with a non-empty annex.  */
2075   PACKET_augmented_libraries_svr4_read_feature,
2076
2077   /* Support for the qXfer:btrace-conf:read packet.  */
2078   PACKET_qXfer_btrace_conf,
2079
2080   /* Support for the Qbtrace-conf:bts:size packet.  */
2081   PACKET_Qbtrace_conf_bts_size,
2082
2083   /* Support for swbreak+ feature.  */
2084   PACKET_swbreak_feature,
2085
2086   /* Support for hwbreak+ feature.  */
2087   PACKET_hwbreak_feature,
2088
2089   /* Support for fork events.  */
2090   PACKET_fork_event_feature,
2091
2092   /* Support for vfork events.  */
2093   PACKET_vfork_event_feature,
2094
2095   /* Support for the Qbtrace-conf:pt:size packet.  */
2096   PACKET_Qbtrace_conf_pt_size,
2097
2098   /* Support for exec events.  */
2099   PACKET_exec_event_feature,
2100
2101   /* Support for query supported vCont actions.  */
2102   PACKET_vContSupported,
2103
2104   /* Support remote CTRL-C.  */
2105   PACKET_vCtrlC,
2106
2107   /* Support TARGET_WAITKIND_NO_RESUMED.  */
2108   PACKET_no_resumed,
2109
2110   PACKET_MAX
2111 };
2112
2113 static struct packet_config remote_protocol_packets[PACKET_MAX];
2114
2115 /* Returns the packet's corresponding "set remote foo-packet" command
2116    state.  See struct packet_config for more details.  */
2117
2118 static enum auto_boolean
2119 packet_set_cmd_state (int packet)
2120 {
2121   return remote_protocol_packets[packet].detect;
2122 }
2123
2124 /* Returns whether a given packet or feature is supported.  This takes
2125    into account the state of the corresponding "set remote foo-packet"
2126    command, which may be used to bypass auto-detection.  */
2127
2128 static enum packet_support
2129 packet_config_support (struct packet_config *config)
2130 {
2131   switch (config->detect)
2132     {
2133     case AUTO_BOOLEAN_TRUE:
2134       return PACKET_ENABLE;
2135     case AUTO_BOOLEAN_FALSE:
2136       return PACKET_DISABLE;
2137     case AUTO_BOOLEAN_AUTO:
2138       return config->support;
2139     default:
2140       gdb_assert_not_reached (_("bad switch"));
2141     }
2142 }
2143
2144 /* Same as packet_config_support, but takes the packet's enum value as
2145    argument.  */
2146
2147 static enum packet_support
2148 packet_support (int packet)
2149 {
2150   struct packet_config *config = &remote_protocol_packets[packet];
2151
2152   return packet_config_support (config);
2153 }
2154
2155 static void
2156 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
2157                                  struct cmd_list_element *c,
2158                                  const char *value)
2159 {
2160   struct packet_config *packet;
2161
2162   for (packet = remote_protocol_packets;
2163        packet < &remote_protocol_packets[PACKET_MAX];
2164        packet++)
2165     {
2166       if (&packet->detect == c->var)
2167         {
2168           show_packet_config_cmd (packet);
2169           return;
2170         }
2171     }
2172   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
2173                   c->name);
2174 }
2175
2176 /* Should we try one of the 'Z' requests?  */
2177
2178 enum Z_packet_type
2179 {
2180   Z_PACKET_SOFTWARE_BP,
2181   Z_PACKET_HARDWARE_BP,
2182   Z_PACKET_WRITE_WP,
2183   Z_PACKET_READ_WP,
2184   Z_PACKET_ACCESS_WP,
2185   NR_Z_PACKET_TYPES
2186 };
2187
2188 /* For compatibility with older distributions.  Provide a ``set remote
2189    Z-packet ...'' command that updates all the Z packet types.  */
2190
2191 static enum auto_boolean remote_Z_packet_detect;
2192
2193 static void
2194 set_remote_protocol_Z_packet_cmd (const char *args, int from_tty,
2195                                   struct cmd_list_element *c)
2196 {
2197   int i;
2198
2199   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2200     remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
2201 }
2202
2203 static void
2204 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
2205                                    struct cmd_list_element *c,
2206                                    const char *value)
2207 {
2208   int i;
2209
2210   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2211     {
2212       show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
2213     }
2214 }
2215
2216 /* Returns true if the multi-process extensions are in effect.  */
2217
2218 static int
2219 remote_multi_process_p (struct remote_state *rs)
2220 {
2221   return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
2222 }
2223
2224 /* Returns true if fork events are supported.  */
2225
2226 static int
2227 remote_fork_event_p (struct remote_state *rs)
2228 {
2229   return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
2230 }
2231
2232 /* Returns true if vfork events are supported.  */
2233
2234 static int
2235 remote_vfork_event_p (struct remote_state *rs)
2236 {
2237   return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
2238 }
2239
2240 /* Returns true if exec events are supported.  */
2241
2242 static int
2243 remote_exec_event_p (struct remote_state *rs)
2244 {
2245   return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
2246 }
2247
2248 /* Insert fork catchpoint target routine.  If fork events are enabled
2249    then return success, nothing more to do.  */
2250
2251 int
2252 remote_target::insert_fork_catchpoint (int pid)
2253 {
2254   struct remote_state *rs = get_remote_state ();
2255
2256   return !remote_fork_event_p (rs);
2257 }
2258
2259 /* Remove fork catchpoint target routine.  Nothing to do, just
2260    return success.  */
2261
2262 int
2263 remote_target::remove_fork_catchpoint (int pid)
2264 {
2265   return 0;
2266 }
2267
2268 /* Insert vfork catchpoint target routine.  If vfork events are enabled
2269    then return success, nothing more to do.  */
2270
2271 int
2272 remote_target::insert_vfork_catchpoint (int pid)
2273 {
2274   struct remote_state *rs = get_remote_state ();
2275
2276   return !remote_vfork_event_p (rs);
2277 }
2278
2279 /* Remove vfork catchpoint target routine.  Nothing to do, just
2280    return success.  */
2281
2282 int
2283 remote_target::remove_vfork_catchpoint (int pid)
2284 {
2285   return 0;
2286 }
2287
2288 /* Insert exec catchpoint target routine.  If exec events are
2289    enabled, just return success.  */
2290
2291 int
2292 remote_target::insert_exec_catchpoint (int pid)
2293 {
2294   struct remote_state *rs = get_remote_state ();
2295
2296   return !remote_exec_event_p (rs);
2297 }
2298
2299 /* Remove exec catchpoint target routine.  Nothing to do, just
2300    return success.  */
2301
2302 int
2303 remote_target::remove_exec_catchpoint (int pid)
2304 {
2305   return 0;
2306 }
2307
2308 \f
2309
2310 static ptid_t magic_null_ptid;
2311 static ptid_t not_sent_ptid;
2312 static ptid_t any_thread_ptid;
2313
2314 /* Find out if the stub attached to PID (and hence GDB should offer to
2315    detach instead of killing it when bailing out).  */
2316
2317 int
2318 remote_target::remote_query_attached (int pid)
2319 {
2320   struct remote_state *rs = get_remote_state ();
2321   size_t size = get_remote_packet_size ();
2322
2323   if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
2324     return 0;
2325
2326   if (remote_multi_process_p (rs))
2327     xsnprintf (rs->buf.data (), size, "qAttached:%x", pid);
2328   else
2329     xsnprintf (rs->buf.data (), size, "qAttached");
2330
2331   putpkt (rs->buf);
2332   getpkt (&rs->buf, 0);
2333
2334   switch (packet_ok (rs->buf,
2335                      &remote_protocol_packets[PACKET_qAttached]))
2336     {
2337     case PACKET_OK:
2338       if (strcmp (rs->buf.data (), "1") == 0)
2339         return 1;
2340       break;
2341     case PACKET_ERROR:
2342       warning (_("Remote failure reply: %s"), rs->buf.data ());
2343       break;
2344     case PACKET_UNKNOWN:
2345       break;
2346     }
2347
2348   return 0;
2349 }
2350
2351 /* Add PID to GDB's inferior table.  If FAKE_PID_P is true, then PID
2352    has been invented by GDB, instead of reported by the target.  Since
2353    we can be connected to a remote system before before knowing about
2354    any inferior, mark the target with execution when we find the first
2355    inferior.  If ATTACHED is 1, then we had just attached to this
2356    inferior.  If it is 0, then we just created this inferior.  If it
2357    is -1, then try querying the remote stub to find out if it had
2358    attached to the inferior or not.  If TRY_OPEN_EXEC is true then
2359    attempt to open this inferior's executable as the main executable
2360    if no main executable is open already.  */
2361
2362 inferior *
2363 remote_target::remote_add_inferior (int fake_pid_p, int pid, int attached,
2364                                     int try_open_exec)
2365 {
2366   struct inferior *inf;
2367
2368   /* Check whether this process we're learning about is to be
2369      considered attached, or if is to be considered to have been
2370      spawned by the stub.  */
2371   if (attached == -1)
2372     attached = remote_query_attached (pid);
2373
2374   if (gdbarch_has_global_solist (target_gdbarch ()))
2375     {
2376       /* If the target shares code across all inferiors, then every
2377          attach adds a new inferior.  */
2378       inf = add_inferior (pid);
2379
2380       /* ... and every inferior is bound to the same program space.
2381          However, each inferior may still have its own address
2382          space.  */
2383       inf->aspace = maybe_new_address_space ();
2384       inf->pspace = current_program_space;
2385     }
2386   else
2387     {
2388       /* In the traditional debugging scenario, there's a 1-1 match
2389          between program/address spaces.  We simply bind the inferior
2390          to the program space's address space.  */
2391       inf = current_inferior ();
2392       inferior_appeared (inf, pid);
2393     }
2394
2395   inf->attach_flag = attached;
2396   inf->fake_pid_p = fake_pid_p;
2397
2398   /* If no main executable is currently open then attempt to
2399      open the file that was executed to create this inferior.  */
2400   if (try_open_exec && get_exec_file (0) == NULL)
2401     exec_file_locate_attach (pid, 0, 1);
2402
2403   return inf;
2404 }
2405
2406 static remote_thread_info *get_remote_thread_info (thread_info *thread);
2407 static remote_thread_info *get_remote_thread_info (ptid_t ptid);
2408
2409 /* Add thread PTID to GDB's thread list.  Tag it as executing/running
2410    according to RUNNING.  */
2411
2412 thread_info *
2413 remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing)
2414 {
2415   struct remote_state *rs = get_remote_state ();
2416   struct thread_info *thread;
2417
2418   /* GDB historically didn't pull threads in the initial connection
2419      setup.  If the remote target doesn't even have a concept of
2420      threads (e.g., a bare-metal target), even if internally we
2421      consider that a single-threaded target, mentioning a new thread
2422      might be confusing to the user.  Be silent then, preserving the
2423      age old behavior.  */
2424   if (rs->starting_up)
2425     thread = add_thread_silent (ptid);
2426   else
2427     thread = add_thread (ptid);
2428
2429   get_remote_thread_info (thread)->vcont_resumed = executing;
2430   set_executing (ptid, executing);
2431   set_running (ptid, running);
2432
2433   return thread;
2434 }
2435
2436 /* Come here when we learn about a thread id from the remote target.
2437    It may be the first time we hear about such thread, so take the
2438    opportunity to add it to GDB's thread list.  In case this is the
2439    first time we're noticing its corresponding inferior, add it to
2440    GDB's inferior list as well.  EXECUTING indicates whether the
2441    thread is (internally) executing or stopped.  */
2442
2443 void
2444 remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
2445 {
2446   /* In non-stop mode, we assume new found threads are (externally)
2447      running until proven otherwise with a stop reply.  In all-stop,
2448      we can only get here if all threads are stopped.  */
2449   int running = target_is_non_stop_p () ? 1 : 0;
2450
2451   /* If this is a new thread, add it to GDB's thread list.
2452      If we leave it up to WFI to do this, bad things will happen.  */
2453
2454   thread_info *tp = find_thread_ptid (currthread);
2455   if (tp != NULL && tp->state == THREAD_EXITED)
2456     {
2457       /* We're seeing an event on a thread id we knew had exited.
2458          This has to be a new thread reusing the old id.  Add it.  */
2459       remote_add_thread (currthread, running, executing);
2460       return;
2461     }
2462
2463   if (!in_thread_list (currthread))
2464     {
2465       struct inferior *inf = NULL;
2466       int pid = currthread.pid ();
2467
2468       if (inferior_ptid.is_pid ()
2469           && pid == inferior_ptid.pid ())
2470         {
2471           /* inferior_ptid has no thread member yet.  This can happen
2472              with the vAttach -> remote_wait,"TAAthread:" path if the
2473              stub doesn't support qC.  This is the first stop reported
2474              after an attach, so this is the main thread.  Update the
2475              ptid in the thread list.  */
2476           if (in_thread_list (ptid_t (pid)))
2477             thread_change_ptid (inferior_ptid, currthread);
2478           else
2479             {
2480               remote_add_thread (currthread, running, executing);
2481               inferior_ptid = currthread;
2482             }
2483           return;
2484         }
2485
2486       if (magic_null_ptid == inferior_ptid)
2487         {
2488           /* inferior_ptid is not set yet.  This can happen with the
2489              vRun -> remote_wait,"TAAthread:" path if the stub
2490              doesn't support qC.  This is the first stop reported
2491              after an attach, so this is the main thread.  Update the
2492              ptid in the thread list.  */
2493           thread_change_ptid (inferior_ptid, currthread);
2494           return;
2495         }
2496
2497       /* When connecting to a target remote, or to a target
2498          extended-remote which already was debugging an inferior, we
2499          may not know about it yet.  Add it before adding its child
2500          thread, so notifications are emitted in a sensible order.  */
2501       if (find_inferior_pid (currthread.pid ()) == NULL)
2502         {
2503           struct remote_state *rs = get_remote_state ();
2504           int fake_pid_p = !remote_multi_process_p (rs);
2505
2506           inf = remote_add_inferior (fake_pid_p,
2507                                      currthread.pid (), -1, 1);
2508         }
2509
2510       /* This is really a new thread.  Add it.  */
2511       thread_info *new_thr
2512         = remote_add_thread (currthread, running, executing);
2513
2514       /* If we found a new inferior, let the common code do whatever
2515          it needs to with it (e.g., read shared libraries, insert
2516          breakpoints), unless we're just setting up an all-stop
2517          connection.  */
2518       if (inf != NULL)
2519         {
2520           struct remote_state *rs = get_remote_state ();
2521
2522           if (!rs->starting_up)
2523             notice_new_inferior (new_thr, executing, 0);
2524         }
2525     }
2526 }
2527
2528 /* Return THREAD's private thread data, creating it if necessary.  */
2529
2530 static remote_thread_info *
2531 get_remote_thread_info (thread_info *thread)
2532 {
2533   gdb_assert (thread != NULL);
2534
2535   if (thread->priv == NULL)
2536     thread->priv.reset (new remote_thread_info);
2537
2538   return static_cast<remote_thread_info *> (thread->priv.get ());
2539 }
2540
2541 static remote_thread_info *
2542 get_remote_thread_info (ptid_t ptid)
2543 {
2544   thread_info *thr = find_thread_ptid (ptid);
2545   return get_remote_thread_info (thr);
2546 }
2547
2548 /* Call this function as a result of
2549    1) A halt indication (T packet) containing a thread id
2550    2) A direct query of currthread
2551    3) Successful execution of set thread */
2552
2553 static void
2554 record_currthread (struct remote_state *rs, ptid_t currthread)
2555 {
2556   rs->general_thread = currthread;
2557 }
2558
2559 /* If 'QPassSignals' is supported, tell the remote stub what signals
2560    it can simply pass through to the inferior without reporting.  */
2561
2562 void
2563 remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals)
2564 {
2565   if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
2566     {
2567       char *pass_packet, *p;
2568       int count = 0;
2569       struct remote_state *rs = get_remote_state ();
2570
2571       gdb_assert (pass_signals.size () < 256);
2572       for (size_t i = 0; i < pass_signals.size (); i++)
2573         {
2574           if (pass_signals[i])
2575             count++;
2576         }
2577       pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
2578       strcpy (pass_packet, "QPassSignals:");
2579       p = pass_packet + strlen (pass_packet);
2580       for (size_t i = 0; i < pass_signals.size (); i++)
2581         {
2582           if (pass_signals[i])
2583             {
2584               if (i >= 16)
2585                 *p++ = tohex (i >> 4);
2586               *p++ = tohex (i & 15);
2587               if (count)
2588                 *p++ = ';';
2589               else
2590                 break;
2591               count--;
2592             }
2593         }
2594       *p = 0;
2595       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
2596         {
2597           putpkt (pass_packet);
2598           getpkt (&rs->buf, 0);
2599           packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
2600           if (rs->last_pass_packet)
2601             xfree (rs->last_pass_packet);
2602           rs->last_pass_packet = pass_packet;
2603         }
2604       else
2605         xfree (pass_packet);
2606     }
2607 }
2608
2609 /* If 'QCatchSyscalls' is supported, tell the remote stub
2610    to report syscalls to GDB.  */
2611
2612 int
2613 remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
2614                                        gdb::array_view<const int> syscall_counts)
2615 {
2616   const char *catch_packet;
2617   enum packet_result result;
2618   int n_sysno = 0;
2619
2620   if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
2621     {
2622       /* Not supported.  */
2623       return 1;
2624     }
2625
2626   if (needed && any_count == 0)
2627     {
2628       /* Count how many syscalls are to be caught.  */
2629       for (size_t i = 0; i < syscall_counts.size (); i++)
2630         {
2631           if (syscall_counts[i] != 0)
2632             n_sysno++;
2633         }
2634     }
2635
2636   if (remote_debug)
2637     {
2638       fprintf_unfiltered (gdb_stdlog,
2639                           "remote_set_syscall_catchpoint "
2640                           "pid %d needed %d any_count %d n_sysno %d\n",
2641                           pid, needed, any_count, n_sysno);
2642     }
2643
2644   std::string built_packet;
2645   if (needed)
2646     {
2647       /* Prepare a packet with the sysno list, assuming max 8+1
2648          characters for a sysno.  If the resulting packet size is too
2649          big, fallback on the non-selective packet.  */
2650       const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1;
2651       built_packet.reserve (maxpktsz);
2652       built_packet = "QCatchSyscalls:1";
2653       if (any_count == 0)
2654         {
2655           /* Add in each syscall to be caught.  */
2656           for (size_t i = 0; i < syscall_counts.size (); i++)
2657             {
2658               if (syscall_counts[i] != 0)
2659                 string_appendf (built_packet, ";%zx", i);
2660             }
2661         }
2662       if (built_packet.size () > get_remote_packet_size ())
2663         {
2664           /* catch_packet too big.  Fallback to less efficient
2665              non selective mode, with GDB doing the filtering.  */
2666           catch_packet = "QCatchSyscalls:1";
2667         }
2668       else
2669         catch_packet = built_packet.c_str ();
2670     }
2671   else
2672     catch_packet = "QCatchSyscalls:0";
2673
2674   struct remote_state *rs = get_remote_state ();
2675
2676   putpkt (catch_packet);
2677   getpkt (&rs->buf, 0);
2678   result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
2679   if (result == PACKET_OK)
2680     return 0;
2681   else
2682     return -1;
2683 }
2684
2685 /* If 'QProgramSignals' is supported, tell the remote stub what
2686    signals it should pass through to the inferior when detaching.  */
2687
2688 void
2689 remote_target::program_signals (gdb::array_view<const unsigned char> signals)
2690 {
2691   if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
2692     {
2693       char *packet, *p;
2694       int count = 0;
2695       struct remote_state *rs = get_remote_state ();
2696
2697       gdb_assert (signals.size () < 256);
2698       for (size_t i = 0; i < signals.size (); i++)
2699         {
2700           if (signals[i])
2701             count++;
2702         }
2703       packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
2704       strcpy (packet, "QProgramSignals:");
2705       p = packet + strlen (packet);
2706       for (size_t i = 0; i < signals.size (); i++)
2707         {
2708           if (signal_pass_state (i))
2709             {
2710               if (i >= 16)
2711                 *p++ = tohex (i >> 4);
2712               *p++ = tohex (i & 15);
2713               if (count)
2714                 *p++ = ';';
2715               else
2716                 break;
2717               count--;
2718             }
2719         }
2720       *p = 0;
2721       if (!rs->last_program_signals_packet
2722           || strcmp (rs->last_program_signals_packet, packet) != 0)
2723         {
2724           putpkt (packet);
2725           getpkt (&rs->buf, 0);
2726           packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
2727           xfree (rs->last_program_signals_packet);
2728           rs->last_program_signals_packet = packet;
2729         }
2730       else
2731         xfree (packet);
2732     }
2733 }
2734
2735 /* If PTID is MAGIC_NULL_PTID, don't set any thread.  If PTID is
2736    MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2737    thread.  If GEN is set, set the general thread, if not, then set
2738    the step/continue thread.  */
2739 void
2740 remote_target::set_thread (ptid_t ptid, int gen)
2741 {
2742   struct remote_state *rs = get_remote_state ();
2743   ptid_t state = gen ? rs->general_thread : rs->continue_thread;
2744   char *buf = rs->buf.data ();
2745   char *endbuf = buf + get_remote_packet_size ();
2746
2747   if (state == ptid)
2748     return;
2749
2750   *buf++ = 'H';
2751   *buf++ = gen ? 'g' : 'c';
2752   if (ptid == magic_null_ptid)
2753     xsnprintf (buf, endbuf - buf, "0");
2754   else if (ptid == any_thread_ptid)
2755     xsnprintf (buf, endbuf - buf, "0");
2756   else if (ptid == minus_one_ptid)
2757     xsnprintf (buf, endbuf - buf, "-1");
2758   else
2759     write_ptid (buf, endbuf, ptid);
2760   putpkt (rs->buf);
2761   getpkt (&rs->buf, 0);
2762   if (gen)
2763     rs->general_thread = ptid;
2764   else
2765     rs->continue_thread = ptid;
2766 }
2767
2768 void
2769 remote_target::set_general_thread (ptid_t ptid)
2770 {
2771   set_thread (ptid, 1);
2772 }
2773
2774 void
2775 remote_target::set_continue_thread (ptid_t ptid)
2776 {
2777   set_thread (ptid, 0);
2778 }
2779
2780 /* Change the remote current process.  Which thread within the process
2781    ends up selected isn't important, as long as it is the same process
2782    as what INFERIOR_PTID points to.
2783
2784    This comes from that fact that there is no explicit notion of
2785    "selected process" in the protocol.  The selected process for
2786    general operations is the process the selected general thread
2787    belongs to.  */
2788
2789 void
2790 remote_target::set_general_process ()
2791 {
2792   struct remote_state *rs = get_remote_state ();
2793
2794   /* If the remote can't handle multiple processes, don't bother.  */
2795   if (!remote_multi_process_p (rs))
2796     return;
2797
2798   /* We only need to change the remote current thread if it's pointing
2799      at some other process.  */
2800   if (rs->general_thread.pid () != inferior_ptid.pid ())
2801     set_general_thread (inferior_ptid);
2802 }
2803
2804 \f
2805 /* Return nonzero if this is the main thread that we made up ourselves
2806    to model non-threaded targets as single-threaded.  */
2807
2808 static int
2809 remote_thread_always_alive (ptid_t ptid)
2810 {
2811   if (ptid == magic_null_ptid)
2812     /* The main thread is always alive.  */
2813     return 1;
2814
2815   if (ptid.pid () != 0 && ptid.lwp () == 0)
2816     /* The main thread is always alive.  This can happen after a
2817        vAttach, if the remote side doesn't support
2818        multi-threading.  */
2819     return 1;
2820
2821   return 0;
2822 }
2823
2824 /* Return nonzero if the thread PTID is still alive on the remote
2825    system.  */
2826
2827 bool
2828 remote_target::thread_alive (ptid_t ptid)
2829 {
2830   struct remote_state *rs = get_remote_state ();
2831   char *p, *endp;
2832
2833   /* Check if this is a thread that we made up ourselves to model
2834      non-threaded targets as single-threaded.  */
2835   if (remote_thread_always_alive (ptid))
2836     return 1;
2837
2838   p = rs->buf.data ();
2839   endp = p + get_remote_packet_size ();
2840
2841   *p++ = 'T';
2842   write_ptid (p, endp, ptid);
2843
2844   putpkt (rs->buf);
2845   getpkt (&rs->buf, 0);
2846   return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
2847 }
2848
2849 /* Return a pointer to a thread name if we know it and NULL otherwise.
2850    The thread_info object owns the memory for the name.  */
2851
2852 const char *
2853 remote_target::thread_name (struct thread_info *info)
2854 {
2855   if (info->priv != NULL)
2856     {
2857       const std::string &name = get_remote_thread_info (info)->name;
2858       return !name.empty () ? name.c_str () : NULL;
2859     }
2860
2861   return NULL;
2862 }
2863
2864 /* About these extended threadlist and threadinfo packets.  They are
2865    variable length packets but, the fields within them are often fixed
2866    length.  They are redundent enough to send over UDP as is the
2867    remote protocol in general.  There is a matching unit test module
2868    in libstub.  */
2869
2870 /* WARNING: This threadref data structure comes from the remote O.S.,
2871    libstub protocol encoding, and remote.c.  It is not particularly
2872    changable.  */
2873
2874 /* Right now, the internal structure is int. We want it to be bigger.
2875    Plan to fix this.  */
2876
2877 typedef int gdb_threadref;      /* Internal GDB thread reference.  */
2878
2879 /* gdb_ext_thread_info is an internal GDB data structure which is
2880    equivalent to the reply of the remote threadinfo packet.  */
2881
2882 struct gdb_ext_thread_info
2883   {
2884     threadref threadid;         /* External form of thread reference.  */
2885     int active;                 /* Has state interesting to GDB?
2886                                    regs, stack.  */
2887     char display[256];          /* Brief state display, name,
2888                                    blocked/suspended.  */
2889     char shortname[32];         /* To be used to name threads.  */
2890     char more_display[256];     /* Long info, statistics, queue depth,
2891                                    whatever.  */
2892   };
2893
2894 /* The volume of remote transfers can be limited by submitting
2895    a mask containing bits specifying the desired information.
2896    Use a union of these values as the 'selection' parameter to
2897    get_thread_info.  FIXME: Make these TAG names more thread specific.  */
2898
2899 #define TAG_THREADID 1
2900 #define TAG_EXISTS 2
2901 #define TAG_DISPLAY 4
2902 #define TAG_THREADNAME 8
2903 #define TAG_MOREDISPLAY 16
2904
2905 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2906
2907 static char *unpack_nibble (char *buf, int *val);
2908
2909 static char *unpack_byte (char *buf, int *value);
2910
2911 static char *pack_int (char *buf, int value);
2912
2913 static char *unpack_int (char *buf, int *value);
2914
2915 static char *unpack_string (char *src, char *dest, int length);
2916
2917 static char *pack_threadid (char *pkt, threadref *id);
2918
2919 static char *unpack_threadid (char *inbuf, threadref *id);
2920
2921 void int_to_threadref (threadref *id, int value);
2922
2923 static int threadref_to_int (threadref *ref);
2924
2925 static void copy_threadref (threadref *dest, threadref *src);
2926
2927 static int threadmatch (threadref *dest, threadref *src);
2928
2929 static char *pack_threadinfo_request (char *pkt, int mode,
2930                                       threadref *id);
2931
2932 static char *pack_threadlist_request (char *pkt, int startflag,
2933                                       int threadcount,
2934                                       threadref *nextthread);
2935
2936 static int remote_newthread_step (threadref *ref, void *context);
2937
2938
2939 /* Write a PTID to BUF.  ENDBUF points to one-passed-the-end of the
2940    buffer we're allowed to write to.  Returns
2941    BUF+CHARACTERS_WRITTEN.  */
2942
2943 char *
2944 remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid)
2945 {
2946   int pid, tid;
2947   struct remote_state *rs = get_remote_state ();
2948
2949   if (remote_multi_process_p (rs))
2950     {
2951       pid = ptid.pid ();
2952       if (pid < 0)
2953         buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2954       else
2955         buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2956     }
2957   tid = ptid.lwp ();
2958   if (tid < 0)
2959     buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2960   else
2961     buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2962
2963   return buf;
2964 }
2965
2966 /* Extract a PTID from BUF.  If non-null, OBUF is set to one past the
2967    last parsed char.  Returns null_ptid if no thread id is found, and
2968    throws an error if the thread id has an invalid format.  */
2969
2970 static ptid_t
2971 read_ptid (const char *buf, const char **obuf)
2972 {
2973   const char *p = buf;
2974   const char *pp;
2975   ULONGEST pid = 0, tid = 0;
2976
2977   if (*p == 'p')
2978     {
2979       /* Multi-process ptid.  */
2980       pp = unpack_varlen_hex (p + 1, &pid);
2981       if (*pp != '.')
2982         error (_("invalid remote ptid: %s"), p);
2983
2984       p = pp;
2985       pp = unpack_varlen_hex (p + 1, &tid);
2986       if (obuf)
2987         *obuf = pp;
2988       return ptid_t (pid, tid, 0);
2989     }
2990
2991   /* No multi-process.  Just a tid.  */
2992   pp = unpack_varlen_hex (p, &tid);
2993
2994   /* Return null_ptid when no thread id is found.  */
2995   if (p == pp)
2996     {
2997       if (obuf)
2998         *obuf = pp;
2999       return null_ptid;
3000     }
3001
3002   /* Since the stub is not sending a process id, then default to
3003      what's in inferior_ptid, unless it's null at this point.  If so,
3004      then since there's no way to know the pid of the reported
3005      threads, use the magic number.  */
3006   if (inferior_ptid == null_ptid)
3007     pid = magic_null_ptid.pid ();
3008   else
3009     pid = inferior_ptid.pid ();
3010
3011   if (obuf)
3012     *obuf = pp;
3013   return ptid_t (pid, tid, 0);
3014 }
3015
3016 static int
3017 stubhex (int ch)
3018 {
3019   if (ch >= 'a' && ch <= 'f')
3020     return ch - 'a' + 10;
3021   if (ch >= '0' && ch <= '9')
3022     return ch - '0';
3023   if (ch >= 'A' && ch <= 'F')
3024     return ch - 'A' + 10;
3025   return -1;
3026 }
3027
3028 static int
3029 stub_unpack_int (char *buff, int fieldlength)
3030 {
3031   int nibble;
3032   int retval = 0;
3033
3034   while (fieldlength)
3035     {
3036       nibble = stubhex (*buff++);
3037       retval |= nibble;
3038       fieldlength--;
3039       if (fieldlength)
3040         retval = retval << 4;
3041     }
3042   return retval;
3043 }
3044
3045 static char *
3046 unpack_nibble (char *buf, int *val)
3047 {
3048   *val = fromhex (*buf++);
3049   return buf;
3050 }
3051
3052 static char *
3053 unpack_byte (char *buf, int *value)
3054 {
3055   *value = stub_unpack_int (buf, 2);
3056   return buf + 2;
3057 }
3058
3059 static char *
3060 pack_int (char *buf, int value)
3061 {
3062   buf = pack_hex_byte (buf, (value >> 24) & 0xff);
3063   buf = pack_hex_byte (buf, (value >> 16) & 0xff);
3064   buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
3065   buf = pack_hex_byte (buf, (value & 0xff));
3066   return buf;
3067 }
3068
3069 static char *
3070 unpack_int (char *buf, int *value)
3071 {
3072   *value = stub_unpack_int (buf, 8);
3073   return buf + 8;
3074 }
3075
3076 #if 0                   /* Currently unused, uncomment when needed.  */
3077 static char *pack_string (char *pkt, char *string);
3078
3079 static char *
3080 pack_string (char *pkt, char *string)
3081 {
3082   char ch;
3083   int len;
3084
3085   len = strlen (string);
3086   if (len > 200)
3087     len = 200;          /* Bigger than most GDB packets, junk???  */
3088   pkt = pack_hex_byte (pkt, len);
3089   while (len-- > 0)
3090     {
3091       ch = *string++;
3092       if ((ch == '\0') || (ch == '#'))
3093         ch = '*';               /* Protect encapsulation.  */
3094       *pkt++ = ch;
3095     }
3096   return pkt;
3097 }
3098 #endif /* 0 (unused) */
3099
3100 static char *
3101 unpack_string (char *src, char *dest, int length)
3102 {
3103   while (length--)
3104     *dest++ = *src++;
3105   *dest = '\0';
3106   return src;
3107 }
3108
3109 static char *
3110 pack_threadid (char *pkt, threadref *id)
3111 {
3112   char *limit;
3113   unsigned char *altid;
3114
3115   altid = (unsigned char *) id;
3116   limit = pkt + BUF_THREAD_ID_SIZE;
3117   while (pkt < limit)
3118     pkt = pack_hex_byte (pkt, *altid++);
3119   return pkt;
3120 }
3121
3122
3123 static char *
3124 unpack_threadid (char *inbuf, threadref *id)
3125 {
3126   char *altref;
3127   char *limit = inbuf + BUF_THREAD_ID_SIZE;
3128   int x, y;
3129
3130   altref = (char *) id;
3131
3132   while (inbuf < limit)
3133     {
3134       x = stubhex (*inbuf++);
3135       y = stubhex (*inbuf++);
3136       *altref++ = (x << 4) | y;
3137     }
3138   return inbuf;
3139 }
3140
3141 /* Externally, threadrefs are 64 bits but internally, they are still
3142    ints.  This is due to a mismatch of specifications.  We would like
3143    to use 64bit thread references internally.  This is an adapter
3144    function.  */
3145
3146 void
3147 int_to_threadref (threadref *id, int value)
3148 {
3149   unsigned char *scan;
3150
3151   scan = (unsigned char *) id;
3152   {
3153     int i = 4;
3154     while (i--)
3155       *scan++ = 0;
3156   }
3157   *scan++ = (value >> 24) & 0xff;
3158   *scan++ = (value >> 16) & 0xff;
3159   *scan++ = (value >> 8) & 0xff;
3160   *scan++ = (value & 0xff);
3161 }
3162
3163 static int
3164 threadref_to_int (threadref *ref)
3165 {
3166   int i, value = 0;
3167   unsigned char *scan;
3168
3169   scan = *ref;
3170   scan += 4;
3171   i = 4;
3172   while (i-- > 0)
3173     value = (value << 8) | ((*scan++) & 0xff);
3174   return value;
3175 }
3176
3177 static void
3178 copy_threadref (threadref *dest, threadref *src)
3179 {
3180   int i;
3181   unsigned char *csrc, *cdest;
3182
3183   csrc = (unsigned char *) src;
3184   cdest = (unsigned char *) dest;
3185   i = 8;
3186   while (i--)
3187     *cdest++ = *csrc++;
3188 }
3189
3190 static int
3191 threadmatch (threadref *dest, threadref *src)
3192 {
3193   /* Things are broken right now, so just assume we got a match.  */
3194 #if 0
3195   unsigned char *srcp, *destp;
3196   int i, result;
3197   srcp = (char *) src;
3198   destp = (char *) dest;
3199
3200   result = 1;
3201   while (i-- > 0)
3202     result &= (*srcp++ == *destp++) ? 1 : 0;
3203   return result;
3204 #endif
3205   return 1;
3206 }
3207
3208 /*
3209    threadid:1,        # always request threadid
3210    context_exists:2,
3211    display:4,
3212    unique_name:8,
3213    more_display:16
3214  */
3215
3216 /* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
3217
3218 static char *
3219 pack_threadinfo_request (char *pkt, int mode, threadref *id)
3220 {
3221   *pkt++ = 'q';                         /* Info Query */
3222   *pkt++ = 'P';                         /* process or thread info */
3223   pkt = pack_int (pkt, mode);           /* mode */
3224   pkt = pack_threadid (pkt, id);        /* threadid */
3225   *pkt = '\0';                          /* terminate */
3226   return pkt;
3227 }
3228
3229 /* These values tag the fields in a thread info response packet.  */
3230 /* Tagging the fields allows us to request specific fields and to
3231    add more fields as time goes by.  */
3232
3233 #define TAG_THREADID 1          /* Echo the thread identifier.  */
3234 #define TAG_EXISTS 2            /* Is this process defined enough to
3235                                    fetch registers and its stack?  */
3236 #define TAG_DISPLAY 4           /* A short thing maybe to put on a window */
3237 #define TAG_THREADNAME 8        /* string, maps 1-to-1 with a thread is.  */
3238 #define TAG_MOREDISPLAY 16      /* Whatever the kernel wants to say about
3239                                    the process.  */
3240
3241 int
3242 remote_target::remote_unpack_thread_info_response (char *pkt,
3243                                                    threadref *expectedref,
3244                                                    gdb_ext_thread_info *info)
3245 {
3246   struct remote_state *rs = get_remote_state ();
3247   int mask, length;
3248   int tag;
3249   threadref ref;
3250   char *limit = pkt + rs->buf.size (); /* Plausible parsing limit.  */
3251   int retval = 1;
3252
3253   /* info->threadid = 0; FIXME: implement zero_threadref.  */
3254   info->active = 0;
3255   info->display[0] = '\0';
3256   info->shortname[0] = '\0';
3257   info->more_display[0] = '\0';
3258
3259   /* Assume the characters indicating the packet type have been
3260      stripped.  */
3261   pkt = unpack_int (pkt, &mask);        /* arg mask */
3262   pkt = unpack_threadid (pkt, &ref);
3263
3264   if (mask == 0)
3265     warning (_("Incomplete response to threadinfo request."));
3266   if (!threadmatch (&ref, expectedref))
3267     {                   /* This is an answer to a different request.  */
3268       warning (_("ERROR RMT Thread info mismatch."));
3269       return 0;
3270     }
3271   copy_threadref (&info->threadid, &ref);
3272
3273   /* Loop on tagged fields , try to bail if somthing goes wrong.  */
3274
3275   /* Packets are terminated with nulls.  */
3276   while ((pkt < limit) && mask && *pkt)
3277     {
3278       pkt = unpack_int (pkt, &tag);     /* tag */
3279       pkt = unpack_byte (pkt, &length); /* length */
3280       if (!(tag & mask))                /* Tags out of synch with mask.  */
3281         {
3282           warning (_("ERROR RMT: threadinfo tag mismatch."));
3283           retval = 0;
3284           break;
3285         }
3286       if (tag == TAG_THREADID)
3287         {
3288           if (length != 16)
3289             {
3290               warning (_("ERROR RMT: length of threadid is not 16."));
3291               retval = 0;
3292               break;
3293             }
3294           pkt = unpack_threadid (pkt, &ref);
3295           mask = mask & ~TAG_THREADID;
3296           continue;
3297         }
3298       if (tag == TAG_EXISTS)
3299         {
3300           info->active = stub_unpack_int (pkt, length);
3301           pkt += length;
3302           mask = mask & ~(TAG_EXISTS);
3303           if (length > 8)
3304             {
3305               warning (_("ERROR RMT: 'exists' length too long."));
3306               retval = 0;
3307               break;
3308             }
3309           continue;
3310         }
3311       if (tag == TAG_THREADNAME)
3312         {
3313           pkt = unpack_string (pkt, &info->shortname[0], length);
3314           mask = mask & ~TAG_THREADNAME;
3315           continue;
3316         }
3317       if (tag == TAG_DISPLAY)
3318         {
3319           pkt = unpack_string (pkt, &info->display[0], length);
3320           mask = mask & ~TAG_DISPLAY;
3321           continue;
3322         }
3323       if (tag == TAG_MOREDISPLAY)
3324         {
3325           pkt = unpack_string (pkt, &info->more_display[0], length);
3326           mask = mask & ~TAG_MOREDISPLAY;
3327           continue;
3328         }
3329       warning (_("ERROR RMT: unknown thread info tag."));
3330       break;                    /* Not a tag we know about.  */
3331     }
3332   return retval;
3333 }
3334
3335 int
3336 remote_target::remote_get_threadinfo (threadref *threadid,
3337                                       int fieldset,
3338                                       gdb_ext_thread_info *info)
3339 {
3340   struct remote_state *rs = get_remote_state ();
3341   int result;
3342
3343   pack_threadinfo_request (rs->buf.data (), fieldset, threadid);
3344   putpkt (rs->buf);
3345   getpkt (&rs->buf, 0);
3346
3347   if (rs->buf[0] == '\0')
3348     return 0;
3349
3350   result = remote_unpack_thread_info_response (&rs->buf[2],
3351                                                threadid, info);
3352   return result;
3353 }
3354
3355 /*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
3356
3357 static char *
3358 pack_threadlist_request (char *pkt, int startflag, int threadcount,
3359                          threadref *nextthread)
3360 {
3361   *pkt++ = 'q';                 /* info query packet */
3362   *pkt++ = 'L';                 /* Process LIST or threadLIST request */
3363   pkt = pack_nibble (pkt, startflag);           /* initflag 1 bytes */
3364   pkt = pack_hex_byte (pkt, threadcount);       /* threadcount 2 bytes */
3365   pkt = pack_threadid (pkt, nextthread);        /* 64 bit thread identifier */
3366   *pkt = '\0';
3367   return pkt;
3368 }
3369
3370 /* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3371
3372 int
3373 remote_target::parse_threadlist_response (char *pkt, int result_limit,
3374                                           threadref *original_echo,
3375                                           threadref *resultlist,
3376                                           int *doneflag)
3377 {
3378   struct remote_state *rs = get_remote_state ();
3379   char *limit;
3380   int count, resultcount, done;
3381
3382   resultcount = 0;
3383   /* Assume the 'q' and 'M chars have been stripped.  */
3384   limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
3385   /* done parse past here */
3386   pkt = unpack_byte (pkt, &count);      /* count field */
3387   pkt = unpack_nibble (pkt, &done);
3388   /* The first threadid is the argument threadid.  */
3389   pkt = unpack_threadid (pkt, original_echo);   /* should match query packet */
3390   while ((count-- > 0) && (pkt < limit))
3391     {
3392       pkt = unpack_threadid (pkt, resultlist++);
3393       if (resultcount++ >= result_limit)
3394         break;
3395     }
3396   if (doneflag)
3397     *doneflag = done;
3398   return resultcount;
3399 }
3400
3401 /* Fetch the next batch of threads from the remote.  Returns -1 if the
3402    qL packet is not supported, 0 on error and 1 on success.  */
3403
3404 int
3405 remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
3406                                       int result_limit, int *done, int *result_count,
3407                                       threadref *threadlist)
3408 {
3409   struct remote_state *rs = get_remote_state ();
3410   int result = 1;
3411
3412   /* Trancate result limit to be smaller than the packet size.  */
3413   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
3414       >= get_remote_packet_size ())
3415     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
3416
3417   pack_threadlist_request (rs->buf.data (), startflag, result_limit,
3418                            nextthread);
3419   putpkt (rs->buf);
3420   getpkt (&rs->buf, 0);
3421   if (rs->buf[0] == '\0')
3422     {
3423       /* Packet not supported.  */
3424       return -1;
3425     }
3426
3427   *result_count =
3428     parse_threadlist_response (&rs->buf[2], result_limit,
3429                                &rs->echo_nextthread, threadlist, done);
3430
3431   if (!threadmatch (&rs->echo_nextthread, nextthread))
3432     {
3433       /* FIXME: This is a good reason to drop the packet.  */
3434       /* Possably, there is a duplicate response.  */
3435       /* Possabilities :
3436          retransmit immediatly - race conditions
3437          retransmit after timeout - yes
3438          exit
3439          wait for packet, then exit
3440        */
3441       warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3442       return 0;                 /* I choose simply exiting.  */
3443     }
3444   if (*result_count <= 0)
3445     {
3446       if (*done != 1)
3447         {
3448           warning (_("RMT ERROR : failed to get remote thread list."));
3449           result = 0;
3450         }
3451       return result;            /* break; */
3452     }
3453   if (*result_count > result_limit)
3454     {
3455       *result_count = 0;
3456       warning (_("RMT ERROR: threadlist response longer than requested."));
3457       return 0;
3458     }
3459   return result;
3460 }
3461
3462 /* Fetch the list of remote threads, with the qL packet, and call
3463    STEPFUNCTION for each thread found.  Stops iterating and returns 1
3464    if STEPFUNCTION returns true.  Stops iterating and returns 0 if the
3465    STEPFUNCTION returns false.  If the packet is not supported,
3466    returns -1.  */
3467
3468 int
3469 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction,
3470                                            void *context, int looplimit)
3471 {
3472   struct remote_state *rs = get_remote_state ();
3473   int done, i, result_count;
3474   int startflag = 1;
3475   int result = 1;
3476   int loopcount = 0;
3477
3478   done = 0;
3479   while (!done)
3480     {
3481       if (loopcount++ > looplimit)
3482         {
3483           result = 0;
3484           warning (_("Remote fetch threadlist -infinite loop-."));
3485           break;
3486         }
3487       result = remote_get_threadlist (startflag, &rs->nextthread,
3488                                       MAXTHREADLISTRESULTS,
3489                                       &done, &result_count,
3490                                       rs->resultthreadlist);
3491       if (result <= 0)
3492         break;
3493       /* Clear for later iterations.  */
3494       startflag = 0;
3495       /* Setup to resume next batch of thread references, set nextthread.  */
3496       if (result_count >= 1)
3497         copy_threadref (&rs->nextthread,
3498                         &rs->resultthreadlist[result_count - 1]);
3499       i = 0;
3500       while (result_count--)
3501         {
3502           if (!(*stepfunction) (&rs->resultthreadlist[i++], context))
3503             {
3504               result = 0;
3505               break;
3506             }
3507         }
3508     }
3509   return result;
3510 }
3511
3512 /* A thread found on the remote target.  */
3513
3514 struct thread_item
3515 {
3516   explicit thread_item (ptid_t ptid_)
3517   : ptid (ptid_)
3518   {}
3519
3520   thread_item (thread_item &&other) = default;
3521   thread_item &operator= (thread_item &&other) = default;
3522
3523   DISABLE_COPY_AND_ASSIGN (thread_item);
3524
3525   /* The thread's PTID.  */
3526   ptid_t ptid;
3527
3528   /* The thread's extra info.  */
3529   std::string extra;
3530
3531   /* The thread's name.  */
3532   std::string name;
3533
3534   /* The core the thread was running on.  -1 if not known.  */
3535   int core = -1;
3536
3537   /* The thread handle associated with the thread.  */
3538   gdb::byte_vector thread_handle;
3539 };
3540
3541 /* Context passed around to the various methods listing remote
3542    threads.  As new threads are found, they're added to the ITEMS
3543    vector.  */
3544
3545 struct threads_listing_context
3546 {
3547   /* Return true if this object contains an entry for a thread with ptid
3548      PTID.  */
3549
3550   bool contains_thread (ptid_t ptid) const
3551   {
3552     auto match_ptid = [&] (const thread_item &item)
3553       {
3554         return item.ptid == ptid;
3555       };
3556
3557     auto it = std::find_if (this->items.begin (),
3558                             this->items.end (),
3559                             match_ptid);
3560
3561     return it != this->items.end ();
3562   }
3563
3564   /* Remove the thread with ptid PTID.  */
3565
3566   void remove_thread (ptid_t ptid)
3567   {
3568     auto match_ptid = [&] (const thread_item &item)
3569       {
3570         return item.ptid == ptid;
3571       };
3572
3573     auto it = std::remove_if (this->items.begin (),
3574                               this->items.end (),
3575                               match_ptid);
3576
3577     if (it != this->items.end ())
3578       this->items.erase (it);
3579   }
3580
3581   /* The threads found on the remote target.  */
3582   std::vector<thread_item> items;
3583 };
3584
3585 static int
3586 remote_newthread_step (threadref *ref, void *data)
3587 {
3588   struct threads_listing_context *context
3589     = (struct threads_listing_context *) data;
3590   int pid = inferior_ptid.pid ();
3591   int lwp = threadref_to_int (ref);
3592   ptid_t ptid (pid, lwp);
3593
3594   context->items.emplace_back (ptid);
3595
3596   return 1;                     /* continue iterator */
3597 }
3598
3599 #define CRAZY_MAX_THREADS 1000
3600
3601 ptid_t
3602 remote_target::remote_current_thread (ptid_t oldpid)
3603 {
3604   struct remote_state *rs = get_remote_state ();
3605
3606   putpkt ("qC");
3607   getpkt (&rs->buf, 0);
3608   if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
3609     {
3610       const char *obuf;
3611       ptid_t result;
3612
3613       result = read_ptid (&rs->buf[2], &obuf);
3614       if (*obuf != '\0' && remote_debug)
3615         fprintf_unfiltered (gdb_stdlog,
3616                             "warning: garbage in qC reply\n");
3617
3618       return result;
3619     }
3620   else
3621     return oldpid;
3622 }
3623
3624 /* List remote threads using the deprecated qL packet.  */
3625
3626 int
3627 remote_target::remote_get_threads_with_ql (threads_listing_context *context)
3628 {
3629   if (remote_threadlist_iterator (remote_newthread_step, context,
3630                                   CRAZY_MAX_THREADS) >= 0)
3631     return 1;
3632
3633   return 0;
3634 }
3635
3636 #if defined(HAVE_LIBEXPAT)
3637
3638 static void
3639 start_thread (struct gdb_xml_parser *parser,
3640               const struct gdb_xml_element *element,
3641               void *user_data,
3642               std::vector<gdb_xml_value> &attributes)
3643 {
3644   struct threads_listing_context *data
3645     = (struct threads_listing_context *) user_data;
3646   struct gdb_xml_value *attr;
3647
3648   char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
3649   ptid_t ptid = read_ptid (id, NULL);
3650
3651   data->items.emplace_back (ptid);
3652   thread_item &item = data->items.back ();
3653
3654   attr = xml_find_attribute (attributes, "core");
3655   if (attr != NULL)
3656     item.core = *(ULONGEST *) attr->value.get ();
3657
3658   attr = xml_find_attribute (attributes, "name");
3659   if (attr != NULL)
3660     item.name = (const char *) attr->value.get ();
3661
3662   attr = xml_find_attribute (attributes, "handle");
3663   if (attr != NULL)
3664     item.thread_handle = hex2bin ((const char *) attr->value.get ());
3665 }
3666
3667 static void
3668 end_thread (struct gdb_xml_parser *parser,
3669             const struct gdb_xml_element *element,
3670             void *user_data, const char *body_text)
3671 {
3672   struct threads_listing_context *data
3673     = (struct threads_listing_context *) user_data;
3674
3675   if (body_text != NULL && *body_text != '\0')
3676     data->items.back ().extra = body_text;
3677 }
3678
3679 const struct gdb_xml_attribute thread_attributes[] = {
3680   { "id", GDB_XML_AF_NONE, NULL, NULL },
3681   { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
3682   { "name", GDB_XML_AF_OPTIONAL, NULL, NULL },
3683   { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL },
3684   { NULL, GDB_XML_AF_NONE, NULL, NULL }
3685 };
3686
3687 const struct gdb_xml_element thread_children[] = {
3688   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3689 };
3690
3691 const struct gdb_xml_element threads_children[] = {
3692   { "thread", thread_attributes, thread_children,
3693     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3694     start_thread, end_thread },
3695   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3696 };
3697
3698 const struct gdb_xml_element threads_elements[] = {
3699   { "threads", NULL, threads_children,
3700     GDB_XML_EF_NONE, NULL, NULL },
3701   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3702 };
3703
3704 #endif
3705
3706 /* List remote threads using qXfer:threads:read.  */
3707
3708 int
3709 remote_target::remote_get_threads_with_qxfer (threads_listing_context *context)
3710 {
3711 #if defined(HAVE_LIBEXPAT)
3712   if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3713     {
3714       gdb::optional<gdb::char_vector> xml
3715         = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL);
3716
3717       if (xml && (*xml)[0] != '\0')
3718         {
3719           gdb_xml_parse_quick (_("threads"), "threads.dtd",
3720                                threads_elements, xml->data (), context);
3721         }
3722
3723       return 1;
3724     }
3725 #endif
3726
3727   return 0;
3728 }
3729
3730 /* List remote threads using qfThreadInfo/qsThreadInfo.  */
3731
3732 int
3733 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context)
3734 {
3735   struct remote_state *rs = get_remote_state ();
3736
3737   if (rs->use_threadinfo_query)
3738     {
3739       const char *bufp;
3740
3741       putpkt ("qfThreadInfo");
3742       getpkt (&rs->buf, 0);
3743       bufp = rs->buf.data ();
3744       if (bufp[0] != '\0')              /* q packet recognized */
3745         {
3746           while (*bufp++ == 'm')        /* reply contains one or more TID */
3747             {
3748               do
3749                 {
3750                   ptid_t ptid = read_ptid (bufp, &bufp);
3751                   context->items.emplace_back (ptid);
3752                 }
3753               while (*bufp++ == ',');   /* comma-separated list */
3754               putpkt ("qsThreadInfo");
3755               getpkt (&rs->buf, 0);
3756               bufp = rs->buf.data ();
3757             }
3758           return 1;
3759         }
3760       else
3761         {
3762           /* Packet not recognized.  */
3763           rs->use_threadinfo_query = 0;
3764         }
3765     }
3766
3767   return 0;
3768 }
3769
3770 /* Implement the to_update_thread_list function for the remote
3771    targets.  */
3772
3773 void
3774 remote_target::update_thread_list ()
3775 {
3776   struct threads_listing_context context;
3777   int got_list = 0;
3778
3779   /* We have a few different mechanisms to fetch the thread list.  Try
3780      them all, starting with the most preferred one first, falling
3781      back to older methods.  */
3782   if (remote_get_threads_with_qxfer (&context)
3783       || remote_get_threads_with_qthreadinfo (&context)
3784       || remote_get_threads_with_ql (&context))
3785     {
3786       got_list = 1;
3787
3788       if (context.items.empty ()
3789           && remote_thread_always_alive (inferior_ptid))
3790         {
3791           /* Some targets don't really support threads, but still
3792              reply an (empty) thread list in response to the thread
3793              listing packets, instead of replying "packet not
3794              supported".  Exit early so we don't delete the main
3795              thread.  */
3796           return;
3797         }
3798
3799       /* CONTEXT now holds the current thread list on the remote
3800          target end.  Delete GDB-side threads no longer found on the
3801          target.  */
3802       for (thread_info *tp : all_threads_safe ())
3803         {
3804           if (!context.contains_thread (tp->ptid))
3805             {
3806               /* Not found.  */
3807               delete_thread (tp);
3808             }
3809         }
3810
3811       /* Remove any unreported fork child threads from CONTEXT so
3812          that we don't interfere with follow fork, which is where
3813          creation of such threads is handled.  */
3814       remove_new_fork_children (&context);
3815
3816       /* And now add threads we don't know about yet to our list.  */
3817       for (thread_item &item : context.items)
3818         {
3819           if (item.ptid != null_ptid)
3820             {
3821               /* In non-stop mode, we assume new found threads are
3822                  executing until proven otherwise with a stop reply.
3823                  In all-stop, we can only get here if all threads are
3824                  stopped.  */
3825               int executing = target_is_non_stop_p () ? 1 : 0;
3826
3827               remote_notice_new_inferior (item.ptid, executing);
3828
3829               thread_info *tp = find_thread_ptid (item.ptid);
3830               remote_thread_info *info = get_remote_thread_info (tp);
3831               info->core = item.core;
3832               info->extra = std::move (item.extra);
3833               info->name = std::move (item.name);
3834               info->thread_handle = std::move (item.thread_handle);
3835             }
3836         }
3837     }
3838
3839   if (!got_list)
3840     {
3841       /* If no thread listing method is supported, then query whether
3842          each known thread is alive, one by one, with the T packet.
3843          If the target doesn't support threads at all, then this is a
3844          no-op.  See remote_thread_alive.  */
3845       prune_threads ();
3846     }
3847 }
3848
3849 /*
3850  * Collect a descriptive string about the given thread.
3851  * The target may say anything it wants to about the thread
3852  * (typically info about its blocked / runnable state, name, etc.).
3853  * This string will appear in the info threads display.
3854  *
3855  * Optional: targets are not required to implement this function.
3856  */
3857
3858 const char *
3859 remote_target::extra_thread_info (thread_info *tp)
3860 {
3861   struct remote_state *rs = get_remote_state ();
3862   int set;
3863   threadref id;
3864   struct gdb_ext_thread_info threadinfo;
3865
3866   if (rs->remote_desc == 0)             /* paranoia */
3867     internal_error (__FILE__, __LINE__,
3868                     _("remote_threads_extra_info"));
3869
3870   if (tp->ptid == magic_null_ptid
3871       || (tp->ptid.pid () != 0 && tp->ptid.lwp () == 0))
3872     /* This is the main thread which was added by GDB.  The remote
3873        server doesn't know about it.  */
3874     return NULL;
3875
3876   std::string &extra = get_remote_thread_info (tp)->extra;
3877
3878   /* If already have cached info, use it.  */
3879   if (!extra.empty ())
3880     return extra.c_str ();
3881
3882   if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3883     {
3884       /* If we're using qXfer:threads:read, then the extra info is
3885          included in the XML.  So if we didn't have anything cached,
3886          it's because there's really no extra info.  */
3887       return NULL;
3888     }
3889
3890   if (rs->use_threadextra_query)
3891     {
3892       char *b = rs->buf.data ();
3893       char *endb = b + get_remote_packet_size ();
3894
3895       xsnprintf (b, endb - b, "qThreadExtraInfo,");
3896       b += strlen (b);
3897       write_ptid (b, endb, tp->ptid);
3898
3899       putpkt (rs->buf);
3900       getpkt (&rs->buf, 0);
3901       if (rs->buf[0] != 0)
3902         {
3903           extra.resize (strlen (rs->buf.data ()) / 2);
3904           hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ());
3905           return extra.c_str ();
3906         }
3907     }
3908
3909   /* If the above query fails, fall back to the old method.  */
3910   rs->use_threadextra_query = 0;
3911   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3912     | TAG_MOREDISPLAY | TAG_DISPLAY;
3913   int_to_threadref (&id, tp->ptid.lwp ());
3914   if (remote_get_threadinfo (&id, set, &threadinfo))
3915     if (threadinfo.active)
3916       {
3917         if (*threadinfo.shortname)
3918           string_appendf (extra, " Name: %s", threadinfo.shortname);
3919         if (*threadinfo.display)
3920           {
3921             if (!extra.empty ())
3922               extra += ',';
3923             string_appendf (extra, " State: %s", threadinfo.display);
3924           }
3925         if (*threadinfo.more_display)
3926           {
3927             if (!extra.empty ())
3928               extra += ',';
3929             string_appendf (extra, " Priority: %s", threadinfo.more_display);
3930           }
3931         return extra.c_str ();
3932       }
3933   return NULL;
3934 }
3935 \f
3936
3937 bool
3938 remote_target::static_tracepoint_marker_at (CORE_ADDR addr,
3939                                             struct static_tracepoint_marker *marker)
3940 {
3941   struct remote_state *rs = get_remote_state ();
3942   char *p = rs->buf.data ();
3943
3944   xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
3945   p += strlen (p);
3946   p += hexnumstr (p, addr);
3947   putpkt (rs->buf);
3948   getpkt (&rs->buf, 0);
3949   p = rs->buf.data ();
3950
3951   if (*p == 'E')
3952     error (_("Remote failure reply: %s"), p);
3953
3954   if (*p++ == 'm')
3955     {
3956       parse_static_tracepoint_marker_definition (p, NULL, marker);
3957       return true;
3958     }
3959
3960   return false;
3961 }
3962
3963 std::vector<static_tracepoint_marker>
3964 remote_target::static_tracepoint_markers_by_strid (const char *strid)
3965 {
3966   struct remote_state *rs = get_remote_state ();
3967   std::vector<static_tracepoint_marker> markers;
3968   const char *p;
3969   static_tracepoint_marker marker;
3970
3971   /* Ask for a first packet of static tracepoint marker
3972      definition.  */
3973   putpkt ("qTfSTM");
3974   getpkt (&rs->buf, 0);
3975   p = rs->buf.data ();
3976   if (*p == 'E')
3977     error (_("Remote failure reply: %s"), p);
3978
3979   while (*p++ == 'm')
3980     {
3981       do
3982         {
3983           parse_static_tracepoint_marker_definition (p, &p, &marker);
3984
3985           if (strid == NULL || marker.str_id == strid)
3986             markers.push_back (std::move (marker));
3987         }
3988       while (*p++ == ',');      /* comma-separated list */
3989       /* Ask for another packet of static tracepoint definition.  */
3990       putpkt ("qTsSTM");
3991       getpkt (&rs->buf, 0);
3992       p = rs->buf.data ();
3993     }
3994
3995   return markers;
3996 }
3997
3998 \f
3999 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
4000
4001 ptid_t
4002 remote_target::get_ada_task_ptid (long lwp, long thread)
4003 {
4004   return ptid_t (inferior_ptid.pid (), lwp, 0);
4005 }
4006 \f
4007
4008 /* Restart the remote side; this is an extended protocol operation.  */
4009
4010 void
4011 remote_target::extended_remote_restart ()
4012 {
4013   struct remote_state *rs = get_remote_state ();
4014
4015   /* Send the restart command; for reasons I don't understand the
4016      remote side really expects a number after the "R".  */
4017   xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0);
4018   putpkt (rs->buf);
4019
4020   remote_fileio_reset ();
4021 }
4022 \f
4023 /* Clean up connection to a remote debugger.  */
4024
4025 void
4026 remote_target::close ()
4027 {
4028   /* Make sure we leave stdin registered in the event loop.  */
4029   terminal_ours ();
4030
4031   /* We don't have a connection to the remote stub anymore.  Get rid
4032      of all the inferiors and their threads we were controlling.
4033      Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4034      will be unable to find the thread corresponding to (pid, 0, 0).  */
4035   inferior_ptid = null_ptid;
4036   discard_all_inferiors ();
4037
4038   trace_reset_local_state ();
4039
4040   delete this;
4041 }
4042
4043 remote_target::~remote_target ()
4044 {
4045   struct remote_state *rs = get_remote_state ();
4046
4047   /* Check for NULL because we may get here with a partially
4048      constructed target/connection.  */
4049   if (rs->remote_desc == nullptr)
4050     return;
4051
4052   serial_close (rs->remote_desc);
4053
4054   /* We are destroying the remote target, so we should discard
4055      everything of this target.  */
4056   discard_pending_stop_replies_in_queue ();
4057
4058   if (rs->remote_async_inferior_event_token)
4059     delete_async_event_handler (&rs->remote_async_inferior_event_token);
4060
4061   remote_notif_state_xfree (rs->notif_state);
4062 }
4063
4064 /* Query the remote side for the text, data and bss offsets.  */
4065
4066 void
4067 remote_target::get_offsets ()
4068 {
4069   struct remote_state *rs = get_remote_state ();
4070   char *buf;
4071   char *ptr;
4072   int lose, num_segments = 0, do_sections, do_segments;
4073   CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
4074   struct section_offsets *offs;
4075   struct symfile_segment_data *data;
4076
4077   if (symfile_objfile == NULL)
4078     return;
4079
4080   putpkt ("qOffsets");
4081   getpkt (&rs->buf, 0);
4082   buf = rs->buf.data ();
4083
4084   if (buf[0] == '\000')
4085     return;                     /* Return silently.  Stub doesn't support
4086                                    this command.  */
4087   if (buf[0] == 'E')
4088     {
4089       warning (_("Remote failure reply: %s"), buf);
4090       return;
4091     }
4092
4093   /* Pick up each field in turn.  This used to be done with scanf, but
4094      scanf will make trouble if CORE_ADDR size doesn't match
4095      conversion directives correctly.  The following code will work
4096      with any size of CORE_ADDR.  */
4097   text_addr = data_addr = bss_addr = 0;
4098   ptr = buf;
4099   lose = 0;
4100
4101   if (startswith (ptr, "Text="))
4102     {
4103       ptr += 5;
4104       /* Don't use strtol, could lose on big values.  */
4105       while (*ptr && *ptr != ';')
4106         text_addr = (text_addr << 4) + fromhex (*ptr++);
4107
4108       if (startswith (ptr, ";Data="))
4109         {
4110           ptr += 6;
4111           while (*ptr && *ptr != ';')
4112             data_addr = (data_addr << 4) + fromhex (*ptr++);
4113         }
4114       else
4115         lose = 1;
4116
4117       if (!lose && startswith (ptr, ";Bss="))
4118         {
4119           ptr += 5;
4120           while (*ptr && *ptr != ';')
4121             bss_addr = (bss_addr << 4) + fromhex (*ptr++);
4122
4123           if (bss_addr != data_addr)
4124             warning (_("Target reported unsupported offsets: %s"), buf);
4125         }
4126       else
4127         lose = 1;
4128     }
4129   else if (startswith (ptr, "TextSeg="))
4130     {
4131       ptr += 8;
4132       /* Don't use strtol, could lose on big values.  */
4133       while (*ptr && *ptr != ';')
4134         text_addr = (text_addr << 4) + fromhex (*ptr++);
4135       num_segments = 1;
4136
4137       if (startswith (ptr, ";DataSeg="))
4138         {
4139           ptr += 9;
4140           while (*ptr && *ptr != ';')
4141             data_addr = (data_addr << 4) + fromhex (*ptr++);
4142           num_segments++;
4143         }
4144     }
4145   else
4146     lose = 1;
4147
4148   if (lose)
4149     error (_("Malformed response to offset query, %s"), buf);
4150   else if (*ptr != '\0')
4151     warning (_("Target reported unsupported offsets: %s"), buf);
4152
4153   offs = ((struct section_offsets *)
4154           alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
4155   memcpy (offs, symfile_objfile->section_offsets,
4156           SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
4157
4158   data = get_symfile_segment_data (symfile_objfile->obfd);
4159   do_segments = (data != NULL);
4160   do_sections = num_segments == 0;
4161
4162   if (num_segments > 0)
4163     {
4164       segments[0] = text_addr;
4165       segments[1] = data_addr;
4166     }
4167   /* If we have two segments, we can still try to relocate everything
4168      by assuming that the .text and .data offsets apply to the whole
4169      text and data segments.  Convert the offsets given in the packet
4170      to base addresses for symfile_map_offsets_to_segments.  */
4171   else if (data && data->num_segments == 2)
4172     {
4173       segments[0] = data->segment_bases[0] + text_addr;
4174       segments[1] = data->segment_bases[1] + data_addr;
4175       num_segments = 2;
4176     }
4177   /* If the object file has only one segment, assume that it is text
4178      rather than data; main programs with no writable data are rare,
4179      but programs with no code are useless.  Of course the code might
4180      have ended up in the data segment... to detect that we would need
4181      the permissions here.  */
4182   else if (data && data->num_segments == 1)
4183     {
4184       segments[0] = data->segment_bases[0] + text_addr;
4185       num_segments = 1;
4186     }
4187   /* There's no way to relocate by segment.  */
4188   else
4189     do_segments = 0;
4190
4191   if (do_segments)
4192     {
4193       int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
4194                                                  offs, num_segments, segments);
4195
4196       if (ret == 0 && !do_sections)
4197         error (_("Can not handle qOffsets TextSeg "
4198                  "response with this symbol file"));
4199
4200       if (ret > 0)
4201         do_sections = 0;
4202     }
4203
4204   if (data)
4205     free_symfile_segment_data (data);
4206
4207   if (do_sections)
4208     {
4209       offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
4210
4211       /* This is a temporary kludge to force data and bss to use the
4212          same offsets because that's what nlmconv does now.  The real
4213          solution requires changes to the stub and remote.c that I
4214          don't have time to do right now.  */
4215
4216       offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
4217       offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
4218     }
4219
4220   objfile_relocate (symfile_objfile, offs);
4221 }
4222
4223 /* Send interrupt_sequence to remote target.  */
4224
4225 void
4226 remote_target::send_interrupt_sequence ()
4227 {
4228   struct remote_state *rs = get_remote_state ();
4229
4230   if (interrupt_sequence_mode == interrupt_sequence_control_c)
4231     remote_serial_write ("\x03", 1);
4232   else if (interrupt_sequence_mode == interrupt_sequence_break)
4233     serial_send_break (rs->remote_desc);
4234   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
4235     {
4236       serial_send_break (rs->remote_desc);
4237       remote_serial_write ("g", 1);
4238     }
4239   else
4240     internal_error (__FILE__, __LINE__,
4241                     _("Invalid value for interrupt_sequence_mode: %s."),
4242                     interrupt_sequence_mode);
4243 }
4244
4245
4246 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4247    and extract the PTID.  Returns NULL_PTID if not found.  */
4248
4249 static ptid_t
4250 stop_reply_extract_thread (char *stop_reply)
4251 {
4252   if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
4253     {
4254       const char *p;
4255
4256       /* Txx r:val ; r:val (...)  */
4257       p = &stop_reply[3];
4258
4259       /* Look for "register" named "thread".  */
4260       while (*p != '\0')
4261         {
4262           const char *p1;
4263
4264           p1 = strchr (p, ':');
4265           if (p1 == NULL)
4266             return null_ptid;
4267
4268           if (strncmp (p, "thread", p1 - p) == 0)
4269             return read_ptid (++p1, &p);
4270
4271           p1 = strchr (p, ';');
4272           if (p1 == NULL)
4273             return null_ptid;
4274           p1++;
4275
4276           p = p1;
4277         }
4278     }
4279
4280   return null_ptid;
4281 }
4282
4283 /* Determine the remote side's current thread.  If we have a stop
4284    reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4285    "thread" register we can extract the current thread from.  If not,
4286    ask the remote which is the current thread with qC.  The former
4287    method avoids a roundtrip.  */
4288
4289 ptid_t
4290 remote_target::get_current_thread (char *wait_status)
4291 {
4292   ptid_t ptid = null_ptid;
4293
4294   /* Note we don't use remote_parse_stop_reply as that makes use of
4295      the target architecture, which we haven't yet fully determined at
4296      this point.  */
4297   if (wait_status != NULL)
4298     ptid = stop_reply_extract_thread (wait_status);
4299   if (ptid == null_ptid)
4300     ptid = remote_current_thread (inferior_ptid);
4301
4302   return ptid;
4303 }
4304
4305 /* Query the remote target for which is the current thread/process,
4306    add it to our tables, and update INFERIOR_PTID.  The caller is
4307    responsible for setting the state such that the remote end is ready
4308    to return the current thread.
4309
4310    This function is called after handling the '?' or 'vRun' packets,
4311    whose response is a stop reply from which we can also try
4312    extracting the thread.  If the target doesn't support the explicit
4313    qC query, we infer the current thread from that stop reply, passed
4314    in in WAIT_STATUS, which may be NULL.  */
4315
4316 void
4317 remote_target::add_current_inferior_and_thread (char *wait_status)
4318 {
4319   struct remote_state *rs = get_remote_state ();
4320   int fake_pid_p = 0;
4321
4322   inferior_ptid = null_ptid;
4323
4324   /* Now, if we have thread information, update inferior_ptid.  */
4325   ptid_t curr_ptid = get_current_thread (wait_status);
4326
4327   if (curr_ptid != null_ptid)
4328     {
4329       if (!remote_multi_process_p (rs))
4330         fake_pid_p = 1;
4331     }
4332   else
4333     {
4334       /* Without this, some commands which require an active target
4335          (such as kill) won't work.  This variable serves (at least)
4336          double duty as both the pid of the target process (if it has
4337          such), and as a flag indicating that a target is active.  */
4338       curr_ptid = magic_null_ptid;
4339       fake_pid_p = 1;
4340     }
4341
4342   remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1);
4343
4344   /* Add the main thread and switch to it.  Don't try reading
4345      registers yet, since we haven't fetched the target description
4346      yet.  */
4347   thread_info *tp = add_thread_silent (curr_ptid);
4348   switch_to_thread_no_regs (tp);
4349 }
4350
4351 /* Print info about a thread that was found already stopped on
4352    connection.  */
4353
4354 static void
4355 print_one_stopped_thread (struct thread_info *thread)
4356 {
4357   struct target_waitstatus *ws = &thread->suspend.waitstatus;
4358
4359   switch_to_thread (thread);
4360   thread->suspend.stop_pc = get_frame_pc (get_current_frame ());
4361   set_current_sal_from_frame (get_current_frame ());
4362
4363   thread->suspend.waitstatus_pending_p = 0;
4364
4365   if (ws->kind == TARGET_WAITKIND_STOPPED)
4366     {
4367       enum gdb_signal sig = ws->value.sig;
4368
4369       if (signal_print_state (sig))
4370         gdb::observers::signal_received.notify (sig);
4371     }
4372   gdb::observers::normal_stop.notify (NULL, 1);
4373 }
4374
4375 /* Process all initial stop replies the remote side sent in response
4376    to the ? packet.  These indicate threads that were already stopped
4377    on initial connection.  We mark these threads as stopped and print
4378    their current frame before giving the user the prompt.  */
4379
4380 void
4381 remote_target::process_initial_stop_replies (int from_tty)
4382 {
4383   int pending_stop_replies = stop_reply_queue_length ();
4384   struct thread_info *selected = NULL;
4385   struct thread_info *lowest_stopped = NULL;
4386   struct thread_info *first = NULL;
4387
4388   /* Consume the initial pending events.  */
4389   while (pending_stop_replies-- > 0)
4390     {
4391       ptid_t waiton_ptid = minus_one_ptid;
4392       ptid_t event_ptid;
4393       struct target_waitstatus ws;
4394       int ignore_event = 0;
4395
4396       memset (&ws, 0, sizeof (ws));
4397       event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
4398       if (remote_debug)
4399         print_target_wait_results (waiton_ptid, event_ptid, &ws);
4400
4401       switch (ws.kind)
4402         {
4403         case TARGET_WAITKIND_IGNORE:
4404         case TARGET_WAITKIND_NO_RESUMED:
4405         case TARGET_WAITKIND_SIGNALLED:
4406         case TARGET_WAITKIND_EXITED:
4407           /* We shouldn't see these, but if we do, just ignore.  */
4408           if (remote_debug)
4409             fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
4410           ignore_event = 1;
4411           break;
4412
4413         case TARGET_WAITKIND_EXECD:
4414           xfree (ws.value.execd_pathname);
4415           break;
4416         default:
4417           break;
4418         }
4419
4420       if (ignore_event)
4421         continue;
4422
4423       struct thread_info *evthread = find_thread_ptid (event_ptid);
4424
4425       if (ws.kind == TARGET_WAITKIND_STOPPED)
4426         {
4427           enum gdb_signal sig = ws.value.sig;
4428
4429           /* Stubs traditionally report SIGTRAP as initial signal,
4430              instead of signal 0.  Suppress it.  */
4431           if (sig == GDB_SIGNAL_TRAP)
4432             sig = GDB_SIGNAL_0;
4433           evthread->suspend.stop_signal = sig;
4434           ws.value.sig = sig;
4435         }
4436
4437       evthread->suspend.waitstatus = ws;
4438
4439       if (ws.kind != TARGET_WAITKIND_STOPPED
4440           || ws.value.sig != GDB_SIGNAL_0)
4441         evthread->suspend.waitstatus_pending_p = 1;
4442
4443       set_executing (event_ptid, 0);
4444       set_running (event_ptid, 0);
4445       get_remote_thread_info (evthread)->vcont_resumed = 0;
4446     }
4447
4448   /* "Notice" the new inferiors before anything related to
4449      registers/memory.  */
4450   for (inferior *inf : all_non_exited_inferiors ())
4451     {
4452       inf->needs_setup = 1;
4453
4454       if (non_stop)
4455         {
4456           thread_info *thread = any_live_thread_of_inferior (inf);
4457           notice_new_inferior (thread, thread->state == THREAD_RUNNING,
4458                                from_tty);
4459         }
4460     }
4461
4462   /* If all-stop on top of non-stop, pause all threads.  Note this
4463      records the threads' stop pc, so must be done after "noticing"
4464      the inferiors.  */
4465   if (!non_stop)
4466     {
4467       stop_all_threads ();
4468
4469       /* If all threads of an inferior were already stopped, we
4470          haven't setup the inferior yet.  */
4471       for (inferior *inf : all_non_exited_inferiors ())
4472         {
4473           if (inf->needs_setup)
4474             {
4475               thread_info *thread = any_live_thread_of_inferior (inf);
4476               switch_to_thread_no_regs (thread);
4477               setup_inferior (0);
4478             }
4479         }
4480     }
4481
4482   /* Now go over all threads that are stopped, and print their current
4483      frame.  If all-stop, then if there's a signalled thread, pick
4484      that as current.  */
4485   for (thread_info *thread : all_non_exited_threads ())
4486     {
4487       if (first == NULL)
4488         first = thread;
4489
4490       if (!non_stop)
4491         thread->set_running (false);
4492       else if (thread->state != THREAD_STOPPED)
4493         continue;
4494
4495       if (selected == NULL
4496           && thread->suspend.waitstatus_pending_p)
4497         selected = thread;
4498
4499       if (lowest_stopped == NULL
4500           || thread->inf->num < lowest_stopped->inf->num
4501           || thread->per_inf_num < lowest_stopped->per_inf_num)
4502         lowest_stopped = thread;
4503
4504       if (non_stop)
4505         print_one_stopped_thread (thread);
4506     }
4507
4508   /* In all-stop, we only print the status of one thread, and leave
4509      others with their status pending.  */
4510   if (!non_stop)
4511     {
4512       thread_info *thread = selected;
4513       if (thread == NULL)
4514         thread = lowest_stopped;
4515       if (thread == NULL)
4516         thread = first;
4517
4518       print_one_stopped_thread (thread);
4519     }
4520
4521   /* For "info program".  */
4522   thread_info *thread = inferior_thread ();
4523   if (thread->state == THREAD_STOPPED)
4524     set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
4525 }
4526
4527 /* Start the remote connection and sync state.  */
4528
4529 void
4530 remote_target::start_remote (int from_tty, int extended_p)
4531 {
4532   struct remote_state *rs = get_remote_state ();
4533   struct packet_config *noack_config;
4534   char *wait_status = NULL;
4535
4536   /* Signal other parts that we're going through the initial setup,
4537      and so things may not be stable yet.  E.g., we don't try to
4538      install tracepoints until we've relocated symbols.  Also, a
4539      Ctrl-C before we're connected and synced up can't interrupt the
4540      target.  Instead, it offers to drop the (potentially wedged)
4541      connection.  */
4542   rs->starting_up = 1;
4543
4544   QUIT;
4545
4546   if (interrupt_on_connect)
4547     send_interrupt_sequence ();
4548
4549   /* Ack any packet which the remote side has already sent.  */
4550   remote_serial_write ("+", 1);
4551
4552   /* The first packet we send to the target is the optional "supported
4553      packets" request.  If the target can answer this, it will tell us
4554      which later probes to skip.  */
4555   remote_query_supported ();
4556
4557   /* If the stub wants to get a QAllow, compose one and send it.  */
4558   if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
4559     set_permissions ();
4560
4561   /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4562      unknown 'v' packet with string "OK".  "OK" gets interpreted by GDB
4563      as a reply to known packet.  For packet "vFile:setfs:" it is an
4564      invalid reply and GDB would return error in
4565      remote_hostio_set_filesystem, making remote files access impossible.
4566      Disable "vFile:setfs:" in such case.  Do not disable other 'v' packets as
4567      other "vFile" packets get correctly detected even on gdbserver < 7.7.  */
4568   {
4569     const char v_mustreplyempty[] = "vMustReplyEmpty";
4570
4571     putpkt (v_mustreplyempty);
4572     getpkt (&rs->buf, 0);
4573     if (strcmp (rs->buf.data (), "OK") == 0)
4574       remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
4575     else if (strcmp (rs->buf.data (), "") != 0)
4576       error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
4577              rs->buf.data ());
4578   }
4579
4580   /* Next, we possibly activate noack mode.
4581
4582      If the QStartNoAckMode packet configuration is set to AUTO,
4583      enable noack mode if the stub reported a wish for it with
4584      qSupported.
4585
4586      If set to TRUE, then enable noack mode even if the stub didn't
4587      report it in qSupported.  If the stub doesn't reply OK, the
4588      session ends with an error.
4589
4590      If FALSE, then don't activate noack mode, regardless of what the
4591      stub claimed should be the default with qSupported.  */
4592
4593   noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
4594   if (packet_config_support (noack_config) != PACKET_DISABLE)
4595     {
4596       putpkt ("QStartNoAckMode");
4597       getpkt (&rs->buf, 0);
4598       if (packet_ok (rs->buf, noack_config) == PACKET_OK)
4599         rs->noack_mode = 1;
4600     }
4601
4602   if (extended_p)
4603     {
4604       /* Tell the remote that we are using the extended protocol.  */
4605       putpkt ("!");
4606       getpkt (&rs->buf, 0);
4607     }
4608
4609   /* Let the target know which signals it is allowed to pass down to
4610      the program.  */
4611   update_signals_program_target ();
4612
4613   /* Next, if the target can specify a description, read it.  We do
4614      this before anything involving memory or registers.  */
4615   target_find_description ();
4616
4617   /* Next, now that we know something about the target, update the
4618      address spaces in the program spaces.  */
4619   update_address_spaces ();
4620
4621   /* On OSs where the list of libraries is global to all
4622      processes, we fetch them early.  */
4623   if (gdbarch_has_global_solist (target_gdbarch ()))
4624     solib_add (NULL, from_tty, auto_solib_add);
4625
4626   if (target_is_non_stop_p ())
4627     {
4628       if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
4629         error (_("Non-stop mode requested, but remote "
4630                  "does not support non-stop"));
4631
4632       putpkt ("QNonStop:1");
4633       getpkt (&rs->buf, 0);
4634
4635       if (strcmp (rs->buf.data (), "OK") != 0)
4636         error (_("Remote refused setting non-stop mode with: %s"),
4637                rs->buf.data ());
4638
4639       /* Find about threads and processes the stub is already
4640          controlling.  We default to adding them in the running state.
4641          The '?' query below will then tell us about which threads are
4642          stopped.  */
4643       this->update_thread_list ();
4644     }
4645   else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
4646     {
4647       /* Don't assume that the stub can operate in all-stop mode.
4648          Request it explicitly.  */
4649       putpkt ("QNonStop:0");
4650       getpkt (&rs->buf, 0);
4651
4652       if (strcmp (rs->buf.data (), "OK") != 0)
4653         error (_("Remote refused setting all-stop mode with: %s"),
4654                rs->buf.data ());
4655     }
4656
4657   /* Upload TSVs regardless of whether the target is running or not.  The
4658      remote stub, such as GDBserver, may have some predefined or builtin
4659      TSVs, even if the target is not running.  */
4660   if (get_trace_status (current_trace_status ()) != -1)
4661     {
4662       struct uploaded_tsv *uploaded_tsvs = NULL;
4663
4664       upload_trace_state_variables (&uploaded_tsvs);
4665       merge_uploaded_trace_state_variables (&uploaded_tsvs);
4666     }
4667
4668   /* Check whether the target is running now.  */
4669   putpkt ("?");
4670   getpkt (&rs->buf, 0);
4671
4672   if (!target_is_non_stop_p ())
4673     {
4674       if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
4675         {
4676           if (!extended_p)
4677             error (_("The target is not running (try extended-remote?)"));
4678
4679           /* We're connected, but not running.  Drop out before we
4680              call start_remote.  */
4681           rs->starting_up = 0;
4682           return;
4683         }
4684       else
4685         {
4686           /* Save the reply for later.  */
4687           wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
4688           strcpy (wait_status, rs->buf.data ());
4689         }
4690
4691       /* Fetch thread list.  */
4692       target_update_thread_list ();
4693
4694       /* Let the stub know that we want it to return the thread.  */
4695       set_continue_thread (minus_one_ptid);
4696
4697       if (thread_count () == 0)
4698         {
4699           /* Target has no concept of threads at all.  GDB treats
4700              non-threaded target as single-threaded; add a main
4701              thread.  */
4702           add_current_inferior_and_thread (wait_status);
4703         }
4704       else
4705         {
4706           /* We have thread information; select the thread the target
4707              says should be current.  If we're reconnecting to a
4708              multi-threaded program, this will ideally be the thread
4709              that last reported an event before GDB disconnected.  */
4710           inferior_ptid = get_current_thread (wait_status);
4711           if (inferior_ptid == null_ptid)
4712             {
4713               /* Odd... The target was able to list threads, but not
4714                  tell us which thread was current (no "thread"
4715                  register in T stop reply?).  Just pick the first
4716                  thread in the thread list then.  */
4717               
4718               if (remote_debug)
4719                 fprintf_unfiltered (gdb_stdlog,
4720                                     "warning: couldn't determine remote "
4721                                     "current thread; picking first in list.\n");
4722
4723               inferior_ptid = inferior_list->thread_list->ptid;
4724             }
4725         }
4726
4727       /* init_wait_for_inferior should be called before get_offsets in order
4728          to manage `inserted' flag in bp loc in a correct state.
4729          breakpoint_init_inferior, called from init_wait_for_inferior, set
4730          `inserted' flag to 0, while before breakpoint_re_set, called from
4731          start_remote, set `inserted' flag to 1.  In the initialization of
4732          inferior, breakpoint_init_inferior should be called first, and then
4733          breakpoint_re_set can be called.  If this order is broken, state of
4734          `inserted' flag is wrong, and cause some problems on breakpoint
4735          manipulation.  */
4736       init_wait_for_inferior ();
4737
4738       get_offsets ();           /* Get text, data & bss offsets.  */
4739
4740       /* If we could not find a description using qXfer, and we know
4741          how to do it some other way, try again.  This is not
4742          supported for non-stop; it could be, but it is tricky if
4743          there are no stopped threads when we connect.  */
4744       if (remote_read_description_p (this)
4745           && gdbarch_target_desc (target_gdbarch ()) == NULL)
4746         {
4747           target_clear_description ();
4748           target_find_description ();
4749         }
4750
4751       /* Use the previously fetched status.  */
4752       gdb_assert (wait_status != NULL);
4753       strcpy (rs->buf.data (), wait_status);
4754       rs->cached_wait_status = 1;
4755
4756       ::start_remote (from_tty); /* Initialize gdb process mechanisms.  */
4757     }
4758   else
4759     {
4760       /* Clear WFI global state.  Do this before finding about new
4761          threads and inferiors, and setting the current inferior.
4762          Otherwise we would clear the proceed status of the current
4763          inferior when we want its stop_soon state to be preserved
4764          (see notice_new_inferior).  */
4765       init_wait_for_inferior ();
4766
4767       /* In non-stop, we will either get an "OK", meaning that there
4768          are no stopped threads at this time; or, a regular stop
4769          reply.  In the latter case, there may be more than one thread
4770          stopped --- we pull them all out using the vStopped
4771          mechanism.  */
4772       if (strcmp (rs->buf.data (), "OK") != 0)
4773         {
4774           struct notif_client *notif = &notif_client_stop;
4775
4776           /* remote_notif_get_pending_replies acks this one, and gets
4777              the rest out.  */
4778           rs->notif_state->pending_event[notif_client_stop.id]
4779             = remote_notif_parse (this, notif, rs->buf.data ());
4780           remote_notif_get_pending_events (notif);
4781         }
4782
4783       if (thread_count () == 0)
4784         {
4785           if (!extended_p)
4786             error (_("The target is not running (try extended-remote?)"));
4787
4788           /* We're connected, but not running.  Drop out before we
4789              call start_remote.  */
4790           rs->starting_up = 0;
4791           return;
4792         }
4793
4794       /* In non-stop mode, any cached wait status will be stored in
4795          the stop reply queue.  */
4796       gdb_assert (wait_status == NULL);
4797
4798       /* Report all signals during attach/startup.  */
4799       pass_signals ({});
4800
4801       /* If there are already stopped threads, mark them stopped and
4802          report their stops before giving the prompt to the user.  */
4803       process_initial_stop_replies (from_tty);
4804
4805       if (target_can_async_p ())
4806         target_async (1);
4807     }
4808
4809   /* If we connected to a live target, do some additional setup.  */
4810   if (target_has_execution)
4811     {
4812       if (symfile_objfile)      /* No use without a symbol-file.  */
4813         remote_check_symbols ();
4814     }
4815
4816   /* Possibly the target has been engaged in a trace run started
4817      previously; find out where things are at.  */
4818   if (get_trace_status (current_trace_status ()) != -1)
4819     {
4820       struct uploaded_tp *uploaded_tps = NULL;
4821
4822       if (current_trace_status ()->running)
4823         printf_filtered (_("Trace is already running on the target.\n"));
4824
4825       upload_tracepoints (&uploaded_tps);
4826
4827       merge_uploaded_tracepoints (&uploaded_tps);
4828     }
4829
4830   /* Possibly the target has been engaged in a btrace record started
4831      previously; find out where things are at.  */
4832   remote_btrace_maybe_reopen ();
4833
4834   /* The thread and inferior lists are now synchronized with the
4835      target, our symbols have been relocated, and we're merged the
4836      target's tracepoints with ours.  We're done with basic start
4837      up.  */
4838   rs->starting_up = 0;
4839
4840   /* Maybe breakpoints are global and need to be inserted now.  */
4841   if (breakpoints_should_be_inserted_now ())
4842     insert_breakpoints ();
4843 }
4844
4845 /* Open a connection to a remote debugger.
4846    NAME is the filename used for communication.  */
4847
4848 void
4849 remote_target::open (const char *name, int from_tty)
4850 {
4851   open_1 (name, from_tty, 0);
4852 }
4853
4854 /* Open a connection to a remote debugger using the extended
4855    remote gdb protocol.  NAME is the filename used for communication.  */
4856
4857 void
4858 extended_remote_target::open (const char *name, int from_tty)
4859 {
4860   open_1 (name, from_tty, 1 /*extended_p */);
4861 }
4862
4863 /* Reset all packets back to "unknown support".  Called when opening a
4864    new connection to a remote target.  */
4865
4866 static void
4867 reset_all_packet_configs_support (void)
4868 {
4869   int i;
4870
4871   for (i = 0; i < PACKET_MAX; i++)
4872     remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4873 }
4874
4875 /* Initialize all packet configs.  */
4876
4877 static void
4878 init_all_packet_configs (void)
4879 {
4880   int i;
4881
4882   for (i = 0; i < PACKET_MAX; i++)
4883     {
4884       remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
4885       remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4886     }
4887 }
4888
4889 /* Symbol look-up.  */
4890
4891 void
4892 remote_target::remote_check_symbols ()
4893 {
4894   char *tmp;
4895   int end;
4896
4897   /* The remote side has no concept of inferiors that aren't running
4898      yet, it only knows about running processes.  If we're connected
4899      but our current inferior is not running, we should not invite the
4900      remote target to request symbol lookups related to its
4901      (unrelated) current process.  */
4902   if (!target_has_execution)
4903     return;
4904
4905   if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
4906     return;
4907
4908   /* Make sure the remote is pointing at the right process.  Note
4909      there's no way to select "no process".  */
4910   set_general_process ();
4911
4912   /* Allocate a message buffer.  We can't reuse the input buffer in RS,
4913      because we need both at the same time.  */
4914   gdb::char_vector msg (get_remote_packet_size ());
4915   gdb::char_vector reply (get_remote_packet_size ());
4916
4917   /* Invite target to request symbol lookups.  */
4918
4919   putpkt ("qSymbol::");
4920   getpkt (&reply, 0);
4921   packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
4922
4923   while (startswith (reply.data (), "qSymbol:"))
4924     {
4925       struct bound_minimal_symbol sym;
4926
4927       tmp = &reply[8];
4928       end = hex2bin (tmp, reinterpret_cast <gdb_byte *> (msg.data ()),
4929                      strlen (tmp) / 2);
4930       msg[end] = '\0';
4931       sym = lookup_minimal_symbol (msg.data (), NULL, NULL);
4932       if (sym.minsym == NULL)
4933         xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol::%s",
4934                    &reply[8]);
4935       else
4936         {
4937           int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
4938           CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
4939
4940           /* If this is a function address, return the start of code
4941              instead of any data function descriptor.  */
4942           sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4943                                                          sym_addr,
4944                                                          current_top_target ());
4945
4946           xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4947                      phex_nz (sym_addr, addr_size), &reply[8]);
4948         }
4949
4950       putpkt (msg.data ());
4951       getpkt (&reply, 0);
4952     }
4953 }
4954
4955 static struct serial *
4956 remote_serial_open (const char *name)
4957 {
4958   static int udp_warning = 0;
4959
4960   /* FIXME: Parsing NAME here is a hack.  But we want to warn here instead
4961      of in ser-tcp.c, because it is the remote protocol assuming that the
4962      serial connection is reliable and not the serial connection promising
4963      to be.  */
4964   if (!udp_warning && startswith (name, "udp:"))
4965     {
4966       warning (_("The remote protocol may be unreliable over UDP.\n"
4967                  "Some events may be lost, rendering further debugging "
4968                  "impossible."));
4969       udp_warning = 1;
4970     }
4971
4972   return serial_open (name);
4973 }
4974
4975 /* Inform the target of our permission settings.  The permission flags
4976    work without this, but if the target knows the settings, it can do
4977    a couple things.  First, it can add its own check, to catch cases
4978    that somehow manage to get by the permissions checks in target
4979    methods.  Second, if the target is wired to disallow particular
4980    settings (for instance, a system in the field that is not set up to
4981    be able to stop at a breakpoint), it can object to any unavailable
4982    permissions.  */
4983
4984 void
4985 remote_target::set_permissions ()
4986 {
4987   struct remote_state *rs = get_remote_state ();
4988
4989   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:"
4990              "WriteReg:%x;WriteMem:%x;"
4991              "InsertBreak:%x;InsertTrace:%x;"
4992              "InsertFastTrace:%x;Stop:%x",
4993              may_write_registers, may_write_memory,
4994              may_insert_breakpoints, may_insert_tracepoints,
4995              may_insert_fast_tracepoints, may_stop);
4996   putpkt (rs->buf);
4997   getpkt (&rs->buf, 0);
4998
4999   /* If the target didn't like the packet, warn the user.  Do not try
5000      to undo the user's settings, that would just be maddening.  */
5001   if (strcmp (rs->buf.data (), "OK") != 0)
5002     warning (_("Remote refused setting permissions with: %s"),
5003              rs->buf.data ());
5004 }
5005
5006 /* This type describes each known response to the qSupported
5007    packet.  */
5008 struct protocol_feature
5009 {
5010   /* The name of this protocol feature.  */
5011   const char *name;
5012
5013   /* The default for this protocol feature.  */
5014   enum packet_support default_support;
5015
5016   /* The function to call when this feature is reported, or after
5017      qSupported processing if the feature is not supported.
5018      The first argument points to this structure.  The second
5019      argument indicates whether the packet requested support be
5020      enabled, disabled, or probed (or the default, if this function
5021      is being called at the end of processing and this feature was
5022      not reported).  The third argument may be NULL; if not NULL, it
5023      is a NUL-terminated string taken from the packet following
5024      this feature's name and an equals sign.  */
5025   void (*func) (remote_target *remote, const struct protocol_feature *,
5026                 enum packet_support, const char *);
5027
5028   /* The corresponding packet for this feature.  Only used if
5029      FUNC is remote_supported_packet.  */
5030   int packet;
5031 };
5032
5033 static void
5034 remote_supported_packet (remote_target *remote,
5035                          const struct protocol_feature *feature,
5036                          enum packet_support support,
5037                          const char *argument)
5038 {
5039   if (argument)
5040     {
5041       warning (_("Remote qSupported response supplied an unexpected value for"
5042                  " \"%s\"."), feature->name);
5043       return;
5044     }
5045
5046   remote_protocol_packets[feature->packet].support = support;
5047 }
5048
5049 void
5050 remote_target::remote_packet_size (const protocol_feature *feature,
5051                                    enum packet_support support, const char *value)
5052 {
5053   struct remote_state *rs = get_remote_state ();
5054
5055   int packet_size;
5056   char *value_end;
5057
5058   if (support != PACKET_ENABLE)
5059     return;
5060
5061   if (value == NULL || *value == '\0')
5062     {
5063       warning (_("Remote target reported \"%s\" without a size."),
5064                feature->name);
5065       return;
5066     }
5067
5068   errno = 0;
5069   packet_size = strtol (value, &value_end, 16);
5070   if (errno != 0 || *value_end != '\0' || packet_size < 0)
5071     {
5072       warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5073                feature->name, value);
5074       return;
5075     }
5076
5077   /* Record the new maximum packet size.  */
5078   rs->explicit_packet_size = packet_size;
5079 }
5080
5081 void
5082 remote_packet_size (remote_target *remote, const protocol_feature *feature,
5083                     enum packet_support support, const char *value)
5084 {
5085   remote->remote_packet_size (feature, support, value);
5086 }
5087
5088 static const struct protocol_feature remote_protocol_features[] = {
5089   { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
5090   { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
5091     PACKET_qXfer_auxv },
5092   { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet,
5093     PACKET_qXfer_exec_file },
5094   { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
5095     PACKET_qXfer_features },
5096   { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
5097     PACKET_qXfer_libraries },
5098   { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
5099     PACKET_qXfer_libraries_svr4 },
5100   { "augmented-libraries-svr4-read", PACKET_DISABLE,
5101     remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
5102   { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
5103     PACKET_qXfer_memory_map },
5104   { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
5105     PACKET_qXfer_spu_read },
5106   { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
5107     PACKET_qXfer_spu_write },
5108   { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
5109     PACKET_qXfer_osdata },
5110   { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
5111     PACKET_qXfer_threads },
5112   { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
5113     PACKET_qXfer_traceframe_info },
5114   { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
5115     PACKET_QPassSignals },
5116   { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet,
5117     PACKET_QCatchSyscalls },
5118   { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
5119     PACKET_QProgramSignals },
5120   { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet,
5121     PACKET_QSetWorkingDir },
5122   { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet,
5123     PACKET_QStartupWithShell },
5124   { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet,
5125     PACKET_QEnvironmentHexEncoded },
5126   { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet,
5127     PACKET_QEnvironmentReset },
5128   { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet,
5129     PACKET_QEnvironmentUnset },
5130   { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
5131     PACKET_QStartNoAckMode },
5132   { "multiprocess", PACKET_DISABLE, remote_supported_packet,
5133     PACKET_multiprocess_feature },
5134   { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
5135   { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
5136     PACKET_qXfer_siginfo_read },
5137   { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
5138     PACKET_qXfer_siginfo_write },
5139   { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
5140     PACKET_ConditionalTracepoints },
5141   { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
5142     PACKET_ConditionalBreakpoints },
5143   { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
5144     PACKET_BreakpointCommands },
5145   { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
5146     PACKET_FastTracepoints },
5147   { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
5148     PACKET_StaticTracepoints },
5149   {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
5150    PACKET_InstallInTrace},
5151   { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
5152     PACKET_DisconnectedTracing_feature },
5153   { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
5154     PACKET_bc },
5155   { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
5156     PACKET_bs },
5157   { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
5158     PACKET_TracepointSource },
5159   { "QAllow", PACKET_DISABLE, remote_supported_packet,
5160     PACKET_QAllow },
5161   { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
5162     PACKET_EnableDisableTracepoints_feature },
5163   { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
5164     PACKET_qXfer_fdpic },
5165   { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
5166     PACKET_qXfer_uib },
5167   { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
5168     PACKET_QDisableRandomization },
5169   { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
5170   { "QTBuffer:size", PACKET_DISABLE,
5171     remote_supported_packet, PACKET_QTBuffer_size},
5172   { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
5173   { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
5174   { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
5175   { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt },
5176   { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
5177     PACKET_qXfer_btrace },
5178   { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet,
5179     PACKET_qXfer_btrace_conf },
5180   { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet,
5181     PACKET_Qbtrace_conf_bts_size },
5182   { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
5183   { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
5184   { "fork-events", PACKET_DISABLE, remote_supported_packet,
5185     PACKET_fork_event_feature },
5186   { "vfork-events", PACKET_DISABLE, remote_supported_packet,
5187     PACKET_vfork_event_feature },
5188   { "exec-events", PACKET_DISABLE, remote_supported_packet,
5189     PACKET_exec_event_feature },
5190   { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet,
5191     PACKET_Qbtrace_conf_pt_size },
5192   { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
5193   { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
5194   { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
5195 };
5196
5197 static char *remote_support_xml;
5198
5199 /* Register string appended to "xmlRegisters=" in qSupported query.  */
5200
5201 void
5202 register_remote_support_xml (const char *xml)
5203 {
5204 #if defined(HAVE_LIBEXPAT)
5205   if (remote_support_xml == NULL)
5206     remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
5207   else
5208     {
5209       char *copy = xstrdup (remote_support_xml + 13);
5210       char *p = strtok (copy, ",");
5211
5212       do
5213         {
5214           if (strcmp (p, xml) == 0)
5215             {
5216               /* already there */
5217               xfree (copy);
5218               return;
5219             }
5220         }
5221       while ((p = strtok (NULL, ",")) != NULL);
5222       xfree (copy);
5223
5224       remote_support_xml = reconcat (remote_support_xml,
5225                                      remote_support_xml, ",", xml,
5226                                      (char *) NULL);
5227     }
5228 #endif
5229 }
5230
5231 static void
5232 remote_query_supported_append (std::string *msg, const char *append)
5233 {
5234   if (!msg->empty ())
5235     msg->append (";");
5236   msg->append (append);
5237 }
5238
5239 void
5240 remote_target::remote_query_supported ()
5241 {
5242   struct remote_state *rs = get_remote_state ();
5243   char *next;
5244   int i;
5245   unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
5246
5247   /* The packet support flags are handled differently for this packet
5248      than for most others.  We treat an error, a disabled packet, and
5249      an empty response identically: any features which must be reported
5250      to be used will be automatically disabled.  An empty buffer
5251      accomplishes this, since that is also the representation for a list
5252      containing no features.  */
5253
5254   rs->buf[0] = 0;
5255   if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
5256     {
5257       std::string q;
5258
5259       if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
5260         remote_query_supported_append (&q, "multiprocess+");
5261
5262       if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
5263         remote_query_supported_append (&q, "swbreak+");
5264       if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
5265         remote_query_supported_append (&q, "hwbreak+");
5266
5267       remote_query_supported_append (&q, "qRelocInsn+");
5268
5269       if (packet_set_cmd_state (PACKET_fork_event_feature)
5270           != AUTO_BOOLEAN_FALSE)
5271         remote_query_supported_append (&q, "fork-events+");
5272       if (packet_set_cmd_state (PACKET_vfork_event_feature)
5273           != AUTO_BOOLEAN_FALSE)
5274         remote_query_supported_append (&q, "vfork-events+");
5275       if (packet_set_cmd_state (PACKET_exec_event_feature)
5276           != AUTO_BOOLEAN_FALSE)
5277         remote_query_supported_append (&q, "exec-events+");
5278
5279       if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
5280         remote_query_supported_append (&q, "vContSupported+");
5281
5282       if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
5283         remote_query_supported_append (&q, "QThreadEvents+");
5284
5285       if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
5286         remote_query_supported_append (&q, "no-resumed+");
5287
5288       /* Keep this one last to work around a gdbserver <= 7.10 bug in
5289          the qSupported:xmlRegisters=i386 handling.  */
5290       if (remote_support_xml != NULL
5291           && packet_support (PACKET_qXfer_features) != PACKET_DISABLE)
5292         remote_query_supported_append (&q, remote_support_xml);
5293
5294       q = "qSupported:" + q;
5295       putpkt (q.c_str ());
5296
5297       getpkt (&rs->buf, 0);
5298
5299       /* If an error occured, warn, but do not return - just reset the
5300          buffer to empty and go on to disable features.  */
5301       if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
5302           == PACKET_ERROR)
5303         {
5304           warning (_("Remote failure reply: %s"), rs->buf.data ());
5305           rs->buf[0] = 0;
5306         }
5307     }
5308
5309   memset (seen, 0, sizeof (seen));
5310
5311   next = rs->buf.data ();
5312   while (*next)
5313     {
5314       enum packet_support is_supported;
5315       char *p, *end, *name_end, *value;
5316
5317       /* First separate out this item from the rest of the packet.  If
5318          there's another item after this, we overwrite the separator
5319          (terminated strings are much easier to work with).  */
5320       p = next;
5321       end = strchr (p, ';');
5322       if (end == NULL)
5323         {
5324           end = p + strlen (p);
5325           next = end;
5326         }
5327       else
5328         {
5329           *end = '\0';
5330           next = end + 1;
5331
5332           if (end == p)
5333             {
5334               warning (_("empty item in \"qSupported\" response"));
5335               continue;
5336             }
5337         }
5338
5339       name_end = strchr (p, '=');
5340       if (name_end)
5341         {
5342           /* This is a name=value entry.  */
5343           is_supported = PACKET_ENABLE;
5344           value = name_end + 1;
5345           *name_end = '\0';
5346         }
5347       else
5348         {
5349           value = NULL;
5350           switch (end[-1])
5351             {
5352             case '+':
5353               is_supported = PACKET_ENABLE;
5354               break;
5355
5356             case '-':
5357               is_supported = PACKET_DISABLE;
5358               break;
5359
5360             case '?':
5361               is_supported = PACKET_SUPPORT_UNKNOWN;
5362               break;
5363
5364             default:
5365               warning (_("unrecognized item \"%s\" "
5366                          "in \"qSupported\" response"), p);
5367               continue;
5368             }
5369           end[-1] = '\0';
5370         }
5371
5372       for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5373         if (strcmp (remote_protocol_features[i].name, p) == 0)
5374           {
5375             const struct protocol_feature *feature;
5376
5377             seen[i] = 1;
5378             feature = &remote_protocol_features[i];
5379             feature->func (this, feature, is_supported, value);
5380             break;
5381           }
5382     }
5383
5384   /* If we increased the packet size, make sure to increase the global
5385      buffer size also.  We delay this until after parsing the entire
5386      qSupported packet, because this is the same buffer we were
5387      parsing.  */
5388   if (rs->buf.size () < rs->explicit_packet_size)
5389     rs->buf.resize (rs->explicit_packet_size);
5390
5391   /* Handle the defaults for unmentioned features.  */
5392   for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5393     if (!seen[i])
5394       {
5395         const struct protocol_feature *feature;
5396
5397         feature = &remote_protocol_features[i];
5398         feature->func (this, feature, feature->default_support, NULL);
5399       }
5400 }
5401
5402 /* Serial QUIT handler for the remote serial descriptor.
5403
5404    Defers handling a Ctrl-C until we're done with the current
5405    command/response packet sequence, unless:
5406
5407    - We're setting up the connection.  Don't send a remote interrupt
5408      request, as we're not fully synced yet.  Quit immediately
5409      instead.
5410
5411    - The target has been resumed in the foreground
5412      (target_terminal::is_ours is false) with a synchronous resume
5413      packet, and we're blocked waiting for the stop reply, thus a
5414      Ctrl-C should be immediately sent to the target.
5415
5416    - We get a second Ctrl-C while still within the same serial read or
5417      write.  In that case the serial is seemingly wedged --- offer to
5418      quit/disconnect.
5419
5420    - We see a second Ctrl-C without target response, after having
5421      previously interrupted the target.  In that case the target/stub
5422      is probably wedged --- offer to quit/disconnect.
5423 */
5424
5425 void
5426 remote_target::remote_serial_quit_handler ()
5427 {
5428   struct remote_state *rs = get_remote_state ();
5429
5430   if (check_quit_flag ())
5431     {
5432       /* If we're starting up, we're not fully synced yet.  Quit
5433          immediately.  */
5434       if (rs->starting_up)
5435         quit ();
5436       else if (rs->got_ctrlc_during_io)
5437         {
5438           if (query (_("The target is not responding to GDB commands.\n"
5439                        "Stop debugging it? ")))
5440             remote_unpush_and_throw ();
5441         }
5442       /* If ^C has already been sent once, offer to disconnect.  */
5443       else if (!target_terminal::is_ours () && rs->ctrlc_pending_p)
5444         interrupt_query ();
5445       /* All-stop protocol, and blocked waiting for stop reply.  Send
5446          an interrupt request.  */
5447       else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply)
5448         target_interrupt ();
5449       else
5450         rs->got_ctrlc_during_io = 1;
5451     }
5452 }
5453
5454 /* The remote_target that is current while the quit handler is
5455    overridden with remote_serial_quit_handler.  */
5456 static remote_target *curr_quit_handler_target;
5457
5458 static void
5459 remote_serial_quit_handler ()
5460 {
5461   curr_quit_handler_target->remote_serial_quit_handler ();
5462 }
5463
5464 /* Remove any of the remote.c targets from target stack.  Upper targets depend
5465    on it so remove them first.  */
5466
5467 static void
5468 remote_unpush_target (void)
5469 {
5470   pop_all_targets_at_and_above (process_stratum);
5471 }
5472
5473 static void
5474 remote_unpush_and_throw (void)
5475 {
5476   remote_unpush_target ();
5477   throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
5478 }
5479
5480 void
5481 remote_target::open_1 (const char *name, int from_tty, int extended_p)
5482 {
5483   remote_target *curr_remote = get_current_remote_target ();
5484
5485   if (name == 0)
5486     error (_("To open a remote debug connection, you need to specify what\n"
5487            "serial device is attached to the remote system\n"
5488            "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5489
5490   /* If we're connected to a running target, target_preopen will kill it.
5491      Ask this question first, before target_preopen has a chance to kill
5492      anything.  */
5493   if (curr_remote != NULL && !have_inferiors ())
5494     {
5495       if (from_tty
5496           && !query (_("Already connected to a remote target.  Disconnect? ")))
5497         error (_("Still connected."));
5498     }
5499
5500   /* Here the possibly existing remote target gets unpushed.  */
5501   target_preopen (from_tty);
5502
5503   remote_fileio_reset ();
5504   reopen_exec_file ();
5505   reread_symbols ();
5506
5507   remote_target *remote
5508     = (extended_p ? new extended_remote_target () : new remote_target ());
5509   target_ops_up target_holder (remote);
5510
5511   remote_state *rs = remote->get_remote_state ();
5512
5513   /* See FIXME above.  */
5514   if (!target_async_permitted)
5515     rs->wait_forever_enabled_p = 1;
5516
5517   rs->remote_desc = remote_serial_open (name);
5518   if (!rs->remote_desc)
5519     perror_with_name (name);
5520
5521   if (baud_rate != -1)
5522     {
5523       if (serial_setbaudrate (rs->remote_desc, baud_rate))
5524         {
5525           /* The requested speed could not be set.  Error out to
5526              top level after closing remote_desc.  Take care to
5527              set remote_desc to NULL to avoid closing remote_desc
5528              more than once.  */
5529           serial_close (rs->remote_desc);
5530           rs->remote_desc = NULL;
5531           perror_with_name (name);
5532         }
5533     }
5534
5535   serial_setparity (rs->remote_desc, serial_parity);
5536   serial_raw (rs->remote_desc);
5537
5538   /* If there is something sitting in the buffer we might take it as a
5539      response to a command, which would be bad.  */
5540   serial_flush_input (rs->remote_desc);
5541
5542   if (from_tty)
5543     {
5544       puts_filtered ("Remote debugging using ");
5545       puts_filtered (name);
5546       puts_filtered ("\n");
5547     }
5548
5549   /* Switch to using the remote target now.  */
5550   push_target (std::move (target_holder));
5551
5552   /* Register extra event sources in the event loop.  */
5553   rs->remote_async_inferior_event_token
5554     = create_async_event_handler (remote_async_inferior_event_handler,
5555                                   remote);
5556   rs->notif_state = remote_notif_state_allocate (remote);
5557
5558   /* Reset the target state; these things will be queried either by
5559      remote_query_supported or as they are needed.  */
5560   reset_all_packet_configs_support ();
5561   rs->cached_wait_status = 0;
5562   rs->explicit_packet_size = 0;
5563   rs->noack_mode = 0;
5564   rs->extended = extended_p;
5565   rs->waiting_for_stop_reply = 0;
5566   rs->ctrlc_pending_p = 0;
5567   rs->got_ctrlc_during_io = 0;
5568
5569   rs->general_thread = not_sent_ptid;
5570   rs->continue_thread = not_sent_ptid;
5571   rs->remote_traceframe_number = -1;
5572
5573   rs->last_resume_exec_dir = EXEC_FORWARD;
5574
5575   /* Probe for ability to use "ThreadInfo" query, as required.  */
5576   rs->use_threadinfo_query = 1;
5577   rs->use_threadextra_query = 1;
5578
5579   rs->readahead_cache.invalidate ();
5580
5581   if (target_async_permitted)
5582     {
5583       /* FIXME: cagney/1999-09-23: During the initial connection it is
5584          assumed that the target is already ready and able to respond to
5585          requests.  Unfortunately remote_start_remote() eventually calls
5586          wait_for_inferior() with no timeout.  wait_forever_enabled_p gets
5587          around this.  Eventually a mechanism that allows
5588          wait_for_inferior() to expect/get timeouts will be
5589          implemented.  */
5590       rs->wait_forever_enabled_p = 0;
5591     }
5592
5593   /* First delete any symbols previously loaded from shared libraries.  */
5594   no_shared_libraries (NULL, 0);
5595
5596   /* Start the remote connection.  If error() or QUIT, discard this
5597      target (we'd otherwise be in an inconsistent state) and then
5598      propogate the error on up the exception chain.  This ensures that
5599      the caller doesn't stumble along blindly assuming that the
5600      function succeeded.  The CLI doesn't have this problem but other
5601      UI's, such as MI do.
5602
5603      FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5604      this function should return an error indication letting the
5605      caller restore the previous state.  Unfortunately the command
5606      ``target remote'' is directly wired to this function making that
5607      impossible.  On a positive note, the CLI side of this problem has
5608      been fixed - the function set_cmd_context() makes it possible for
5609      all the ``target ....'' commands to share a common callback
5610      function.  See cli-dump.c.  */
5611   {
5612
5613     TRY
5614       {
5615         remote->start_remote (from_tty, extended_p);
5616       }
5617     CATCH (ex, RETURN_MASK_ALL)
5618       {
5619         /* Pop the partially set up target - unless something else did
5620            already before throwing the exception.  */
5621         if (ex.error != TARGET_CLOSE_ERROR)
5622           remote_unpush_target ();
5623         throw_exception (ex);
5624       }
5625     END_CATCH
5626   }
5627
5628   remote_btrace_reset (rs);
5629
5630   if (target_async_permitted)
5631     rs->wait_forever_enabled_p = 1;
5632 }
5633
5634 /* Detach the specified process.  */
5635
5636 void
5637 remote_target::remote_detach_pid (int pid)
5638 {
5639   struct remote_state *rs = get_remote_state ();
5640
5641   /* This should not be necessary, but the handling for D;PID in
5642      GDBserver versions prior to 8.2 incorrectly assumes that the
5643      selected process points to the same process we're detaching,
5644      leading to misbehavior (and possibly GDBserver crashing) when it
5645      does not.  Since it's easy and cheap, work around it by forcing
5646      GDBserver to select GDB's current process.  */
5647   set_general_process ();
5648
5649   if (remote_multi_process_p (rs))
5650     xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid);
5651   else
5652     strcpy (rs->buf.data (), "D");
5653
5654   putpkt (rs->buf);
5655   getpkt (&rs->buf, 0);
5656
5657   if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
5658     ;
5659   else if (rs->buf[0] == '\0')
5660     error (_("Remote doesn't know how to detach"));
5661   else
5662     error (_("Can't detach process."));
5663 }
5664
5665 /* This detaches a program to which we previously attached, using
5666    inferior_ptid to identify the process.  After this is done, GDB
5667    can be used to debug some other program.  We better not have left
5668    any breakpoints in the target program or it'll die when it hits
5669    one.  */
5670
5671 void
5672 remote_target::remote_detach_1 (inferior *inf, int from_tty)
5673 {
5674   int pid = inferior_ptid.pid ();
5675   struct remote_state *rs = get_remote_state ();
5676   int is_fork_parent;
5677
5678   if (!target_has_execution)
5679     error (_("No process to detach from."));
5680
5681   target_announce_detach (from_tty);
5682
5683   /* Tell the remote target to detach.  */
5684   remote_detach_pid (pid);
5685
5686   /* Exit only if this is the only active inferior.  */
5687   if (from_tty && !rs->extended && number_of_live_inferiors () == 1)
5688     puts_filtered (_("Ending remote debugging.\n"));
5689
5690   struct thread_info *tp = find_thread_ptid (inferior_ptid);
5691
5692   /* Check to see if we are detaching a fork parent.  Note that if we
5693      are detaching a fork child, tp == NULL.  */
5694   is_fork_parent = (tp != NULL
5695                     && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
5696
5697   /* If doing detach-on-fork, we don't mourn, because that will delete
5698      breakpoints that should be available for the followed inferior.  */
5699   if (!is_fork_parent)
5700     {
5701       /* Save the pid as a string before mourning, since that will
5702          unpush the remote target, and we need the string after.  */
5703       std::string infpid = target_pid_to_str (ptid_t (pid));
5704
5705       target_mourn_inferior (inferior_ptid);
5706       if (print_inferior_events)
5707         printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5708                            inf->num, infpid.c_str ());
5709     }
5710   else
5711     {
5712       inferior_ptid = null_ptid;
5713       detach_inferior (current_inferior ());
5714     }
5715 }
5716
5717 void
5718 remote_target::detach (inferior *inf, int from_tty)
5719 {
5720   remote_detach_1 (inf, from_tty);
5721 }
5722
5723 void
5724 extended_remote_target::detach (inferior *inf, int from_tty)
5725 {
5726   remote_detach_1 (inf, from_tty);
5727 }
5728
5729 /* Target follow-fork function for remote targets.  On entry, and
5730    at return, the current inferior is the fork parent.
5731
5732    Note that although this is currently only used for extended-remote,
5733    it is named remote_follow_fork in anticipation of using it for the
5734    remote target as well.  */
5735
5736 int
5737 remote_target::follow_fork (int follow_child, int detach_fork)
5738 {
5739   struct remote_state *rs = get_remote_state ();
5740   enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
5741
5742   if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
5743       || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
5744     {
5745       /* When following the parent and detaching the child, we detach
5746          the child here.  For the case of following the child and
5747          detaching the parent, the detach is done in the target-
5748          independent follow fork code in infrun.c.  We can't use
5749          target_detach when detaching an unfollowed child because
5750          the client side doesn't know anything about the child.  */
5751       if (detach_fork && !follow_child)
5752         {
5753           /* Detach the fork child.  */
5754           ptid_t child_ptid;
5755           pid_t child_pid;
5756
5757           child_ptid = inferior_thread ()->pending_follow.value.related_pid;
5758           child_pid = child_ptid.pid ();
5759
5760           remote_detach_pid (child_pid);
5761         }
5762     }
5763   return 0;
5764 }
5765
5766 /* Target follow-exec function for remote targets.  Save EXECD_PATHNAME
5767    in the program space of the new inferior.  On entry and at return the
5768    current inferior is the exec'ing inferior.  INF is the new exec'd
5769    inferior, which may be the same as the exec'ing inferior unless
5770    follow-exec-mode is "new".  */
5771
5772 void
5773 remote_target::follow_exec (struct inferior *inf, char *execd_pathname)
5774 {
5775   /* We know that this is a target file name, so if it has the "target:"
5776      prefix we strip it off before saving it in the program space.  */
5777   if (is_target_filename (execd_pathname))
5778     execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
5779
5780   set_pspace_remote_exec_file (inf->pspace, execd_pathname);
5781 }
5782
5783 /* Same as remote_detach, but don't send the "D" packet; just disconnect.  */
5784
5785 void
5786 remote_target::disconnect (const char *args, int from_tty)
5787 {
5788   if (args)
5789     error (_("Argument given to \"disconnect\" when remotely debugging."));
5790
5791   /* Make sure we unpush even the extended remote targets.  Calling
5792      target_mourn_inferior won't unpush, and remote_mourn won't
5793      unpush if there is more than one inferior left.  */
5794   unpush_target (this);
5795   generic_mourn_inferior ();
5796
5797   if (from_tty)
5798     puts_filtered ("Ending remote debugging.\n");
5799 }
5800
5801 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
5802    be chatty about it.  */
5803
5804 void
5805 extended_remote_target::attach (const char *args, int from_tty)
5806 {
5807   struct remote_state *rs = get_remote_state ();
5808   int pid;
5809   char *wait_status = NULL;
5810
5811   pid = parse_pid_to_attach (args);
5812
5813   /* Remote PID can be freely equal to getpid, do not check it here the same
5814      way as in other targets.  */
5815
5816   if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
5817     error (_("This target does not support attaching to a process"));
5818
5819   if (from_tty)
5820     {
5821       char *exec_file = get_exec_file (0);
5822
5823       if (exec_file)
5824         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
5825                            target_pid_to_str (ptid_t (pid)));
5826       else
5827         printf_unfiltered (_("Attaching to %s\n"),
5828                            target_pid_to_str (ptid_t (pid)));
5829
5830       gdb_flush (gdb_stdout);
5831     }
5832
5833   xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
5834   putpkt (rs->buf);
5835   getpkt (&rs->buf, 0);
5836
5837   switch (packet_ok (rs->buf,
5838                      &remote_protocol_packets[PACKET_vAttach]))
5839     {
5840     case PACKET_OK:
5841       if (!target_is_non_stop_p ())
5842         {
5843           /* Save the reply for later.  */
5844           wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
5845           strcpy (wait_status, rs->buf.data ());
5846         }
5847       else if (strcmp (rs->buf.data (), "OK") != 0)
5848         error (_("Attaching to %s failed with: %s"),
5849                target_pid_to_str (ptid_t (pid)),
5850                rs->buf.data ());
5851       break;
5852     case PACKET_UNKNOWN:
5853       error (_("This target does not support attaching to a process"));
5854     default:
5855       error (_("Attaching to %s failed"),
5856              target_pid_to_str (ptid_t (pid)));
5857     }
5858
5859   set_current_inferior (remote_add_inferior (0, pid, 1, 0));
5860
5861   inferior_ptid = ptid_t (pid);
5862
5863   if (target_is_non_stop_p ())
5864     {
5865       struct thread_info *thread;
5866
5867       /* Get list of threads.  */
5868       update_thread_list ();
5869
5870       thread = first_thread_of_inferior (current_inferior ());
5871       if (thread)
5872         inferior_ptid = thread->ptid;
5873       else
5874         inferior_ptid = ptid_t (pid);
5875
5876       /* Invalidate our notion of the remote current thread.  */
5877       record_currthread (rs, minus_one_ptid);
5878     }
5879   else
5880     {
5881       /* Now, if we have thread information, update inferior_ptid.  */
5882       inferior_ptid = remote_current_thread (inferior_ptid);
5883
5884       /* Add the main thread to the thread list.  */
5885       thread_info *thr = add_thread_silent (inferior_ptid);
5886       /* Don't consider the thread stopped until we've processed the
5887          saved stop reply.  */
5888       set_executing (thr->ptid, true);
5889     }
5890
5891   /* Next, if the target can specify a description, read it.  We do
5892      this before anything involving memory or registers.  */
5893   target_find_description ();
5894
5895   if (!target_is_non_stop_p ())
5896     {
5897       /* Use the previously fetched status.  */
5898       gdb_assert (wait_status != NULL);
5899
5900       if (target_can_async_p ())
5901         {
5902           struct notif_event *reply
5903             =  remote_notif_parse (this, &notif_client_stop, wait_status);
5904
5905           push_stop_reply ((struct stop_reply *) reply);
5906
5907           target_async (1);
5908         }
5909       else
5910         {
5911           gdb_assert (wait_status != NULL);
5912           strcpy (rs->buf.data (), wait_status);
5913           rs->cached_wait_status = 1;
5914         }
5915     }
5916   else
5917     gdb_assert (wait_status == NULL);
5918 }
5919
5920 /* Implementation of the to_post_attach method.  */
5921
5922 void
5923 extended_remote_target::post_attach (int pid)
5924 {
5925   /* Get text, data & bss offsets.  */
5926   get_offsets ();
5927
5928   /* In certain cases GDB might not have had the chance to start
5929      symbol lookup up until now.  This could happen if the debugged
5930      binary is not using shared libraries, the vsyscall page is not
5931      present (on Linux) and the binary itself hadn't changed since the
5932      debugging process was started.  */
5933   if (symfile_objfile != NULL)
5934     remote_check_symbols();
5935 }
5936
5937 \f
5938 /* Check for the availability of vCont.  This function should also check
5939    the response.  */
5940
5941 void
5942 remote_target::remote_vcont_probe ()
5943 {
5944   remote_state *rs = get_remote_state ();
5945   char *buf;
5946
5947   strcpy (rs->buf.data (), "vCont?");
5948   putpkt (rs->buf);
5949   getpkt (&rs->buf, 0);
5950   buf = rs->buf.data ();
5951
5952   /* Make sure that the features we assume are supported.  */
5953   if (startswith (buf, "vCont"))
5954     {
5955       char *p = &buf[5];
5956       int support_c, support_C;
5957
5958       rs->supports_vCont.s = 0;
5959       rs->supports_vCont.S = 0;
5960       support_c = 0;
5961       support_C = 0;
5962       rs->supports_vCont.t = 0;
5963       rs->supports_vCont.r = 0;
5964       while (p && *p == ';')
5965         {
5966           p++;
5967           if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
5968             rs->supports_vCont.s = 1;
5969           else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
5970             rs->supports_vCont.S = 1;
5971           else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
5972             support_c = 1;
5973           else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
5974             support_C = 1;
5975           else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
5976             rs->supports_vCont.t = 1;
5977           else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0))
5978             rs->supports_vCont.r = 1;
5979
5980           p = strchr (p, ';');
5981         }
5982
5983       /* If c, and C are not all supported, we can't use vCont.  Clearing
5984          BUF will make packet_ok disable the packet.  */
5985       if (!support_c || !support_C)
5986         buf[0] = 0;
5987     }
5988
5989   packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]);
5990 }
5991
5992 /* Helper function for building "vCont" resumptions.  Write a
5993    resumption to P.  ENDP points to one-passed-the-end of the buffer
5994    we're allowed to write to.  Returns BUF+CHARACTERS_WRITTEN.  The
5995    thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5996    resumed thread should be single-stepped and/or signalled.  If PTID
5997    equals minus_one_ptid, then all threads are resumed; if PTID
5998    represents a process, then all threads of the process are resumed;
5999    the thread to be stepped and/or signalled is given in the global
6000    INFERIOR_PTID.  */
6001
6002 char *
6003 remote_target::append_resumption (char *p, char *endp,
6004                                   ptid_t ptid, int step, gdb_signal siggnal)
6005 {
6006   struct remote_state *rs = get_remote_state ();
6007
6008   if (step && siggnal != GDB_SIGNAL_0)
6009     p += xsnprintf (p, endp - p, ";S%02x", siggnal);
6010   else if (step
6011            /* GDB is willing to range step.  */
6012            && use_range_stepping
6013            /* Target supports range stepping.  */
6014            && rs->supports_vCont.r
6015            /* We don't currently support range stepping multiple
6016               threads with a wildcard (though the protocol allows it,
6017               so stubs shouldn't make an active effort to forbid
6018               it).  */
6019            && !(remote_multi_process_p (rs) && ptid.is_pid ()))
6020     {
6021       struct thread_info *tp;
6022
6023       if (ptid == minus_one_ptid)
6024         {
6025           /* If we don't know about the target thread's tid, then
6026              we're resuming magic_null_ptid (see caller).  */
6027           tp = find_thread_ptid (magic_null_ptid);
6028         }
6029       else
6030         tp = find_thread_ptid (ptid);
6031       gdb_assert (tp != NULL);
6032
6033       if (tp->control.may_range_step)
6034         {
6035           int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
6036
6037           p += xsnprintf (p, endp - p, ";r%s,%s",
6038                           phex_nz (tp->control.step_range_start,
6039                                    addr_size),
6040                           phex_nz (tp->control.step_range_end,
6041                                    addr_size));
6042         }
6043       else
6044         p += xsnprintf (p, endp - p, ";s");
6045     }
6046   else if (step)
6047     p += xsnprintf (p, endp - p, ";s");
6048   else if (siggnal != GDB_SIGNAL_0)
6049     p += xsnprintf (p, endp - p, ";C%02x", siggnal);
6050   else
6051     p += xsnprintf (p, endp - p, ";c");
6052
6053   if (remote_multi_process_p (rs) && ptid.is_pid ())
6054     {
6055       ptid_t nptid;
6056
6057       /* All (-1) threads of process.  */
6058       nptid = ptid_t (ptid.pid (), -1, 0);
6059
6060       p += xsnprintf (p, endp - p, ":");
6061       p = write_ptid (p, endp, nptid);
6062     }
6063   else if (ptid != minus_one_ptid)
6064     {
6065       p += xsnprintf (p, endp - p, ":");
6066       p = write_ptid (p, endp, ptid);
6067     }
6068
6069   return p;
6070 }
6071
6072 /* Clear the thread's private info on resume.  */
6073
6074 static void
6075 resume_clear_thread_private_info (struct thread_info *thread)
6076 {
6077   if (thread->priv != NULL)
6078     {
6079       remote_thread_info *priv = get_remote_thread_info (thread);
6080
6081       priv->stop_reason = TARGET_STOPPED_BY_NO_REASON;
6082       priv->watch_data_address = 0;
6083     }
6084 }
6085
6086 /* Append a vCont continue-with-signal action for threads that have a
6087    non-zero stop signal.  */
6088
6089 char *
6090 remote_target::append_pending_thread_resumptions (char *p, char *endp,
6091                                                   ptid_t ptid)
6092 {
6093   for (thread_info *thread : all_non_exited_threads (ptid))
6094     if (inferior_ptid != thread->ptid
6095         && thread->suspend.stop_signal != GDB_SIGNAL_0)
6096       {
6097         p = append_resumption (p, endp, thread->ptid,
6098                                0, thread->suspend.stop_signal);
6099         thread->suspend.stop_signal = GDB_SIGNAL_0;
6100         resume_clear_thread_private_info (thread);
6101       }
6102
6103   return p;
6104 }
6105
6106 /* Set the target running, using the packets that use Hc
6107    (c/s/C/S).  */
6108
6109 void
6110 remote_target::remote_resume_with_hc (ptid_t ptid, int step,
6111                                       gdb_signal siggnal)
6112 {
6113   struct remote_state *rs = get_remote_state ();
6114   char *buf;
6115
6116   rs->last_sent_signal = siggnal;
6117   rs->last_sent_step = step;
6118
6119   /* The c/s/C/S resume packets use Hc, so set the continue
6120      thread.  */
6121   if (ptid == minus_one_ptid)
6122     set_continue_thread (any_thread_ptid);
6123   else
6124     set_continue_thread (ptid);
6125
6126   for (thread_info *thread : all_non_exited_threads ())
6127     resume_clear_thread_private_info (thread);
6128
6129   buf = rs->buf.data ();
6130   if (::execution_direction == EXEC_REVERSE)
6131     {
6132       /* We don't pass signals to the target in reverse exec mode.  */
6133       if (info_verbose && siggnal != GDB_SIGNAL_0)
6134         warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6135                  siggnal);
6136
6137       if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
6138         error (_("Remote reverse-step not supported."));
6139       if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
6140         error (_("Remote reverse-continue not supported."));
6141
6142       strcpy (buf, step ? "bs" : "bc");
6143     }
6144   else if (siggnal != GDB_SIGNAL_0)
6145     {
6146       buf[0] = step ? 'S' : 'C';
6147       buf[1] = tohex (((int) siggnal >> 4) & 0xf);
6148       buf[2] = tohex (((int) siggnal) & 0xf);
6149       buf[3] = '\0';
6150     }
6151   else
6152     strcpy (buf, step ? "s" : "c");
6153
6154   putpkt (buf);
6155 }
6156
6157 /* Resume the remote inferior by using a "vCont" packet.  The thread
6158    to be resumed is PTID; STEP and SIGGNAL indicate whether the
6159    resumed thread should be single-stepped and/or signalled.  If PTID
6160    equals minus_one_ptid, then all threads are resumed; the thread to
6161    be stepped and/or signalled is given in the global INFERIOR_PTID.
6162    This function returns non-zero iff it resumes the inferior.
6163
6164    This function issues a strict subset of all possible vCont commands
6165    at the moment.  */
6166
6167 int
6168 remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
6169                                          enum gdb_signal siggnal)
6170 {
6171   struct remote_state *rs = get_remote_state ();
6172   char *p;
6173   char *endp;
6174
6175   /* No reverse execution actions defined for vCont.  */
6176   if (::execution_direction == EXEC_REVERSE)
6177     return 0;
6178
6179   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6180     remote_vcont_probe ();
6181
6182   if (packet_support (PACKET_vCont) == PACKET_DISABLE)
6183     return 0;
6184
6185   p = rs->buf.data ();
6186   endp = p + get_remote_packet_size ();
6187
6188   /* If we could generate a wider range of packets, we'd have to worry
6189      about overflowing BUF.  Should there be a generic
6190      "multi-part-packet" packet?  */
6191
6192   p += xsnprintf (p, endp - p, "vCont");
6193
6194   if (ptid == magic_null_ptid)
6195     {
6196       /* MAGIC_NULL_PTID means that we don't have any active threads,
6197          so we don't have any TID numbers the inferior will
6198          understand.  Make sure to only send forms that do not specify
6199          a TID.  */
6200       append_resumption (p, endp, minus_one_ptid, step, siggnal);
6201     }
6202   else if (ptid == minus_one_ptid || ptid.is_pid ())
6203     {
6204       /* Resume all threads (of all processes, or of a single
6205          process), with preference for INFERIOR_PTID.  This assumes
6206          inferior_ptid belongs to the set of all threads we are about
6207          to resume.  */
6208       if (step || siggnal != GDB_SIGNAL_0)
6209         {
6210           /* Step inferior_ptid, with or without signal.  */
6211           p = append_resumption (p, endp, inferior_ptid, step, siggnal);
6212         }
6213
6214       /* Also pass down any pending signaled resumption for other
6215          threads not the current.  */
6216       p = append_pending_thread_resumptions (p, endp, ptid);
6217
6218       /* And continue others without a signal.  */
6219       append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
6220     }
6221   else
6222     {
6223       /* Scheduler locking; resume only PTID.  */
6224       append_resumption (p, endp, ptid, step, siggnal);
6225     }
6226
6227   gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ());
6228   putpkt (rs->buf);
6229
6230   if (target_is_non_stop_p ())
6231     {
6232       /* In non-stop, the stub replies to vCont with "OK".  The stop
6233          reply will be reported asynchronously by means of a `%Stop'
6234          notification.  */
6235       getpkt (&rs->buf, 0);
6236       if (strcmp (rs->buf.data (), "OK") != 0)
6237         error (_("Unexpected vCont reply in non-stop mode: %s"),
6238                rs->buf.data ());
6239     }
6240
6241   return 1;
6242 }
6243
6244 /* Tell the remote machine to resume.  */
6245
6246 void
6247 remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
6248 {
6249   struct remote_state *rs = get_remote_state ();
6250
6251   /* When connected in non-stop mode, the core resumes threads
6252      individually.  Resuming remote threads directly in target_resume
6253      would thus result in sending one packet per thread.  Instead, to
6254      minimize roundtrip latency, here we just store the resume
6255      request; the actual remote resumption will be done in
6256      target_commit_resume / remote_commit_resume, where we'll be able
6257      to do vCont action coalescing.  */
6258   if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
6259     {
6260       remote_thread_info *remote_thr;
6261
6262       if (minus_one_ptid == ptid || ptid.is_pid ())
6263         remote_thr = get_remote_thread_info (inferior_ptid);
6264       else
6265         remote_thr = get_remote_thread_info (ptid);
6266
6267       remote_thr->last_resume_step = step;
6268       remote_thr->last_resume_sig = siggnal;
6269       return;
6270     }
6271
6272   /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6273      (explained in remote-notif.c:handle_notification) so
6274      remote_notif_process is not called.  We need find a place where
6275      it is safe to start a 'vNotif' sequence.  It is good to do it
6276      before resuming inferior, because inferior was stopped and no RSP
6277      traffic at that moment.  */
6278   if (!target_is_non_stop_p ())
6279     remote_notif_process (rs->notif_state, &notif_client_stop);
6280
6281   rs->last_resume_exec_dir = ::execution_direction;
6282
6283   /* Prefer vCont, and fallback to s/c/S/C, which use Hc.  */
6284   if (!remote_resume_with_vcont (ptid, step, siggnal))
6285     remote_resume_with_hc (ptid, step, siggnal);
6286
6287   /* We are about to start executing the inferior, let's register it
6288      with the event loop.  NOTE: this is the one place where all the
6289      execution commands end up.  We could alternatively do this in each
6290      of the execution commands in infcmd.c.  */
6291   /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6292      into infcmd.c in order to allow inferior function calls to work
6293      NOT asynchronously.  */
6294   if (target_can_async_p ())
6295     target_async (1);
6296
6297   /* We've just told the target to resume.  The remote server will
6298      wait for the inferior to stop, and then send a stop reply.  In
6299      the mean time, we can't start another command/query ourselves
6300      because the stub wouldn't be ready to process it.  This applies
6301      only to the base all-stop protocol, however.  In non-stop (which
6302      only supports vCont), the stub replies with an "OK", and is
6303      immediate able to process further serial input.  */
6304   if (!target_is_non_stop_p ())
6305     rs->waiting_for_stop_reply = 1;
6306 }
6307
6308 static int is_pending_fork_parent_thread (struct thread_info *thread);
6309
6310 /* Private per-inferior info for target remote processes.  */
6311
6312 struct remote_inferior : public private_inferior
6313 {
6314   /* Whether we can send a wildcard vCont for this process.  */
6315   bool may_wildcard_vcont = true;
6316 };
6317
6318 /* Get the remote private inferior data associated to INF.  */
6319
6320 static remote_inferior *
6321 get_remote_inferior (inferior *inf)
6322 {
6323   if (inf->priv == NULL)
6324     inf->priv.reset (new remote_inferior);
6325
6326   return static_cast<remote_inferior *> (inf->priv.get ());
6327 }
6328
6329 /* Class used to track the construction of a vCont packet in the
6330    outgoing packet buffer.  This is used to send multiple vCont
6331    packets if we have more actions than would fit a single packet.  */
6332
6333 class vcont_builder
6334 {
6335 public:
6336   explicit vcont_builder (remote_target *remote)
6337     : m_remote (remote)
6338   {
6339     restart ();
6340   }
6341
6342   void flush ();
6343   void push_action (ptid_t ptid, bool step, gdb_signal siggnal);
6344
6345 private:
6346   void restart ();
6347
6348   /* The remote target.  */
6349   remote_target *m_remote;
6350
6351   /* Pointer to the first action.  P points here if no action has been
6352      appended yet.  */
6353   char *m_first_action;
6354
6355   /* Where the next action will be appended.  */
6356   char *m_p;
6357
6358   /* The end of the buffer.  Must never write past this.  */
6359   char *m_endp;
6360 };
6361
6362 /* Prepare the outgoing buffer for a new vCont packet.  */
6363
6364 void
6365 vcont_builder::restart ()
6366 {
6367   struct remote_state *rs = m_remote->get_remote_state ();
6368
6369   m_p = rs->buf.data ();
6370   m_endp = m_p + m_remote->get_remote_packet_size ();
6371   m_p += xsnprintf (m_p, m_endp - m_p, "vCont");
6372   m_first_action = m_p;
6373 }
6374
6375 /* If the vCont packet being built has any action, send it to the
6376    remote end.  */
6377
6378 void
6379 vcont_builder::flush ()
6380 {
6381   struct remote_state *rs;
6382
6383   if (m_p == m_first_action)
6384     return;
6385
6386   rs = m_remote->get_remote_state ();
6387   m_remote->putpkt (rs->buf);
6388   m_remote->getpkt (&rs->buf, 0);
6389   if (strcmp (rs->buf.data (), "OK") != 0)
6390     error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ());
6391 }
6392
6393 /* The largest action is range-stepping, with its two addresses.  This
6394    is more than sufficient.  If a new, bigger action is created, it'll
6395    quickly trigger a failed assertion in append_resumption (and we'll
6396    just bump this).  */
6397 #define MAX_ACTION_SIZE 200
6398
6399 /* Append a new vCont action in the outgoing packet being built.  If
6400    the action doesn't fit the packet along with previous actions, push
6401    what we've got so far to the remote end and start over a new vCont
6402    packet (with the new action).  */
6403
6404 void
6405 vcont_builder::push_action (ptid_t ptid, bool step, gdb_signal siggnal)
6406 {
6407   char buf[MAX_ACTION_SIZE + 1];
6408
6409   char *endp = m_remote->append_resumption (buf, buf + sizeof (buf),
6410                                             ptid, step, siggnal);
6411
6412   /* Check whether this new action would fit in the vCont packet along
6413      with previous actions.  If not, send what we've got so far and
6414      start a new vCont packet.  */
6415   size_t rsize = endp - buf;
6416   if (rsize > m_endp - m_p)
6417     {
6418       flush ();
6419       restart ();
6420
6421       /* Should now fit.  */
6422       gdb_assert (rsize <= m_endp - m_p);
6423     }
6424
6425   memcpy (m_p, buf, rsize);
6426   m_p += rsize;
6427   *m_p = '\0';
6428 }
6429
6430 /* to_commit_resume implementation.  */
6431
6432 void
6433 remote_target::commit_resume ()
6434 {
6435   int any_process_wildcard;
6436   int may_global_wildcard_vcont;
6437
6438   /* If connected in all-stop mode, we'd send the remote resume
6439      request directly from remote_resume.  Likewise if
6440      reverse-debugging, as there are no defined vCont actions for
6441      reverse execution.  */
6442   if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE)
6443     return;
6444
6445   /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6446      instead of resuming all threads of each process individually.
6447      However, if any thread of a process must remain halted, we can't
6448      send wildcard resumes and must send one action per thread.
6449
6450      Care must be taken to not resume threads/processes the server
6451      side already told us are stopped, but the core doesn't know about
6452      yet, because the events are still in the vStopped notification
6453      queue.  For example:
6454
6455        #1 => vCont s:p1.1;c
6456        #2 <= OK
6457        #3 <= %Stopped T05 p1.1
6458        #4 => vStopped
6459        #5 <= T05 p1.2
6460        #6 => vStopped
6461        #7 <= OK
6462        #8 (infrun handles the stop for p1.1 and continues stepping)
6463        #9 => vCont s:p1.1;c
6464
6465      The last vCont above would resume thread p1.2 by mistake, because
6466      the server has no idea that the event for p1.2 had not been
6467      handled yet.
6468
6469      The server side must similarly ignore resume actions for the
6470      thread that has a pending %Stopped notification (and any other
6471      threads with events pending), until GDB acks the notification
6472      with vStopped.  Otherwise, e.g., the following case is
6473      mishandled:
6474
6475        #1 => g  (or any other packet)
6476        #2 <= [registers]
6477        #3 <= %Stopped T05 p1.2
6478        #4 => vCont s:p1.1;c
6479        #5 <= OK
6480
6481      Above, the server must not resume thread p1.2.  GDB can't know
6482      that p1.2 stopped until it acks the %Stopped notification, and
6483      since from GDB's perspective all threads should be running, it
6484      sends a "c" action.
6485
6486      Finally, special care must also be given to handling fork/vfork
6487      events.  A (v)fork event actually tells us that two processes
6488      stopped -- the parent and the child.  Until we follow the fork,
6489      we must not resume the child.  Therefore, if we have a pending
6490      fork follow, we must not send a global wildcard resume action
6491      (vCont;c).  We can still send process-wide wildcards though.  */
6492
6493   /* Start by assuming a global wildcard (vCont;c) is possible.  */
6494   may_global_wildcard_vcont = 1;
6495
6496   /* And assume every process is individually wildcard-able too.  */
6497   for (inferior *inf : all_non_exited_inferiors ())
6498     {
6499       remote_inferior *priv = get_remote_inferior (inf);
6500
6501       priv->may_wildcard_vcont = true;
6502     }
6503
6504   /* Check for any pending events (not reported or processed yet) and
6505      disable process and global wildcard resumes appropriately.  */
6506   check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
6507
6508   for (thread_info *tp : all_non_exited_threads ())
6509     {
6510       /* If a thread of a process is not meant to be resumed, then we
6511          can't wildcard that process.  */
6512       if (!tp->executing)
6513         {
6514           get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
6515
6516           /* And if we can't wildcard a process, we can't wildcard
6517              everything either.  */
6518           may_global_wildcard_vcont = 0;
6519           continue;
6520         }
6521
6522       /* If a thread is the parent of an unfollowed fork, then we
6523          can't do a global wildcard, as that would resume the fork
6524          child.  */
6525       if (is_pending_fork_parent_thread (tp))
6526         may_global_wildcard_vcont = 0;
6527     }
6528
6529   /* Now let's build the vCont packet(s).  Actions must be appended
6530      from narrower to wider scopes (thread -> process -> global).  If
6531      we end up with too many actions for a single packet vcont_builder
6532      flushes the current vCont packet to the remote side and starts a
6533      new one.  */
6534   struct vcont_builder vcont_builder (this);
6535
6536   /* Threads first.  */
6537   for (thread_info *tp : all_non_exited_threads ())
6538     {
6539       remote_thread_info *remote_thr = get_remote_thread_info (tp);
6540
6541       if (!tp->executing || remote_thr->vcont_resumed)
6542         continue;
6543
6544       gdb_assert (!thread_is_in_step_over_chain (tp));
6545
6546       if (!remote_thr->last_resume_step
6547           && remote_thr->last_resume_sig == GDB_SIGNAL_0
6548           && get_remote_inferior (tp->inf)->may_wildcard_vcont)
6549         {
6550           /* We'll send a wildcard resume instead.  */
6551           remote_thr->vcont_resumed = 1;
6552           continue;
6553         }
6554
6555       vcont_builder.push_action (tp->ptid,
6556                                  remote_thr->last_resume_step,
6557                                  remote_thr->last_resume_sig);
6558       remote_thr->vcont_resumed = 1;
6559     }
6560
6561   /* Now check whether we can send any process-wide wildcard.  This is
6562      to avoid sending a global wildcard in the case nothing is
6563      supposed to be resumed.  */
6564   any_process_wildcard = 0;
6565
6566   for (inferior *inf : all_non_exited_inferiors ())
6567     {
6568       if (get_remote_inferior (inf)->may_wildcard_vcont)
6569         {
6570           any_process_wildcard = 1;
6571           break;
6572         }
6573     }
6574
6575   if (any_process_wildcard)
6576     {
6577       /* If all processes are wildcard-able, then send a single "c"
6578          action, otherwise, send an "all (-1) threads of process"
6579          continue action for each running process, if any.  */
6580       if (may_global_wildcard_vcont)
6581         {
6582           vcont_builder.push_action (minus_one_ptid,
6583                                      false, GDB_SIGNAL_0);
6584         }
6585       else
6586         {
6587           for (inferior *inf : all_non_exited_inferiors ())
6588             {
6589               if (get_remote_inferior (inf)->may_wildcard_vcont)
6590                 {
6591                   vcont_builder.push_action (ptid_t (inf->pid),
6592                                              false, GDB_SIGNAL_0);
6593                 }
6594             }
6595         }
6596     }
6597
6598   vcont_builder.flush ();
6599 }
6600
6601 \f
6602
6603 /* Non-stop version of target_stop.  Uses `vCont;t' to stop a remote
6604    thread, all threads of a remote process, or all threads of all
6605    processes.  */
6606
6607 void
6608 remote_target::remote_stop_ns (ptid_t ptid)
6609 {
6610   struct remote_state *rs = get_remote_state ();
6611   char *p = rs->buf.data ();
6612   char *endp = p + get_remote_packet_size ();
6613
6614   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6615     remote_vcont_probe ();
6616
6617   if (!rs->supports_vCont.t)
6618     error (_("Remote server does not support stopping threads"));
6619
6620   if (ptid == minus_one_ptid
6621       || (!remote_multi_process_p (rs) && ptid.is_pid ()))
6622     p += xsnprintf (p, endp - p, "vCont;t");
6623   else
6624     {
6625       ptid_t nptid;
6626
6627       p += xsnprintf (p, endp - p, "vCont;t:");
6628
6629       if (ptid.is_pid ())
6630           /* All (-1) threads of process.  */
6631         nptid = ptid_t (ptid.pid (), -1, 0);
6632       else
6633         {
6634           /* Small optimization: if we already have a stop reply for
6635              this thread, no use in telling the stub we want this
6636              stopped.  */
6637           if (peek_stop_reply (ptid))
6638             return;
6639
6640           nptid = ptid;
6641         }
6642
6643       write_ptid (p, endp, nptid);
6644     }
6645
6646   /* In non-stop, we get an immediate OK reply.  The stop reply will
6647      come in asynchronously by notification.  */
6648   putpkt (rs->buf);
6649   getpkt (&rs->buf, 0);
6650   if (strcmp (rs->buf.data (), "OK") != 0)
6651     error (_("Stopping %s failed: %s"), target_pid_to_str (ptid),
6652            rs->buf.data ());
6653 }
6654
6655 /* All-stop version of target_interrupt.  Sends a break or a ^C to
6656    interrupt the remote target.  It is undefined which thread of which
6657    process reports the interrupt.  */
6658
6659 void
6660 remote_target::remote_interrupt_as ()
6661 {
6662   struct remote_state *rs = get_remote_state ();
6663
6664   rs->ctrlc_pending_p = 1;
6665
6666   /* If the inferior is stopped already, but the core didn't know
6667      about it yet, just ignore the request.  The cached wait status
6668      will be collected in remote_wait.  */
6669   if (rs->cached_wait_status)
6670     return;
6671
6672   /* Send interrupt_sequence to remote target.  */
6673   send_interrupt_sequence ();
6674 }
6675
6676 /* Non-stop version of target_interrupt.  Uses `vCtrlC' to interrupt
6677    the remote target.  It is undefined which thread of which process
6678    reports the interrupt.  Throws an error if the packet is not
6679    supported by the server.  */
6680
6681 void
6682 remote_target::remote_interrupt_ns ()
6683 {
6684   struct remote_state *rs = get_remote_state ();
6685   char *p = rs->buf.data ();
6686   char *endp = p + get_remote_packet_size ();
6687
6688   xsnprintf (p, endp - p, "vCtrlC");
6689
6690   /* In non-stop, we get an immediate OK reply.  The stop reply will
6691      come in asynchronously by notification.  */
6692   putpkt (rs->buf);
6693   getpkt (&rs->buf, 0);
6694
6695   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
6696     {
6697     case PACKET_OK:
6698       break;
6699     case PACKET_UNKNOWN:
6700       error (_("No support for interrupting the remote target."));
6701     case PACKET_ERROR:
6702       error (_("Interrupting target failed: %s"), rs->buf.data ());
6703     }
6704 }
6705
6706 /* Implement the to_stop function for the remote targets.  */
6707
6708 void
6709 remote_target::stop (ptid_t ptid)
6710 {
6711   if (remote_debug)
6712     fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
6713
6714   if (target_is_non_stop_p ())
6715     remote_stop_ns (ptid);
6716   else
6717     {
6718       /* We don't currently have a way to transparently pause the
6719          remote target in all-stop mode.  Interrupt it instead.  */
6720       remote_interrupt_as ();
6721     }
6722 }
6723
6724 /* Implement the to_interrupt function for the remote targets.  */
6725
6726 void
6727 remote_target::interrupt ()
6728 {
6729   if (remote_debug)
6730     fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
6731
6732   if (target_is_non_stop_p ())
6733     remote_interrupt_ns ();
6734   else
6735     remote_interrupt_as ();
6736 }
6737
6738 /* Implement the to_pass_ctrlc function for the remote targets.  */
6739
6740 void
6741 remote_target::pass_ctrlc ()
6742 {
6743   struct remote_state *rs = get_remote_state ();
6744
6745   if (remote_debug)
6746     fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
6747
6748   /* If we're starting up, we're not fully synced yet.  Quit
6749      immediately.  */
6750   if (rs->starting_up)
6751     quit ();
6752   /* If ^C has already been sent once, offer to disconnect.  */
6753   else if (rs->ctrlc_pending_p)
6754     interrupt_query ();
6755   else
6756     target_interrupt ();
6757 }
6758
6759 /* Ask the user what to do when an interrupt is received.  */
6760
6761 void
6762 remote_target::interrupt_query ()
6763 {
6764   struct remote_state *rs = get_remote_state ();
6765
6766   if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p)
6767     {
6768       if (query (_("The target is not responding to interrupt requests.\n"
6769                    "Stop debugging it? ")))
6770         {
6771           remote_unpush_target ();
6772           throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
6773         }
6774     }
6775   else
6776     {
6777       if (query (_("Interrupted while waiting for the program.\n"
6778                    "Give up waiting? ")))
6779         quit ();
6780     }
6781 }
6782
6783 /* Enable/disable target terminal ownership.  Most targets can use
6784    terminal groups to control terminal ownership.  Remote targets are
6785    different in that explicit transfer of ownership to/from GDB/target
6786    is required.  */
6787
6788 void
6789 remote_target::terminal_inferior ()
6790 {
6791   /* NOTE: At this point we could also register our selves as the
6792      recipient of all input.  Any characters typed could then be
6793      passed on down to the target.  */
6794 }
6795
6796 void
6797 remote_target::terminal_ours ()
6798 {
6799 }
6800
6801 static void
6802 remote_console_output (const char *msg)
6803 {
6804   const char *p;
6805
6806   for (p = msg; p[0] && p[1]; p += 2)
6807     {
6808       char tb[2];
6809       char c = fromhex (p[0]) * 16 + fromhex (p[1]);
6810
6811       tb[0] = c;
6812       tb[1] = 0;
6813       fputs_unfiltered (tb, gdb_stdtarg);
6814     }
6815   gdb_flush (gdb_stdtarg);
6816 }
6817
6818 DEF_VEC_O(cached_reg_t);
6819
6820 typedef struct stop_reply
6821 {
6822   struct notif_event base;
6823
6824   /* The identifier of the thread about this event  */
6825   ptid_t ptid;
6826
6827   /* The remote state this event is associated with.  When the remote
6828      connection, represented by a remote_state object, is closed,
6829      all the associated stop_reply events should be released.  */
6830   struct remote_state *rs;
6831
6832   struct target_waitstatus ws;
6833
6834   /* The architecture associated with the expedited registers.  */
6835   gdbarch *arch;
6836
6837   /* Expedited registers.  This makes remote debugging a bit more
6838      efficient for those targets that provide critical registers as
6839      part of their normal status mechanism (as another roundtrip to
6840      fetch them is avoided).  */
6841   VEC(cached_reg_t) *regcache;
6842
6843   enum target_stop_reason stop_reason;
6844
6845   CORE_ADDR watch_data_address;
6846
6847   int core;
6848 } *stop_reply_p;
6849
6850 static void
6851 stop_reply_xfree (struct stop_reply *r)
6852 {
6853   notif_event_xfree ((struct notif_event *) r);
6854 }
6855
6856 /* Return the length of the stop reply queue.  */
6857
6858 int
6859 remote_target::stop_reply_queue_length ()
6860 {
6861   remote_state *rs = get_remote_state ();
6862   return rs->stop_reply_queue.size ();
6863 }
6864
6865 void
6866 remote_notif_stop_parse (remote_target *remote,
6867                          struct notif_client *self, const char *buf,
6868                          struct notif_event *event)
6869 {
6870   remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
6871 }
6872
6873 static void
6874 remote_notif_stop_ack (remote_target *remote,
6875                        struct notif_client *self, const char *buf,
6876                        struct notif_event *event)
6877 {
6878   struct stop_reply *stop_reply = (struct stop_reply *) event;
6879
6880   /* acknowledge */
6881   putpkt (remote, self->ack_command);
6882
6883   if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
6884     {
6885       /* We got an unknown stop reply.  */
6886       error (_("Unknown stop reply"));
6887     }
6888
6889   remote->push_stop_reply (stop_reply);
6890 }
6891
6892 static int
6893 remote_notif_stop_can_get_pending_events (remote_target *remote,
6894                                           struct notif_client *self)
6895 {
6896   /* We can't get pending events in remote_notif_process for
6897      notification stop, and we have to do this in remote_wait_ns
6898      instead.  If we fetch all queued events from stub, remote stub
6899      may exit and we have no chance to process them back in
6900      remote_wait_ns.  */
6901   remote_state *rs = remote->get_remote_state ();
6902   mark_async_event_handler (rs->remote_async_inferior_event_token);
6903   return 0;
6904 }
6905
6906 static void
6907 stop_reply_dtr (struct notif_event *event)
6908 {
6909   struct stop_reply *r = (struct stop_reply *) event;
6910   cached_reg_t *reg;
6911   int ix;
6912
6913   for (ix = 0;
6914        VEC_iterate (cached_reg_t, r->regcache, ix, reg);
6915        ix++)
6916     xfree (reg->data);
6917
6918   VEC_free (cached_reg_t, r->regcache);
6919 }
6920
6921 static struct notif_event *
6922 remote_notif_stop_alloc_reply (void)
6923 {
6924   /* We cast to a pointer to the "base class".  */
6925   struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply);
6926
6927   r->dtr = stop_reply_dtr;
6928
6929   return r;
6930 }
6931
6932 /* A client of notification Stop.  */
6933
6934 struct notif_client notif_client_stop =
6935 {
6936   "Stop",
6937   "vStopped",
6938   remote_notif_stop_parse,
6939   remote_notif_stop_ack,
6940   remote_notif_stop_can_get_pending_events,
6941   remote_notif_stop_alloc_reply,
6942   REMOTE_NOTIF_STOP,
6943 };
6944
6945 /* Determine if THREAD_PTID is a pending fork parent thread.  ARG contains
6946    the pid of the process that owns the threads we want to check, or
6947    -1 if we want to check all threads.  */
6948
6949 static int
6950 is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
6951                         ptid_t thread_ptid)
6952 {
6953   if (ws->kind == TARGET_WAITKIND_FORKED
6954       || ws->kind == TARGET_WAITKIND_VFORKED)
6955     {
6956       if (event_pid == -1 || event_pid == thread_ptid.pid ())
6957         return 1;
6958     }
6959
6960   return 0;
6961 }
6962
6963 /* Return the thread's pending status used to determine whether the
6964    thread is a fork parent stopped at a fork event.  */
6965
6966 static struct target_waitstatus *
6967 thread_pending_fork_status (struct thread_info *thread)
6968 {
6969   if (thread->suspend.waitstatus_pending_p)
6970     return &thread->suspend.waitstatus;
6971   else
6972     return &thread->pending_follow;
6973 }
6974
6975 /* Determine if THREAD is a pending fork parent thread.  */
6976
6977 static int
6978 is_pending_fork_parent_thread (struct thread_info *thread)
6979 {
6980   struct target_waitstatus *ws = thread_pending_fork_status (thread);
6981   int pid = -1;
6982
6983   return is_pending_fork_parent (ws, pid, thread->ptid);
6984 }
6985
6986 /* If CONTEXT contains any fork child threads that have not been
6987    reported yet, remove them from the CONTEXT list.  If such a
6988    thread exists it is because we are stopped at a fork catchpoint
6989    and have not yet called follow_fork, which will set up the
6990    host-side data structures for the new process.  */
6991
6992 void
6993 remote_target::remove_new_fork_children (threads_listing_context *context)
6994 {
6995   int pid = -1;
6996   struct notif_client *notif = &notif_client_stop;
6997
6998   /* For any threads stopped at a fork event, remove the corresponding
6999      fork child threads from the CONTEXT list.  */
7000   for (thread_info *thread : all_non_exited_threads ())
7001     {
7002       struct target_waitstatus *ws = thread_pending_fork_status (thread);
7003
7004       if (is_pending_fork_parent (ws, pid, thread->ptid))
7005         context->remove_thread (ws->value.related_pid);
7006     }
7007
7008   /* Check for any pending fork events (not reported or processed yet)
7009      in process PID and remove those fork child threads from the
7010      CONTEXT list as well.  */
7011   remote_notif_get_pending_events (notif);
7012   for (auto &event : get_remote_state ()->stop_reply_queue)
7013     if (event->ws.kind == TARGET_WAITKIND_FORKED
7014         || event->ws.kind == TARGET_WAITKIND_VFORKED
7015         || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
7016       context->remove_thread (event->ws.value.related_pid);
7017 }
7018
7019 /* Check whether any event pending in the vStopped queue would prevent
7020    a global or process wildcard vCont action.  Clear
7021    *may_global_wildcard if we can't do a global wildcard (vCont;c),
7022    and clear the event inferior's may_wildcard_vcont flag if we can't
7023    do a process-wide wildcard resume (vCont;c:pPID.-1).  */
7024
7025 void
7026 remote_target::check_pending_events_prevent_wildcard_vcont
7027   (int *may_global_wildcard)
7028 {
7029   struct notif_client *notif = &notif_client_stop;
7030
7031   remote_notif_get_pending_events (notif);
7032   for (auto &event : get_remote_state ()->stop_reply_queue)
7033     {
7034       if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
7035           || event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
7036         continue;
7037
7038       if (event->ws.kind == TARGET_WAITKIND_FORKED
7039           || event->ws.kind == TARGET_WAITKIND_VFORKED)
7040         *may_global_wildcard = 0;
7041
7042       struct inferior *inf = find_inferior_ptid (event->ptid);
7043
7044       /* This may be the first time we heard about this process.
7045          Regardless, we must not do a global wildcard resume, otherwise
7046          we'd resume this process too.  */
7047       *may_global_wildcard = 0;
7048       if (inf != NULL)
7049         get_remote_inferior (inf)->may_wildcard_vcont = false;
7050     }
7051 }
7052
7053 /* Discard all pending stop replies of inferior INF.  */
7054
7055 void
7056 remote_target::discard_pending_stop_replies (struct inferior *inf)
7057 {
7058   struct stop_reply *reply;
7059   struct remote_state *rs = get_remote_state ();
7060   struct remote_notif_state *rns = rs->notif_state;
7061
7062   /* This function can be notified when an inferior exists.  When the
7063      target is not remote, the notification state is NULL.  */
7064   if (rs->remote_desc == NULL)
7065     return;
7066
7067   reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];
7068
7069   /* Discard the in-flight notification.  */
7070   if (reply != NULL && reply->ptid.pid () == inf->pid)
7071     {
7072       stop_reply_xfree (reply);
7073       rns->pending_event[notif_client_stop.id] = NULL;
7074     }
7075
7076   /* Discard the stop replies we have already pulled with
7077      vStopped.  */
7078   auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7079                               rs->stop_reply_queue.end (),
7080                               [=] (const stop_reply_up &event)
7081                               {
7082                                 return event->ptid.pid () == inf->pid;
7083                               });
7084   rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7085 }
7086
7087 /* Discard the stop replies for RS in stop_reply_queue.  */
7088
7089 void
7090 remote_target::discard_pending_stop_replies_in_queue ()
7091 {
7092   remote_state *rs = get_remote_state ();
7093
7094   /* Discard the stop replies we have already pulled with
7095      vStopped.  */
7096   auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7097                               rs->stop_reply_queue.end (),
7098                               [=] (const stop_reply_up &event)
7099                               {
7100                                 return event->rs == rs;
7101                               });
7102   rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7103 }
7104
7105 /* Remove the first reply in 'stop_reply_queue' which matches
7106    PTID.  */
7107
7108 struct stop_reply *
7109 remote_target::remote_notif_remove_queued_reply (ptid_t ptid)
7110 {
7111   remote_state *rs = get_remote_state ();
7112
7113   auto iter = std::find_if (rs->stop_reply_queue.begin (),
7114                             rs->stop_reply_queue.end (),
7115                             [=] (const stop_reply_up &event)
7116                             {
7117                               return event->ptid.matches (ptid);
7118                             });
7119   struct stop_reply *result;
7120   if (iter == rs->stop_reply_queue.end ())
7121     result = nullptr;
7122   else
7123     {
7124       result = iter->release ();
7125       rs->stop_reply_queue.erase (iter);
7126     }
7127
7128   if (notif_debug)
7129     fprintf_unfiltered (gdb_stdlog,
7130                         "notif: discard queued event: 'Stop' in %s\n",
7131                         target_pid_to_str (ptid));
7132
7133   return result;
7134 }
7135
7136 /* Look for a queued stop reply belonging to PTID.  If one is found,
7137    remove it from the queue, and return it.  Returns NULL if none is
7138    found.  If there are still queued events left to process, tell the
7139    event loop to get back to target_wait soon.  */
7140
7141 struct stop_reply *
7142 remote_target::queued_stop_reply (ptid_t ptid)
7143 {
7144   remote_state *rs = get_remote_state ();
7145   struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
7146
7147   if (!rs->stop_reply_queue.empty ())
7148     {
7149       /* There's still at least an event left.  */
7150       mark_async_event_handler (rs->remote_async_inferior_event_token);
7151     }
7152
7153   return r;
7154 }
7155
7156 /* Push a fully parsed stop reply in the stop reply queue.  Since we
7157    know that we now have at least one queued event left to pass to the
7158    core side, tell the event loop to get back to target_wait soon.  */
7159
7160 void
7161 remote_target::push_stop_reply (struct stop_reply *new_event)
7162 {
7163   remote_state *rs = get_remote_state ();
7164   rs->stop_reply_queue.push_back (stop_reply_up (new_event));
7165
7166   if (notif_debug)
7167     fprintf_unfiltered (gdb_stdlog,
7168                         "notif: push 'Stop' %s to queue %d\n",
7169                         target_pid_to_str (new_event->ptid),
7170                         int (rs->stop_reply_queue.size ()));
7171
7172   mark_async_event_handler (rs->remote_async_inferior_event_token);
7173 }
7174
7175 /* Returns true if we have a stop reply for PTID.  */
7176
7177 int
7178 remote_target::peek_stop_reply (ptid_t ptid)
7179 {
7180   remote_state *rs = get_remote_state ();
7181   for (auto &event : rs->stop_reply_queue)
7182     if (ptid == event->ptid
7183         && event->ws.kind == TARGET_WAITKIND_STOPPED)
7184       return 1;
7185   return 0;
7186 }
7187
7188 /* Helper for remote_parse_stop_reply.  Return nonzero if the substring
7189    starting with P and ending with PEND matches PREFIX.  */
7190
7191 static int
7192 strprefix (const char *p, const char *pend, const char *prefix)
7193 {
7194   for ( ; p < pend; p++, prefix++)
7195     if (*p != *prefix)
7196       return 0;
7197   return *prefix == '\0';
7198 }
7199
7200 /* Parse the stop reply in BUF.  Either the function succeeds, and the
7201    result is stored in EVENT, or throws an error.  */
7202
7203 void
7204 remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event)
7205 {
7206   remote_arch_state *rsa = NULL;
7207   ULONGEST addr;
7208   const char *p;
7209   int skipregs = 0;
7210
7211   event->ptid = null_ptid;
7212   event->rs = get_remote_state ();
7213   event->ws.kind = TARGET_WAITKIND_IGNORE;
7214   event->ws.value.integer = 0;
7215   event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
7216   event->regcache = NULL;
7217   event->core = -1;
7218
7219   switch (buf[0])
7220     {
7221     case 'T':           /* Status with PC, SP, FP, ...  */
7222       /* Expedited reply, containing Signal, {regno, reg} repeat.  */
7223       /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
7224             ss = signal number
7225             n... = register number
7226             r... = register contents
7227       */
7228
7229       p = &buf[3];      /* after Txx */
7230       while (*p)
7231         {
7232           const char *p1;
7233           int fieldsize;
7234
7235           p1 = strchr (p, ':');
7236           if (p1 == NULL)
7237             error (_("Malformed packet(a) (missing colon): %s\n\
7238 Packet: '%s'\n"),
7239                    p, buf);
7240           if (p == p1)
7241             error (_("Malformed packet(a) (missing register number): %s\n\
7242 Packet: '%s'\n"),
7243                    p, buf);
7244
7245           /* Some "registers" are actually extended stop information.
7246              Note if you're adding a new entry here: GDB 7.9 and
7247              earlier assume that all register "numbers" that start
7248              with an hex digit are real register numbers.  Make sure
7249              the server only sends such a packet if it knows the
7250              client understands it.  */
7251
7252           if (strprefix (p, p1, "thread"))
7253             event->ptid = read_ptid (++p1, &p);
7254           else if (strprefix (p, p1, "syscall_entry"))
7255             {
7256               ULONGEST sysno;
7257
7258               event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY;
7259               p = unpack_varlen_hex (++p1, &sysno);
7260               event->ws.value.syscall_number = (int) sysno;
7261             }
7262           else if (strprefix (p, p1, "syscall_return"))
7263             {
7264               ULONGEST sysno;
7265
7266               event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN;
7267               p = unpack_varlen_hex (++p1, &sysno);
7268               event->ws.value.syscall_number = (int) sysno;
7269             }
7270           else if (strprefix (p, p1, "watch")
7271                    || strprefix (p, p1, "rwatch")
7272                    || strprefix (p, p1, "awatch"))
7273             {
7274               event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
7275               p = unpack_varlen_hex (++p1, &addr);
7276               event->watch_data_address = (CORE_ADDR) addr;
7277             }
7278           else if (strprefix (p, p1, "swbreak"))
7279             {
7280               event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
7281
7282               /* Make sure the stub doesn't forget to indicate support
7283                  with qSupported.  */
7284               if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
7285                 error (_("Unexpected swbreak stop reason"));
7286
7287               /* The value part is documented as "must be empty",
7288                  though we ignore it, in case we ever decide to make
7289                  use of it in a backward compatible way.  */
7290               p = strchrnul (p1 + 1, ';');
7291             }
7292           else if (strprefix (p, p1, "hwbreak"))
7293             {
7294               event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
7295
7296               /* Make sure the stub doesn't forget to indicate support
7297                  with qSupported.  */
7298               if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
7299                 error (_("Unexpected hwbreak stop reason"));
7300
7301               /* See above.  */
7302               p = strchrnul (p1 + 1, ';');
7303             }
7304           else if (strprefix (p, p1, "library"))
7305             {
7306               event->ws.kind = TARGET_WAITKIND_LOADED;
7307               p = strchrnul (p1 + 1, ';');
7308             }
7309           else if (strprefix (p, p1, "replaylog"))
7310             {
7311               event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
7312               /* p1 will indicate "begin" or "end", but it makes
7313                  no difference for now, so ignore it.  */
7314               p = strchrnul (p1 + 1, ';');
7315             }
7316           else if (strprefix (p, p1, "core"))
7317             {
7318               ULONGEST c;
7319
7320               p = unpack_varlen_hex (++p1, &c);
7321               event->core = c;
7322             }
7323           else if (strprefix (p, p1, "fork"))
7324             {
7325               event->ws.value.related_pid = read_ptid (++p1, &p);
7326               event->ws.kind = TARGET_WAITKIND_FORKED;
7327             }
7328           else if (strprefix (p, p1, "vfork"))
7329             {
7330               event->ws.value.related_pid = read_ptid (++p1, &p);
7331               event->ws.kind = TARGET_WAITKIND_VFORKED;
7332             }
7333           else if (strprefix (p, p1, "vforkdone"))
7334             {
7335               event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
7336               p = strchrnul (p1 + 1, ';');
7337             }
7338           else if (strprefix (p, p1, "exec"))
7339             {
7340               ULONGEST ignored;
7341               int pathlen;
7342
7343               /* Determine the length of the execd pathname.  */
7344               p = unpack_varlen_hex (++p1, &ignored);
7345               pathlen = (p - p1) / 2;
7346
7347               /* Save the pathname for event reporting and for
7348                  the next run command.  */
7349               char *pathname = (char *) xmalloc (pathlen + 1);
7350               struct cleanup *old_chain = make_cleanup (xfree, pathname);
7351               hex2bin (p1, (gdb_byte *) pathname, pathlen);
7352               pathname[pathlen] = '\0';
7353               discard_cleanups (old_chain);
7354
7355               /* This is freed during event handling.  */
7356               event->ws.value.execd_pathname = pathname;
7357               event->ws.kind = TARGET_WAITKIND_EXECD;
7358
7359               /* Skip the registers included in this packet, since
7360                  they may be for an architecture different from the
7361                  one used by the original program.  */
7362               skipregs = 1;
7363             }
7364           else if (strprefix (p, p1, "create"))
7365             {
7366               event->ws.kind = TARGET_WAITKIND_THREAD_CREATED;
7367               p = strchrnul (p1 + 1, ';');
7368             }
7369           else
7370             {
7371               ULONGEST pnum;
7372               const char *p_temp;
7373
7374               if (skipregs)
7375                 {
7376                   p = strchrnul (p1 + 1, ';');
7377                   p++;
7378                   continue;
7379                 }
7380
7381               /* Maybe a real ``P'' register number.  */
7382               p_temp = unpack_varlen_hex (p, &pnum);
7383               /* If the first invalid character is the colon, we got a
7384                  register number.  Otherwise, it's an unknown stop
7385                  reason.  */
7386               if (p_temp == p1)
7387                 {
7388                   /* If we haven't parsed the event's thread yet, find
7389                      it now, in order to find the architecture of the
7390                      reported expedited registers.  */
7391                   if (event->ptid == null_ptid)
7392                     {
7393                       const char *thr = strstr (p1 + 1, ";thread:");
7394                       if (thr != NULL)
7395                         event->ptid = read_ptid (thr + strlen (";thread:"),
7396                                                  NULL);
7397                       else
7398                         {
7399                           /* Either the current thread hasn't changed,
7400                              or the inferior is not multi-threaded.
7401                              The event must be for the thread we last
7402                              set as (or learned as being) current.  */
7403                           event->ptid = event->rs->general_thread;
7404                         }
7405                     }
7406
7407                   if (rsa == NULL)
7408                     {
7409                       inferior *inf = (event->ptid == null_ptid
7410                                        ? NULL
7411                                        : find_inferior_ptid (event->ptid));
7412                       /* If this is the first time we learn anything
7413                          about this process, skip the registers
7414                          included in this packet, since we don't yet
7415                          know which architecture to use to parse them.
7416                          We'll determine the architecture later when
7417                          we process the stop reply and retrieve the
7418                          target description, via
7419                          remote_notice_new_inferior ->
7420                          post_create_inferior.  */
7421                       if (inf == NULL)
7422                         {
7423                           p = strchrnul (p1 + 1, ';');
7424                           p++;
7425                           continue;
7426                         }
7427
7428                       event->arch = inf->gdbarch;
7429                       rsa = event->rs->get_remote_arch_state (event->arch);
7430                     }
7431
7432                   packet_reg *reg
7433                     = packet_reg_from_pnum (event->arch, rsa, pnum);
7434                   cached_reg_t cached_reg;
7435
7436                   if (reg == NULL)
7437                     error (_("Remote sent bad register number %s: %s\n\
7438 Packet: '%s'\n"),
7439                            hex_string (pnum), p, buf);
7440
7441                   cached_reg.num = reg->regnum;
7442                   cached_reg.data = (gdb_byte *)
7443                     xmalloc (register_size (event->arch, reg->regnum));
7444
7445                   p = p1 + 1;
7446                   fieldsize = hex2bin (p, cached_reg.data,
7447                                        register_size (event->arch, reg->regnum));
7448                   p += 2 * fieldsize;
7449                   if (fieldsize < register_size (event->arch, reg->regnum))
7450                     warning (_("Remote reply is too short: %s"), buf);
7451
7452                   VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
7453                 }
7454               else
7455                 {
7456                   /* Not a number.  Silently skip unknown optional
7457                      info.  */
7458                   p = strchrnul (p1 + 1, ';');
7459                 }
7460             }
7461
7462           if (*p != ';')
7463             error (_("Remote register badly formatted: %s\nhere: %s"),
7464                    buf, p);
7465           ++p;
7466         }
7467
7468       if (event->ws.kind != TARGET_WAITKIND_IGNORE)
7469         break;
7470
7471       /* fall through */
7472     case 'S':           /* Old style status, just signal only.  */
7473       {
7474         int sig;
7475
7476         event->ws.kind = TARGET_WAITKIND_STOPPED;
7477         sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
7478         if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
7479           event->ws.value.sig = (enum gdb_signal) sig;
7480         else
7481           event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7482       }
7483       break;
7484     case 'w':           /* Thread exited.  */
7485       {
7486         ULONGEST value;
7487
7488         event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
7489         p = unpack_varlen_hex (&buf[1], &value);
7490         event->ws.value.integer = value;
7491         if (*p != ';')
7492           error (_("stop reply packet badly formatted: %s"), buf);
7493         event->ptid = read_ptid (++p, NULL);
7494         break;
7495       }
7496     case 'W':           /* Target exited.  */
7497     case 'X':
7498       {
7499         int pid;
7500         ULONGEST value;
7501
7502         /* GDB used to accept only 2 hex chars here.  Stubs should
7503            only send more if they detect GDB supports multi-process
7504            support.  */
7505         p = unpack_varlen_hex (&buf[1], &value);
7506
7507         if (buf[0] == 'W')
7508           {
7509             /* The remote process exited.  */
7510             event->ws.kind = TARGET_WAITKIND_EXITED;
7511             event->ws.value.integer = value;
7512           }
7513         else
7514           {
7515             /* The remote process exited with a signal.  */
7516             event->ws.kind = TARGET_WAITKIND_SIGNALLED;
7517             if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
7518               event->ws.value.sig = (enum gdb_signal) value;
7519             else
7520               event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7521           }
7522
7523         /* If no process is specified, assume inferior_ptid.  */
7524         pid = inferior_ptid.pid ();
7525         if (*p == '\0')
7526           ;
7527         else if (*p == ';')
7528           {
7529             p++;
7530
7531             if (*p == '\0')
7532               ;
7533             else if (startswith (p, "process:"))
7534               {
7535                 ULONGEST upid;
7536
7537                 p += sizeof ("process:") - 1;
7538                 unpack_varlen_hex (p, &upid);
7539                 pid = upid;
7540               }
7541             else
7542               error (_("unknown stop reply packet: %s"), buf);
7543           }
7544         else
7545           error (_("unknown stop reply packet: %s"), buf);
7546         event->ptid = ptid_t (pid);
7547       }
7548       break;
7549     case 'N':
7550       event->ws.kind = TARGET_WAITKIND_NO_RESUMED;
7551       event->ptid = minus_one_ptid;
7552       break;
7553     }
7554
7555   if (target_is_non_stop_p () && event->ptid == null_ptid)
7556     error (_("No process or thread specified in stop reply: %s"), buf);
7557 }
7558
7559 /* When the stub wants to tell GDB about a new notification reply, it
7560    sends a notification (%Stop, for example).  Those can come it at
7561    any time, hence, we have to make sure that any pending
7562    putpkt/getpkt sequence we're making is finished, before querying
7563    the stub for more events with the corresponding ack command
7564    (vStopped, for example).  E.g., if we started a vStopped sequence
7565    immediately upon receiving the notification, something like this
7566    could happen:
7567
7568     1.1) --> Hg 1
7569     1.2) <-- OK
7570     1.3) --> g
7571     1.4) <-- %Stop
7572     1.5) --> vStopped
7573     1.6) <-- (registers reply to step #1.3)
7574
7575    Obviously, the reply in step #1.6 would be unexpected to a vStopped
7576    query.
7577
7578    To solve this, whenever we parse a %Stop notification successfully,
7579    we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7580    doing whatever we were doing:
7581
7582     2.1) --> Hg 1
7583     2.2) <-- OK
7584     2.3) --> g
7585     2.4) <-- %Stop
7586       <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7587     2.5) <-- (registers reply to step #2.3)
7588
7589    Eventualy after step #2.5, we return to the event loop, which
7590    notices there's an event on the
7591    REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7592    associated callback --- the function below.  At this point, we're
7593    always safe to start a vStopped sequence. :
7594
7595     2.6) --> vStopped
7596     2.7) <-- T05 thread:2
7597     2.8) --> vStopped
7598     2.9) --> OK
7599 */
7600
7601 void
7602 remote_target::remote_notif_get_pending_events (notif_client *nc)
7603 {
7604   struct remote_state *rs = get_remote_state ();
7605
7606   if (rs->notif_state->pending_event[nc->id] != NULL)
7607     {
7608       if (notif_debug)
7609         fprintf_unfiltered (gdb_stdlog,
7610                             "notif: process: '%s' ack pending event\n",
7611                             nc->name);
7612
7613       /* acknowledge */
7614       nc->ack (this, nc, rs->buf.data (),
7615                rs->notif_state->pending_event[nc->id]);
7616       rs->notif_state->pending_event[nc->id] = NULL;
7617
7618       while (1)
7619         {
7620           getpkt (&rs->buf, 0);
7621           if (strcmp (rs->buf.data (), "OK") == 0)
7622             break;
7623           else
7624             remote_notif_ack (this, nc, rs->buf.data ());
7625         }
7626     }
7627   else
7628     {
7629       if (notif_debug)
7630         fprintf_unfiltered (gdb_stdlog,
7631                             "notif: process: '%s' no pending reply\n",
7632                             nc->name);
7633     }
7634 }
7635
7636 /* Wrapper around remote_target::remote_notif_get_pending_events to
7637    avoid having to export the whole remote_target class.  */
7638
7639 void
7640 remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
7641 {
7642   remote->remote_notif_get_pending_events (nc);
7643 }
7644
7645 /* Called when it is decided that STOP_REPLY holds the info of the
7646    event that is to be returned to the core.  This function always
7647    destroys STOP_REPLY.  */
7648
7649 ptid_t
7650 remote_target::process_stop_reply (struct stop_reply *stop_reply,
7651                                    struct target_waitstatus *status)
7652 {
7653   ptid_t ptid;
7654
7655   *status = stop_reply->ws;
7656   ptid = stop_reply->ptid;
7657
7658   /* If no thread/process was reported by the stub, assume the current
7659      inferior.  */
7660   if (ptid == null_ptid)
7661     ptid = inferior_ptid;
7662
7663   if (status->kind != TARGET_WAITKIND_EXITED
7664       && status->kind != TARGET_WAITKIND_SIGNALLED
7665       && status->kind != TARGET_WAITKIND_NO_RESUMED)
7666     {
7667       /* Expedited registers.  */
7668       if (stop_reply->regcache)
7669         {
7670           struct regcache *regcache
7671             = get_thread_arch_regcache (ptid, stop_reply->arch);
7672           cached_reg_t *reg;
7673           int ix;
7674
7675           for (ix = 0;
7676                VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg);
7677                ix++)
7678           {
7679             regcache->raw_supply (reg->num, reg->data);
7680             xfree (reg->data);
7681           }
7682
7683           VEC_free (cached_reg_t, stop_reply->regcache);
7684         }
7685
7686       remote_notice_new_inferior (ptid, 0);
7687       remote_thread_info *remote_thr = get_remote_thread_info (ptid);
7688       remote_thr->core = stop_reply->core;
7689       remote_thr->stop_reason = stop_reply->stop_reason;
7690       remote_thr->watch_data_address = stop_reply->watch_data_address;
7691       remote_thr->vcont_resumed = 0;
7692     }
7693
7694   stop_reply_xfree (stop_reply);
7695   return ptid;
7696 }
7697
7698 /* The non-stop mode version of target_wait.  */
7699
7700 ptid_t
7701 remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
7702 {
7703   struct remote_state *rs = get_remote_state ();
7704   struct stop_reply *stop_reply;
7705   int ret;
7706   int is_notif = 0;
7707
7708   /* If in non-stop mode, get out of getpkt even if a
7709      notification is received.  */
7710
7711   ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif);
7712   while (1)
7713     {
7714       if (ret != -1 && !is_notif)
7715         switch (rs->buf[0])
7716           {
7717           case 'E':             /* Error of some sort.  */
7718             /* We're out of sync with the target now.  Did it continue
7719                or not?  We can't tell which thread it was in non-stop,
7720                so just ignore this.  */
7721             warning (_("Remote failure reply: %s"), rs->buf.data ());
7722             break;
7723           case 'O':             /* Console output.  */
7724             remote_console_output (&rs->buf[1]);
7725             break;
7726           default:
7727             warning (_("Invalid remote reply: %s"), rs->buf.data ());
7728             break;
7729           }
7730
7731       /* Acknowledge a pending stop reply that may have arrived in the
7732          mean time.  */
7733       if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)
7734         remote_notif_get_pending_events (&notif_client_stop);
7735
7736       /* If indeed we noticed a stop reply, we're done.  */
7737       stop_reply = queued_stop_reply (ptid);
7738       if (stop_reply != NULL)
7739         return process_stop_reply (stop_reply, status);
7740
7741       /* Still no event.  If we're just polling for an event, then
7742          return to the event loop.  */
7743       if (options & TARGET_WNOHANG)
7744         {
7745           status->kind = TARGET_WAITKIND_IGNORE;
7746           return minus_one_ptid;
7747         }
7748
7749       /* Otherwise do a blocking wait.  */
7750       ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif);
7751     }
7752 }
7753
7754 /* Wait until the remote machine stops, then return, storing status in
7755    STATUS just as `wait' would.  */
7756
7757 ptid_t
7758 remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
7759 {
7760   struct remote_state *rs = get_remote_state ();
7761   ptid_t event_ptid = null_ptid;
7762   char *buf;
7763   struct stop_reply *stop_reply;
7764
7765  again:
7766
7767   status->kind = TARGET_WAITKIND_IGNORE;
7768   status->value.integer = 0;
7769
7770   stop_reply = queued_stop_reply (ptid);
7771   if (stop_reply != NULL)
7772     return process_stop_reply (stop_reply, status);
7773
7774   if (rs->cached_wait_status)
7775     /* Use the cached wait status, but only once.  */
7776     rs->cached_wait_status = 0;
7777   else
7778     {
7779       int ret;
7780       int is_notif;
7781       int forever = ((options & TARGET_WNOHANG) == 0
7782                      && rs->wait_forever_enabled_p);
7783
7784       if (!rs->waiting_for_stop_reply)
7785         {
7786           status->kind = TARGET_WAITKIND_NO_RESUMED;
7787           return minus_one_ptid;
7788         }
7789
7790       /* FIXME: cagney/1999-09-27: If we're in async mode we should
7791          _never_ wait for ever -> test on target_is_async_p().
7792          However, before we do that we need to ensure that the caller
7793          knows how to take the target into/out of async mode.  */
7794       ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
7795
7796       /* GDB gets a notification.  Return to core as this event is
7797          not interesting.  */
7798       if (ret != -1 && is_notif)
7799         return minus_one_ptid;
7800
7801       if (ret == -1 && (options & TARGET_WNOHANG) != 0)
7802         return minus_one_ptid;
7803     }
7804
7805   buf = rs->buf.data ();
7806
7807   /* Assume that the target has acknowledged Ctrl-C unless we receive
7808      an 'F' or 'O' packet.  */
7809   if (buf[0] != 'F' && buf[0] != 'O')
7810     rs->ctrlc_pending_p = 0;
7811
7812   switch (buf[0])
7813     {
7814     case 'E':           /* Error of some sort.  */
7815       /* We're out of sync with the target now.  Did it continue or
7816          not?  Not is more likely, so report a stop.  */
7817       rs->waiting_for_stop_reply = 0;
7818
7819       warning (_("Remote failure reply: %s"), buf);
7820       status->kind = TARGET_WAITKIND_STOPPED;
7821       status->value.sig = GDB_SIGNAL_0;
7822       break;
7823     case 'F':           /* File-I/O request.  */
7824       /* GDB may access the inferior memory while handling the File-I/O
7825          request, but we don't want GDB accessing memory while waiting
7826          for a stop reply.  See the comments in putpkt_binary.  Set
7827          waiting_for_stop_reply to 0 temporarily.  */
7828       rs->waiting_for_stop_reply = 0;
7829       remote_fileio_request (this, buf, rs->ctrlc_pending_p);
7830       rs->ctrlc_pending_p = 0;
7831       /* GDB handled the File-I/O request, and the target is running
7832          again.  Keep waiting for events.  */
7833       rs->waiting_for_stop_reply = 1;
7834       break;
7835     case 'N': case 'T': case 'S': case 'X': case 'W':
7836       {
7837         /* There is a stop reply to handle.  */
7838         rs->waiting_for_stop_reply = 0;
7839
7840         stop_reply
7841           = (struct stop_reply *) remote_notif_parse (this,
7842                                                       &notif_client_stop,
7843                                                       rs->buf.data ());
7844
7845         event_ptid = process_stop_reply (stop_reply, status);
7846         break;
7847       }
7848     case 'O':           /* Console output.  */
7849       remote_console_output (buf + 1);
7850       break;
7851     case '\0':
7852       if (rs->last_sent_signal != GDB_SIGNAL_0)
7853         {
7854           /* Zero length reply means that we tried 'S' or 'C' and the
7855              remote system doesn't support it.  */
7856           target_terminal::ours_for_output ();
7857           printf_filtered
7858             ("Can't send signals to this remote system.  %s not sent.\n",
7859              gdb_signal_to_name (rs->last_sent_signal));
7860           rs->last_sent_signal = GDB_SIGNAL_0;
7861           target_terminal::inferior ();
7862
7863           strcpy (buf, rs->last_sent_step ? "s" : "c");
7864           putpkt (buf);
7865           break;
7866         }
7867       /* fallthrough */
7868     default:
7869       warning (_("Invalid remote reply: %s"), buf);
7870       break;
7871     }
7872
7873   if (status->kind == TARGET_WAITKIND_NO_RESUMED)
7874     return minus_one_ptid;
7875   else if (status->kind == TARGET_WAITKIND_IGNORE)
7876     {
7877       /* Nothing interesting happened.  If we're doing a non-blocking
7878          poll, we're done.  Otherwise, go back to waiting.  */
7879       if (options & TARGET_WNOHANG)
7880         return minus_one_ptid;
7881       else
7882         goto again;
7883     }
7884   else if (status->kind != TARGET_WAITKIND_EXITED
7885            && status->kind != TARGET_WAITKIND_SIGNALLED)
7886     {
7887       if (event_ptid != null_ptid)
7888         record_currthread (rs, event_ptid);
7889       else
7890         event_ptid = inferior_ptid;
7891     }
7892   else
7893     /* A process exit.  Invalidate our notion of current thread.  */
7894     record_currthread (rs, minus_one_ptid);
7895
7896   return event_ptid;
7897 }
7898
7899 /* Wait until the remote machine stops, then return, storing status in
7900    STATUS just as `wait' would.  */
7901
7902 ptid_t
7903 remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options)
7904 {
7905   ptid_t event_ptid;
7906
7907   if (target_is_non_stop_p ())
7908     event_ptid = wait_ns (ptid, status, options);
7909   else
7910     event_ptid = wait_as (ptid, status, options);
7911
7912   if (target_is_async_p ())
7913     {
7914       remote_state *rs = get_remote_state ();
7915
7916       /* If there are are events left in the queue tell the event loop
7917          to return here.  */
7918       if (!rs->stop_reply_queue.empty ())
7919         mark_async_event_handler (rs->remote_async_inferior_event_token);
7920     }
7921
7922   return event_ptid;
7923 }
7924
7925 /* Fetch a single register using a 'p' packet.  */
7926
7927 int
7928 remote_target::fetch_register_using_p (struct regcache *regcache,
7929                                        packet_reg *reg)
7930 {
7931   struct gdbarch *gdbarch = regcache->arch ();
7932   struct remote_state *rs = get_remote_state ();
7933   char *buf, *p;
7934   gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
7935   int i;
7936
7937   if (packet_support (PACKET_p) == PACKET_DISABLE)
7938     return 0;
7939
7940   if (reg->pnum == -1)
7941     return 0;
7942
7943   p = rs->buf.data ();
7944   *p++ = 'p';
7945   p += hexnumstr (p, reg->pnum);
7946   *p++ = '\0';
7947   putpkt (rs->buf);
7948   getpkt (&rs->buf, 0);
7949
7950   buf = rs->buf.data ();
7951
7952   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p]))
7953     {
7954     case PACKET_OK:
7955       break;
7956     case PACKET_UNKNOWN:
7957       return 0;
7958     case PACKET_ERROR:
7959       error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7960              gdbarch_register_name (regcache->arch (), 
7961                                     reg->regnum), 
7962              buf);
7963     }
7964
7965   /* If this register is unfetchable, tell the regcache.  */
7966   if (buf[0] == 'x')
7967     {
7968       regcache->raw_supply (reg->regnum, NULL);
7969       return 1;
7970     }
7971
7972   /* Otherwise, parse and supply the value.  */
7973   p = buf;
7974   i = 0;
7975   while (p[0] != 0)
7976     {
7977       if (p[1] == 0)
7978         error (_("fetch_register_using_p: early buf termination"));
7979
7980       regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
7981       p += 2;
7982     }
7983   regcache->raw_supply (reg->regnum, regp);
7984   return 1;
7985 }
7986
7987 /* Fetch the registers included in the target's 'g' packet.  */
7988
7989 int
7990 remote_target::send_g_packet ()
7991 {
7992   struct remote_state *rs = get_remote_state ();
7993   int buf_len;
7994
7995   xsnprintf (rs->buf.data (), get_remote_packet_size (), "g");
7996   putpkt (rs->buf);
7997   getpkt (&rs->buf, 0);
7998   if (packet_check_result (rs->buf) == PACKET_ERROR)
7999     error (_("Could not read registers; remote failure reply '%s'"),
8000            rs->buf.data ());
8001
8002   /* We can get out of synch in various cases.  If the first character
8003      in the buffer is not a hex character, assume that has happened
8004      and try to fetch another packet to read.  */
8005   while ((rs->buf[0] < '0' || rs->buf[0] > '9')
8006          && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
8007          && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
8008          && rs->buf[0] != 'x')  /* New: unavailable register value.  */
8009     {
8010       if (remote_debug)
8011         fprintf_unfiltered (gdb_stdlog,
8012                             "Bad register packet; fetching a new packet\n");
8013       getpkt (&rs->buf, 0);
8014     }
8015
8016   buf_len = strlen (rs->buf.data ());
8017
8018   /* Sanity check the received packet.  */
8019   if (buf_len % 2 != 0)
8020     error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ());
8021
8022   return buf_len / 2;
8023 }
8024
8025 void
8026 remote_target::process_g_packet (struct regcache *regcache)
8027 {
8028   struct gdbarch *gdbarch = regcache->arch ();
8029   struct remote_state *rs = get_remote_state ();
8030   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8031   int i, buf_len;
8032   char *p;
8033   char *regs;
8034
8035   buf_len = strlen (rs->buf.data ());
8036
8037   /* Further sanity checks, with knowledge of the architecture.  */
8038   if (buf_len > 2 * rsa->sizeof_g_packet)
8039     error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
8040              "bytes): %s"),
8041            rsa->sizeof_g_packet, buf_len / 2,
8042            rs->buf.data ());
8043
8044   /* Save the size of the packet sent to us by the target.  It is used
8045      as a heuristic when determining the max size of packets that the
8046      target can safely receive.  */
8047   if (rsa->actual_register_packet_size == 0)
8048     rsa->actual_register_packet_size = buf_len;
8049
8050   /* If this is smaller than we guessed the 'g' packet would be,
8051      update our records.  A 'g' reply that doesn't include a register's
8052      value implies either that the register is not available, or that
8053      the 'p' packet must be used.  */
8054   if (buf_len < 2 * rsa->sizeof_g_packet)
8055     {
8056       long sizeof_g_packet = buf_len / 2;
8057
8058       for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8059         {
8060           long offset = rsa->regs[i].offset;
8061           long reg_size = register_size (gdbarch, i);
8062
8063           if (rsa->regs[i].pnum == -1)
8064             continue;
8065
8066           if (offset >= sizeof_g_packet)
8067             rsa->regs[i].in_g_packet = 0;
8068           else if (offset + reg_size > sizeof_g_packet)
8069             error (_("Truncated register %d in remote 'g' packet"), i);
8070           else
8071             rsa->regs[i].in_g_packet = 1;
8072         }
8073
8074       /* Looks valid enough, we can assume this is the correct length
8075          for a 'g' packet.  It's important not to adjust
8076          rsa->sizeof_g_packet if we have truncated registers otherwise
8077          this "if" won't be run the next time the method is called
8078          with a packet of the same size and one of the internal errors
8079          below will trigger instead.  */
8080       rsa->sizeof_g_packet = sizeof_g_packet;
8081     }
8082
8083   regs = (char *) alloca (rsa->sizeof_g_packet);
8084
8085   /* Unimplemented registers read as all bits zero.  */
8086   memset (regs, 0, rsa->sizeof_g_packet);
8087
8088   /* Reply describes registers byte by byte, each byte encoded as two
8089      hex characters.  Suck them all up, then supply them to the
8090      register cacheing/storage mechanism.  */
8091
8092   p = rs->buf.data ();
8093   for (i = 0; i < rsa->sizeof_g_packet; i++)
8094     {
8095       if (p[0] == 0 || p[1] == 0)
8096         /* This shouldn't happen - we adjusted sizeof_g_packet above.  */
8097         internal_error (__FILE__, __LINE__,
8098                         _("unexpected end of 'g' packet reply"));
8099
8100       if (p[0] == 'x' && p[1] == 'x')
8101         regs[i] = 0;            /* 'x' */
8102       else
8103         regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
8104       p += 2;
8105     }
8106
8107   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8108     {
8109       struct packet_reg *r = &rsa->regs[i];
8110       long reg_size = register_size (gdbarch, i);
8111
8112       if (r->in_g_packet)
8113         {
8114           if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ()))
8115             /* This shouldn't happen - we adjusted in_g_packet above.  */
8116             internal_error (__FILE__, __LINE__,
8117                             _("unexpected end of 'g' packet reply"));
8118           else if (rs->buf[r->offset * 2] == 'x')
8119             {
8120               gdb_assert (r->offset * 2 < strlen (rs->buf.data ()));
8121               /* The register isn't available, mark it as such (at
8122                  the same time setting the value to zero).  */
8123               regcache->raw_supply (r->regnum, NULL);
8124             }
8125           else
8126             regcache->raw_supply (r->regnum, regs + r->offset);
8127         }
8128     }
8129 }
8130
8131 void
8132 remote_target::fetch_registers_using_g (struct regcache *regcache)
8133 {
8134   send_g_packet ();
8135   process_g_packet (regcache);
8136 }
8137
8138 /* Make the remote selected traceframe match GDB's selected
8139    traceframe.  */
8140
8141 void
8142 remote_target::set_remote_traceframe ()
8143 {
8144   int newnum;
8145   struct remote_state *rs = get_remote_state ();
8146
8147   if (rs->remote_traceframe_number == get_traceframe_number ())
8148     return;
8149
8150   /* Avoid recursion, remote_trace_find calls us again.  */
8151   rs->remote_traceframe_number = get_traceframe_number ();
8152
8153   newnum = target_trace_find (tfind_number,
8154                               get_traceframe_number (), 0, 0, NULL);
8155
8156   /* Should not happen.  If it does, all bets are off.  */
8157   if (newnum != get_traceframe_number ())
8158     warning (_("could not set remote traceframe"));
8159 }
8160
8161 void
8162 remote_target::fetch_registers (struct regcache *regcache, int regnum)
8163 {
8164   struct gdbarch *gdbarch = regcache->arch ();
8165   struct remote_state *rs = get_remote_state ();
8166   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8167   int i;
8168
8169   set_remote_traceframe ();
8170   set_general_thread (regcache->ptid ());
8171
8172   if (regnum >= 0)
8173     {
8174       packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8175
8176       gdb_assert (reg != NULL);
8177
8178       /* If this register might be in the 'g' packet, try that first -
8179          we are likely to read more than one register.  If this is the
8180          first 'g' packet, we might be overly optimistic about its
8181          contents, so fall back to 'p'.  */
8182       if (reg->in_g_packet)
8183         {
8184           fetch_registers_using_g (regcache);
8185           if (reg->in_g_packet)
8186             return;
8187         }
8188
8189       if (fetch_register_using_p (regcache, reg))
8190         return;
8191
8192       /* This register is not available.  */
8193       regcache->raw_supply (reg->regnum, NULL);
8194
8195       return;
8196     }
8197
8198   fetch_registers_using_g (regcache);
8199
8200   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8201     if (!rsa->regs[i].in_g_packet)
8202       if (!fetch_register_using_p (regcache, &rsa->regs[i]))
8203         {
8204           /* This register is not available.  */
8205           regcache->raw_supply (i, NULL);
8206         }
8207 }
8208
8209 /* Prepare to store registers.  Since we may send them all (using a
8210    'G' request), we have to read out the ones we don't want to change
8211    first.  */
8212
8213 void
8214 remote_target::prepare_to_store (struct regcache *regcache)
8215 {
8216   struct remote_state *rs = get_remote_state ();
8217   remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8218   int i;
8219
8220   /* Make sure the entire registers array is valid.  */
8221   switch (packet_support (PACKET_P))
8222     {
8223     case PACKET_DISABLE:
8224     case PACKET_SUPPORT_UNKNOWN:
8225       /* Make sure all the necessary registers are cached.  */
8226       for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8227         if (rsa->regs[i].in_g_packet)
8228           regcache->raw_update (rsa->regs[i].regnum);
8229       break;
8230     case PACKET_ENABLE:
8231       break;
8232     }
8233 }
8234
8235 /* Helper: Attempt to store REGNUM using the P packet.  Return fail IFF
8236    packet was not recognized.  */
8237
8238 int
8239 remote_target::store_register_using_P (const struct regcache *regcache,
8240                                        packet_reg *reg)
8241 {
8242   struct gdbarch *gdbarch = regcache->arch ();
8243   struct remote_state *rs = get_remote_state ();
8244   /* Try storing a single register.  */
8245   char *buf = rs->buf.data ();
8246   gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
8247   char *p;
8248
8249   if (packet_support (PACKET_P) == PACKET_DISABLE)
8250     return 0;
8251
8252   if (reg->pnum == -1)
8253     return 0;
8254
8255   xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
8256   p = buf + strlen (buf);
8257   regcache->raw_collect (reg->regnum, regp);
8258   bin2hex (regp, p, register_size (gdbarch, reg->regnum));
8259   putpkt (rs->buf);
8260   getpkt (&rs->buf, 0);
8261
8262   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
8263     {
8264     case PACKET_OK:
8265       return 1;
8266     case PACKET_ERROR:
8267       error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8268              gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ());
8269     case PACKET_UNKNOWN:
8270       return 0;
8271     default:
8272       internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
8273     }
8274 }
8275
8276 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8277    contents of the register cache buffer.  FIXME: ignores errors.  */
8278
8279 void
8280 remote_target::store_registers_using_G (const struct regcache *regcache)
8281 {
8282   struct remote_state *rs = get_remote_state ();
8283   remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8284   gdb_byte *regs;
8285   char *p;
8286
8287   /* Extract all the registers in the regcache copying them into a
8288      local buffer.  */
8289   {
8290     int i;
8291
8292     regs = (gdb_byte *) alloca (rsa->sizeof_g_packet);
8293     memset (regs, 0, rsa->sizeof_g_packet);
8294     for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8295       {
8296         struct packet_reg *r = &rsa->regs[i];
8297
8298         if (r->in_g_packet)
8299           regcache->raw_collect (r->regnum, regs + r->offset);
8300       }
8301   }
8302
8303   /* Command describes registers byte by byte,
8304      each byte encoded as two hex characters.  */
8305   p = rs->buf.data ();
8306   *p++ = 'G';
8307   bin2hex (regs, p, rsa->sizeof_g_packet);
8308   putpkt (rs->buf);
8309   getpkt (&rs->buf, 0);
8310   if (packet_check_result (rs->buf) == PACKET_ERROR)
8311     error (_("Could not write registers; remote failure reply '%s'"), 
8312            rs->buf.data ());
8313 }
8314
8315 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8316    of the register cache buffer.  FIXME: ignores errors.  */
8317
8318 void
8319 remote_target::store_registers (struct regcache *regcache, int regnum)
8320 {
8321   struct gdbarch *gdbarch = regcache->arch ();
8322   struct remote_state *rs = get_remote_state ();
8323   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8324   int i;
8325
8326   set_remote_traceframe ();
8327   set_general_thread (regcache->ptid ());
8328
8329   if (regnum >= 0)
8330     {
8331       packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8332
8333       gdb_assert (reg != NULL);
8334
8335       /* Always prefer to store registers using the 'P' packet if
8336          possible; we often change only a small number of registers.
8337          Sometimes we change a larger number; we'd need help from a
8338          higher layer to know to use 'G'.  */
8339       if (store_register_using_P (regcache, reg))
8340         return;
8341
8342       /* For now, don't complain if we have no way to write the
8343          register.  GDB loses track of unavailable registers too
8344          easily.  Some day, this may be an error.  We don't have
8345          any way to read the register, either...  */
8346       if (!reg->in_g_packet)
8347         return;
8348
8349       store_registers_using_G (regcache);
8350       return;
8351     }
8352
8353   store_registers_using_G (regcache);
8354
8355   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8356     if (!rsa->regs[i].in_g_packet)
8357       if (!store_register_using_P (regcache, &rsa->regs[i]))
8358         /* See above for why we do not issue an error here.  */
8359         continue;
8360 }
8361 \f
8362
8363 /* Return the number of hex digits in num.  */
8364
8365 static int
8366 hexnumlen (ULONGEST num)
8367 {
8368   int i;
8369
8370   for (i = 0; num != 0; i++)
8371     num >>= 4;
8372
8373   return std::max (i, 1);
8374 }
8375
8376 /* Set BUF to the minimum number of hex digits representing NUM.  */
8377
8378 static int
8379 hexnumstr (char *buf, ULONGEST num)
8380 {
8381   int len = hexnumlen (num);
8382
8383   return hexnumnstr (buf, num, len);
8384 }
8385
8386
8387 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters.  */
8388
8389 static int
8390 hexnumnstr (char *buf, ULONGEST num, int width)
8391 {
8392   int i;
8393
8394   buf[width] = '\0';
8395
8396   for (i = width - 1; i >= 0; i--)
8397     {
8398       buf[i] = "0123456789abcdef"[(num & 0xf)];
8399       num >>= 4;
8400     }
8401
8402   return width;
8403 }
8404
8405 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits.  */
8406
8407 static CORE_ADDR
8408 remote_address_masked (CORE_ADDR addr)
8409 {
8410   unsigned int address_size = remote_address_size;
8411
8412   /* If "remoteaddresssize" was not set, default to target address size.  */
8413   if (!address_size)
8414     address_size = gdbarch_addr_bit (target_gdbarch ());
8415
8416   if (address_size > 0
8417       && address_size < (sizeof (ULONGEST) * 8))
8418     {
8419       /* Only create a mask when that mask can safely be constructed
8420          in a ULONGEST variable.  */
8421       ULONGEST mask = 1;
8422
8423       mask = (mask << address_size) - 1;
8424       addr &= mask;
8425     }
8426   return addr;
8427 }
8428
8429 /* Determine whether the remote target supports binary downloading.
8430    This is accomplished by sending a no-op memory write of zero length
8431    to the target at the specified address. It does not suffice to send
8432    the whole packet, since many stubs strip the eighth bit and
8433    subsequently compute a wrong checksum, which causes real havoc with
8434    remote_write_bytes.
8435
8436    NOTE: This can still lose if the serial line is not eight-bit
8437    clean.  In cases like this, the user should clear "remote
8438    X-packet".  */
8439
8440 void
8441 remote_target::check_binary_download (CORE_ADDR addr)
8442 {
8443   struct remote_state *rs = get_remote_state ();
8444
8445   switch (packet_support (PACKET_X))
8446     {
8447     case PACKET_DISABLE:
8448       break;
8449     case PACKET_ENABLE:
8450       break;
8451     case PACKET_SUPPORT_UNKNOWN:
8452       {
8453         char *p;
8454
8455         p = rs->buf.data ();
8456         *p++ = 'X';
8457         p += hexnumstr (p, (ULONGEST) addr);
8458         *p++ = ',';
8459         p += hexnumstr (p, (ULONGEST) 0);
8460         *p++ = ':';
8461         *p = '\0';
8462
8463         putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
8464         getpkt (&rs->buf, 0);
8465
8466         if (rs->buf[0] == '\0')
8467           {
8468             if (remote_debug)
8469               fprintf_unfiltered (gdb_stdlog,
8470                                   "binary downloading NOT "
8471                                   "supported by target\n");
8472             remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
8473           }
8474         else
8475           {
8476             if (remote_debug)
8477               fprintf_unfiltered (gdb_stdlog,
8478                                   "binary downloading supported by target\n");
8479             remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
8480           }
8481         break;
8482       }
8483     }
8484 }
8485
8486 /* Helper function to resize the payload in order to try to get a good
8487    alignment.  We try to write an amount of data such that the next write will
8488    start on an address aligned on REMOTE_ALIGN_WRITES.  */
8489
8490 static int
8491 align_for_efficient_write (int todo, CORE_ADDR memaddr)
8492 {
8493   return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
8494 }
8495
8496 /* Write memory data directly to the remote machine.
8497    This does not inform the data cache; the data cache uses this.
8498    HEADER is the starting part of the packet.
8499    MEMADDR is the address in the remote memory space.
8500    MYADDR is the address of the buffer in our space.
8501    LEN_UNITS is the number of addressable units to write.
8502    UNIT_SIZE is the length in bytes of an addressable unit.
8503    PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8504    should send data as binary ('X'), or hex-encoded ('M').
8505
8506    The function creates packet of the form
8507        <HEADER><ADDRESS>,<LENGTH>:<DATA>
8508
8509    where encoding of <DATA> is terminated by PACKET_FORMAT.
8510
8511    If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8512    are omitted.
8513
8514    Return the transferred status, error or OK (an
8515    'enum target_xfer_status' value).  Save the number of addressable units
8516    transferred in *XFERED_LEN_UNITS.  Only transfer a single packet.
8517
8518    On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8519    exchange between gdb and the stub could look like (?? in place of the
8520    checksum):
8521
8522    -> $m1000,4#??
8523    <- aaaabbbbccccdddd
8524
8525    -> $M1000,3:eeeeffffeeee#??
8526    <- OK
8527
8528    -> $m1000,4#??
8529    <- eeeeffffeeeedddd  */
8530
8531 target_xfer_status
8532 remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
8533                                        const gdb_byte *myaddr,
8534                                        ULONGEST len_units,
8535                                        int unit_size,
8536                                        ULONGEST *xfered_len_units,
8537                                        char packet_format, int use_length)
8538 {
8539   struct remote_state *rs = get_remote_state ();
8540   char *p;
8541   char *plen = NULL;
8542   int plenlen = 0;
8543   int todo_units;
8544   int units_written;
8545   int payload_capacity_bytes;
8546   int payload_length_bytes;
8547
8548   if (packet_format != 'X' && packet_format != 'M')
8549     internal_error (__FILE__, __LINE__,
8550                     _("remote_write_bytes_aux: bad packet format"));
8551
8552   if (len_units == 0)
8553     return TARGET_XFER_EOF;
8554
8555   payload_capacity_bytes = get_memory_write_packet_size ();
8556
8557   /* The packet buffer will be large enough for the payload;
8558      get_memory_packet_size ensures this.  */
8559   rs->buf[0] = '\0';
8560
8561   /* Compute the size of the actual payload by subtracting out the
8562      packet header and footer overhead: "$M<memaddr>,<len>:...#nn".  */
8563
8564   payload_capacity_bytes -= strlen ("$,:#NN");
8565   if (!use_length)
8566     /* The comma won't be used.  */
8567     payload_capacity_bytes += 1;
8568   payload_capacity_bytes -= strlen (header);
8569   payload_capacity_bytes -= hexnumlen (memaddr);
8570
8571   /* Construct the packet excluding the data: "<header><memaddr>,<len>:".  */
8572
8573   strcat (rs->buf.data (), header);
8574   p = rs->buf.data () + strlen (header);
8575
8576   /* Compute a best guess of the number of bytes actually transfered.  */
8577   if (packet_format == 'X')
8578     {
8579       /* Best guess at number of bytes that will fit.  */
8580       todo_units = std::min (len_units,
8581                              (ULONGEST) payload_capacity_bytes / unit_size);
8582       if (use_length)
8583         payload_capacity_bytes -= hexnumlen (todo_units);
8584       todo_units = std::min (todo_units, payload_capacity_bytes / unit_size);
8585     }
8586   else
8587     {
8588       /* Number of bytes that will fit.  */
8589       todo_units
8590         = std::min (len_units,
8591                     (ULONGEST) (payload_capacity_bytes / unit_size) / 2);
8592       if (use_length)
8593         payload_capacity_bytes -= hexnumlen (todo_units);
8594       todo_units = std::min (todo_units,
8595                              (payload_capacity_bytes / unit_size) / 2);
8596     }
8597
8598   if (todo_units <= 0)
8599     internal_error (__FILE__, __LINE__,
8600                     _("minimum packet size too small to write data"));
8601
8602   /* If we already need another packet, then try to align the end
8603      of this packet to a useful boundary.  */
8604   if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units)
8605     todo_units = align_for_efficient_write (todo_units, memaddr);
8606
8607   /* Append "<memaddr>".  */
8608   memaddr = remote_address_masked (memaddr);
8609   p += hexnumstr (p, (ULONGEST) memaddr);
8610
8611   if (use_length)
8612     {
8613       /* Append ",".  */
8614       *p++ = ',';
8615
8616       /* Append the length and retain its location and size.  It may need to be
8617          adjusted once the packet body has been created.  */
8618       plen = p;
8619       plenlen = hexnumstr (p, (ULONGEST) todo_units);
8620       p += plenlen;
8621     }
8622
8623   /* Append ":".  */
8624   *p++ = ':';
8625   *p = '\0';
8626
8627   /* Append the packet body.  */
8628   if (packet_format == 'X')
8629     {
8630       /* Binary mode.  Send target system values byte by byte, in
8631          increasing byte addresses.  Only escape certain critical
8632          characters.  */
8633       payload_length_bytes =
8634           remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p,
8635                                 &units_written, payload_capacity_bytes);
8636
8637       /* If not all TODO units fit, then we'll need another packet.  Make
8638          a second try to keep the end of the packet aligned.  Don't do
8639          this if the packet is tiny.  */
8640       if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES)
8641         {
8642           int new_todo_units;
8643
8644           new_todo_units = align_for_efficient_write (units_written, memaddr);
8645
8646           if (new_todo_units != units_written)
8647             payload_length_bytes =
8648                 remote_escape_output (myaddr, new_todo_units, unit_size,
8649                                       (gdb_byte *) p, &units_written,
8650                                       payload_capacity_bytes);
8651         }
8652
8653       p += payload_length_bytes;
8654       if (use_length && units_written < todo_units)
8655         {
8656           /* Escape chars have filled up the buffer prematurely,
8657              and we have actually sent fewer units than planned.
8658              Fix-up the length field of the packet.  Use the same
8659              number of characters as before.  */
8660           plen += hexnumnstr (plen, (ULONGEST) units_written,
8661                               plenlen);
8662           *plen = ':';  /* overwrite \0 from hexnumnstr() */
8663         }
8664     }
8665   else
8666     {
8667       /* Normal mode: Send target system values byte by byte, in
8668          increasing byte addresses.  Each byte is encoded as a two hex
8669          value.  */
8670       p += 2 * bin2hex (myaddr, p, todo_units * unit_size);
8671       units_written = todo_units;
8672     }
8673
8674   putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
8675   getpkt (&rs->buf, 0);
8676
8677   if (rs->buf[0] == 'E')
8678     return TARGET_XFER_E_IO;
8679
8680   /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8681      send fewer units than we'd planned.  */
8682   *xfered_len_units = (ULONGEST) units_written;
8683   return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8684 }
8685
8686 /* Write memory data directly to the remote machine.
8687    This does not inform the data cache; the data cache uses this.
8688    MEMADDR is the address in the remote memory space.
8689    MYADDR is the address of the buffer in our space.
8690    LEN is the number of bytes.
8691
8692    Return the transferred status, error or OK (an
8693    'enum target_xfer_status' value).  Save the number of bytes
8694    transferred in *XFERED_LEN.  Only transfer a single packet.  */
8695
8696 target_xfer_status
8697 remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr,
8698                                    ULONGEST len, int unit_size,
8699                                    ULONGEST *xfered_len)
8700 {
8701   const char *packet_format = NULL;
8702
8703   /* Check whether the target supports binary download.  */
8704   check_binary_download (memaddr);
8705
8706   switch (packet_support (PACKET_X))
8707     {
8708     case PACKET_ENABLE:
8709       packet_format = "X";
8710       break;
8711     case PACKET_DISABLE:
8712       packet_format = "M";
8713       break;
8714     case PACKET_SUPPORT_UNKNOWN:
8715       internal_error (__FILE__, __LINE__,
8716                       _("remote_write_bytes: bad internal state"));
8717     default:
8718       internal_error (__FILE__, __LINE__, _("bad switch"));
8719     }
8720
8721   return remote_write_bytes_aux (packet_format,
8722                                  memaddr, myaddr, len, unit_size, xfered_len,
8723                                  packet_format[0], 1);
8724 }
8725
8726 /* Read memory data directly from the remote machine.
8727    This does not use the data cache; the data cache uses this.
8728    MEMADDR is the address in the remote memory space.
8729    MYADDR is the address of the buffer in our space.
8730    LEN_UNITS is the number of addressable memory units to read..
8731    UNIT_SIZE is the length in bytes of an addressable unit.
8732
8733    Return the transferred status, error or OK (an
8734    'enum target_xfer_status' value).  Save the number of bytes
8735    transferred in *XFERED_LEN_UNITS.
8736
8737    See the comment of remote_write_bytes_aux for an example of
8738    memory read/write exchange between gdb and the stub.  */
8739
8740 target_xfer_status
8741 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
8742                                     ULONGEST len_units,
8743                                     int unit_size, ULONGEST *xfered_len_units)
8744 {
8745   struct remote_state *rs = get_remote_state ();
8746   int buf_size_bytes;           /* Max size of packet output buffer.  */
8747   char *p;
8748   int todo_units;
8749   int decoded_bytes;
8750
8751   buf_size_bytes = get_memory_read_packet_size ();
8752   /* The packet buffer will be large enough for the payload;
8753      get_memory_packet_size ensures this.  */
8754
8755   /* Number of units that will fit.  */
8756   todo_units = std::min (len_units,
8757                          (ULONGEST) (buf_size_bytes / unit_size) / 2);
8758
8759   /* Construct "m"<memaddr>","<len>".  */
8760   memaddr = remote_address_masked (memaddr);
8761   p = rs->buf.data ();
8762   *p++ = 'm';
8763   p += hexnumstr (p, (ULONGEST) memaddr);
8764   *p++ = ',';
8765   p += hexnumstr (p, (ULONGEST) todo_units);
8766   *p = '\0';
8767   putpkt (rs->buf);
8768   getpkt (&rs->buf, 0);
8769   if (rs->buf[0] == 'E'
8770       && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
8771       && rs->buf[3] == '\0')
8772     return TARGET_XFER_E_IO;
8773   /* Reply describes memory byte by byte, each byte encoded as two hex
8774      characters.  */
8775   p = rs->buf.data ();
8776   decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
8777   /* Return what we have.  Let higher layers handle partial reads.  */
8778   *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
8779   return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8780 }
8781
8782 /* Using the set of read-only target sections of remote, read live
8783    read-only memory.
8784
8785    For interface/parameters/return description see target.h,
8786    to_xfer_partial.  */
8787
8788 target_xfer_status
8789 remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
8790                                                   ULONGEST memaddr,
8791                                                   ULONGEST len,
8792                                                   int unit_size,
8793                                                   ULONGEST *xfered_len)
8794 {
8795   struct target_section *secp;
8796   struct target_section_table *table;
8797
8798   secp = target_section_by_addr (this, memaddr);
8799   if (secp != NULL
8800       && (bfd_get_section_flags (secp->the_bfd_section->owner,
8801                                  secp->the_bfd_section)
8802           & SEC_READONLY))
8803     {
8804       struct target_section *p;
8805       ULONGEST memend = memaddr + len;
8806
8807       table = target_get_section_table (this);
8808
8809       for (p = table->sections; p < table->sections_end; p++)
8810         {
8811           if (memaddr >= p->addr)
8812             {
8813               if (memend <= p->endaddr)
8814                 {
8815                   /* Entire transfer is within this section.  */
8816                   return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8817                                               xfered_len);
8818                 }
8819               else if (memaddr >= p->endaddr)
8820                 {
8821                   /* This section ends before the transfer starts.  */
8822                   continue;
8823                 }
8824               else
8825                 {
8826                   /* This section overlaps the transfer.  Just do half.  */
8827                   len = p->endaddr - memaddr;
8828                   return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8829                                               xfered_len);
8830                 }
8831             }
8832         }
8833     }
8834
8835   return TARGET_XFER_EOF;
8836 }
8837
8838 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8839    first if the requested memory is unavailable in traceframe.
8840    Otherwise, fall back to remote_read_bytes_1.  */
8841
8842 target_xfer_status
8843 remote_target::remote_read_bytes (CORE_ADDR memaddr,
8844                                   gdb_byte *myaddr, ULONGEST len, int unit_size,
8845                                   ULONGEST *xfered_len)
8846 {
8847   if (len == 0)
8848     return TARGET_XFER_EOF;
8849
8850   if (get_traceframe_number () != -1)
8851     {
8852       std::vector<mem_range> available;
8853
8854       /* If we fail to get the set of available memory, then the
8855          target does not support querying traceframe info, and so we
8856          attempt reading from the traceframe anyway (assuming the
8857          target implements the old QTro packet then).  */
8858       if (traceframe_available_memory (&available, memaddr, len))
8859         {
8860           if (available.empty () || available[0].start != memaddr)
8861             {
8862               enum target_xfer_status res;
8863
8864               /* Don't read into the traceframe's available
8865                  memory.  */
8866               if (!available.empty ())
8867                 {
8868                   LONGEST oldlen = len;
8869
8870                   len = available[0].start - memaddr;
8871                   gdb_assert (len <= oldlen);
8872                 }
8873
8874               /* This goes through the topmost target again.  */
8875               res = remote_xfer_live_readonly_partial (myaddr, memaddr,
8876                                                        len, unit_size, xfered_len);
8877               if (res == TARGET_XFER_OK)
8878                 return TARGET_XFER_OK;
8879               else
8880                 {
8881                   /* No use trying further, we know some memory starting
8882                      at MEMADDR isn't available.  */
8883                   *xfered_len = len;
8884                   return (*xfered_len != 0) ?
8885                     TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF;
8886                 }
8887             }
8888
8889           /* Don't try to read more than how much is available, in
8890              case the target implements the deprecated QTro packet to
8891              cater for older GDBs (the target's knowledge of read-only
8892              sections may be outdated by now).  */
8893           len = available[0].length;
8894         }
8895     }
8896
8897   return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len);
8898 }
8899
8900 \f
8901
8902 /* Sends a packet with content determined by the printf format string
8903    FORMAT and the remaining arguments, then gets the reply.  Returns
8904    whether the packet was a success, a failure, or unknown.  */
8905
8906 packet_result
8907 remote_target::remote_send_printf (const char *format, ...)
8908 {
8909   struct remote_state *rs = get_remote_state ();
8910   int max_size = get_remote_packet_size ();
8911   va_list ap;
8912
8913   va_start (ap, format);
8914
8915   rs->buf[0] = '\0';
8916   int size = vsnprintf (rs->buf.data (), max_size, format, ap);
8917
8918   va_end (ap);
8919
8920   if (size >= max_size)
8921     internal_error (__FILE__, __LINE__, _("Too long remote packet."));
8922
8923   if (putpkt (rs->buf) < 0)
8924     error (_("Communication problem with target."));
8925
8926   rs->buf[0] = '\0';
8927   getpkt (&rs->buf, 0);
8928
8929   return packet_check_result (rs->buf);
8930 }
8931
8932 /* Flash writing can take quite some time.  We'll set
8933    effectively infinite timeout for flash operations.
8934    In future, we'll need to decide on a better approach.  */
8935 static const int remote_flash_timeout = 1000;
8936
8937 void
8938 remote_target::flash_erase (ULONGEST address, LONGEST length)
8939 {
8940   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
8941   enum packet_result ret;
8942   scoped_restore restore_timeout
8943     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8944
8945   ret = remote_send_printf ("vFlashErase:%s,%s",
8946                             phex (address, addr_size),
8947                             phex (length, 4));
8948   switch (ret)
8949     {
8950     case PACKET_UNKNOWN:
8951       error (_("Remote target does not support flash erase"));
8952     case PACKET_ERROR:
8953       error (_("Error erasing flash with vFlashErase packet"));
8954     default:
8955       break;
8956     }
8957 }
8958
8959 target_xfer_status
8960 remote_target::remote_flash_write (ULONGEST address,
8961                                    ULONGEST length, ULONGEST *xfered_len,
8962                                    const gdb_byte *data)
8963 {
8964   scoped_restore restore_timeout
8965     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8966   return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1,
8967                                  xfered_len,'X', 0);
8968 }
8969
8970 void
8971 remote_target::flash_done ()
8972 {
8973   int ret;
8974
8975   scoped_restore restore_timeout
8976     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8977
8978   ret = remote_send_printf ("vFlashDone");
8979
8980   switch (ret)
8981     {
8982     case PACKET_UNKNOWN:
8983       error (_("Remote target does not support vFlashDone"));
8984     case PACKET_ERROR:
8985       error (_("Error finishing flash operation"));
8986     default:
8987       break;
8988     }
8989 }
8990
8991 void
8992 remote_target::files_info ()
8993 {
8994   puts_filtered ("Debugging a target over a serial line.\n");
8995 }
8996 \f
8997 /* Stuff for dealing with the packets which are part of this protocol.
8998    See comment at top of file for details.  */
8999
9000 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
9001    error to higher layers.  Called when a serial error is detected.
9002    The exception message is STRING, followed by a colon and a blank,
9003    the system error message for errno at function entry and final dot
9004    for output compatibility with throw_perror_with_name.  */
9005
9006 static void
9007 unpush_and_perror (const char *string)
9008 {
9009   int saved_errno = errno;
9010
9011   remote_unpush_target ();
9012   throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
9013                safe_strerror (saved_errno));
9014 }
9015
9016 /* Read a single character from the remote end.  The current quit
9017    handler is overridden to avoid quitting in the middle of packet
9018    sequence, as that would break communication with the remote server.
9019    See remote_serial_quit_handler for more detail.  */
9020
9021 int
9022 remote_target::readchar (int timeout)
9023 {
9024   int ch;
9025   struct remote_state *rs = get_remote_state ();
9026
9027   {
9028     scoped_restore restore_quit_target
9029       = make_scoped_restore (&curr_quit_handler_target, this);
9030     scoped_restore restore_quit
9031       = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
9032
9033     rs->got_ctrlc_during_io = 0;
9034
9035     ch = serial_readchar (rs->remote_desc, timeout);
9036
9037     if (rs->got_ctrlc_during_io)
9038       set_quit_flag ();
9039   }
9040
9041   if (ch >= 0)
9042     return ch;
9043
9044   switch ((enum serial_rc) ch)
9045     {
9046     case SERIAL_EOF:
9047       remote_unpush_target ();
9048       throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
9049       /* no return */
9050     case SERIAL_ERROR:
9051       unpush_and_perror (_("Remote communication error.  "
9052                            "Target disconnected."));
9053       /* no return */
9054     case SERIAL_TIMEOUT:
9055       break;
9056     }
9057   return ch;
9058 }
9059
9060 /* Wrapper for serial_write that closes the target and throws if
9061    writing fails.  The current quit handler is overridden to avoid
9062    quitting in the middle of packet sequence, as that would break
9063    communication with the remote server.  See
9064    remote_serial_quit_handler for more detail.  */
9065
9066 void
9067 remote_target::remote_serial_write (const char *str, int len)
9068 {
9069   struct remote_state *rs = get_remote_state ();
9070
9071   scoped_restore restore_quit_target
9072     = make_scoped_restore (&curr_quit_handler_target, this);
9073   scoped_restore restore_quit
9074     = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
9075
9076   rs->got_ctrlc_during_io = 0;
9077
9078   if (serial_write (rs->remote_desc, str, len))
9079     {
9080       unpush_and_perror (_("Remote communication error.  "
9081                            "Target disconnected."));
9082     }
9083
9084   if (rs->got_ctrlc_during_io)
9085     set_quit_flag ();
9086 }
9087
9088 /* Return a string representing an escaped version of BUF, of len N.
9089    E.g. \n is converted to \\n, \t to \\t, etc.  */
9090
9091 static std::string
9092 escape_buffer (const char *buf, int n)
9093 {
9094   string_file stb;
9095
9096   stb.putstrn (buf, n, '\\');
9097   return std::move (stb.string ());
9098 }
9099
9100 /* Display a null-terminated packet on stdout, for debugging, using C
9101    string notation.  */
9102
9103 static void
9104 print_packet (const char *buf)
9105 {
9106   puts_filtered ("\"");
9107   fputstr_filtered (buf, '"', gdb_stdout);
9108   puts_filtered ("\"");
9109 }
9110
9111 int
9112 remote_target::putpkt (const char *buf)
9113 {
9114   return putpkt_binary (buf, strlen (buf));
9115 }
9116
9117 /* Wrapper around remote_target::putpkt to avoid exporting
9118    remote_target.  */
9119
9120 int
9121 putpkt (remote_target *remote, const char *buf)
9122 {
9123   return remote->putpkt (buf);
9124 }
9125
9126 /* Send a packet to the remote machine, with error checking.  The data
9127    of the packet is in BUF.  The string in BUF can be at most
9128    get_remote_packet_size () - 5 to account for the $, # and checksum,
9129    and for a possible /0 if we are debugging (remote_debug) and want
9130    to print the sent packet as a string.  */
9131
9132 int
9133 remote_target::putpkt_binary (const char *buf, int cnt)
9134 {
9135   struct remote_state *rs = get_remote_state ();
9136   int i;
9137   unsigned char csum = 0;
9138   gdb::def_vector<char> data (cnt + 6);
9139   char *buf2 = data.data ();
9140
9141   int ch;
9142   int tcount = 0;
9143   char *p;
9144
9145   /* Catch cases like trying to read memory or listing threads while
9146      we're waiting for a stop reply.  The remote server wouldn't be
9147      ready to handle this request, so we'd hang and timeout.  We don't
9148      have to worry about this in synchronous mode, because in that
9149      case it's not possible to issue a command while the target is
9150      running.  This is not a problem in non-stop mode, because in that
9151      case, the stub is always ready to process serial input.  */
9152   if (!target_is_non_stop_p ()
9153       && target_is_async_p ()
9154       && rs->waiting_for_stop_reply)
9155     {
9156       error (_("Cannot execute this command while the target is running.\n"
9157                "Use the \"interrupt\" command to stop the target\n"
9158                "and then try again."));
9159     }
9160
9161   /* We're sending out a new packet.  Make sure we don't look at a
9162      stale cached response.  */
9163   rs->cached_wait_status = 0;
9164
9165   /* Copy the packet into buffer BUF2, encapsulating it
9166      and giving it a checksum.  */
9167
9168   p = buf2;
9169   *p++ = '$';
9170
9171   for (i = 0; i < cnt; i++)
9172     {
9173       csum += buf[i];
9174       *p++ = buf[i];
9175     }
9176   *p++ = '#';
9177   *p++ = tohex ((csum >> 4) & 0xf);
9178   *p++ = tohex (csum & 0xf);
9179
9180   /* Send it over and over until we get a positive ack.  */
9181
9182   while (1)
9183     {
9184       int started_error_output = 0;
9185
9186       if (remote_debug)
9187         {
9188           *p = '\0';
9189
9190           int len = (int) (p - buf2);
9191
9192           std::string str
9193             = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
9194
9195           fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
9196
9197           if (len > REMOTE_DEBUG_MAX_CHAR)
9198             fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9199                                 len - REMOTE_DEBUG_MAX_CHAR);
9200
9201           fprintf_unfiltered (gdb_stdlog, "...");
9202
9203           gdb_flush (gdb_stdlog);
9204         }
9205       remote_serial_write (buf2, p - buf2);
9206
9207       /* If this is a no acks version of the remote protocol, send the
9208          packet and move on.  */
9209       if (rs->noack_mode)
9210         break;
9211
9212       /* Read until either a timeout occurs (-2) or '+' is read.
9213          Handle any notification that arrives in the mean time.  */
9214       while (1)
9215         {
9216           ch = readchar (remote_timeout);
9217
9218           if (remote_debug)
9219             {
9220               switch (ch)
9221                 {
9222                 case '+':
9223                 case '-':
9224                 case SERIAL_TIMEOUT:
9225                 case '$':
9226                 case '%':
9227                   if (started_error_output)
9228                     {
9229                       putchar_unfiltered ('\n');
9230                       started_error_output = 0;
9231                     }
9232                 }
9233             }
9234
9235           switch (ch)
9236             {
9237             case '+':
9238               if (remote_debug)
9239                 fprintf_unfiltered (gdb_stdlog, "Ack\n");
9240               return 1;
9241             case '-':
9242               if (remote_debug)
9243                 fprintf_unfiltered (gdb_stdlog, "Nak\n");
9244               /* FALLTHROUGH */
9245             case SERIAL_TIMEOUT:
9246               tcount++;
9247               if (tcount > 3)
9248                 return 0;
9249               break;            /* Retransmit buffer.  */
9250             case '$':
9251               {
9252                 if (remote_debug)
9253                   fprintf_unfiltered (gdb_stdlog,
9254                                       "Packet instead of Ack, ignoring it\n");
9255                 /* It's probably an old response sent because an ACK
9256                    was lost.  Gobble up the packet and ack it so it
9257                    doesn't get retransmitted when we resend this
9258                    packet.  */
9259                 skip_frame ();
9260                 remote_serial_write ("+", 1);
9261                 continue;       /* Now, go look for +.  */
9262               }
9263
9264             case '%':
9265               {
9266                 int val;
9267
9268                 /* If we got a notification, handle it, and go back to looking
9269                    for an ack.  */
9270                 /* We've found the start of a notification.  Now
9271                    collect the data.  */
9272                 val = read_frame (&rs->buf);
9273                 if (val >= 0)
9274                   {
9275                     if (remote_debug)
9276                       {
9277                         std::string str = escape_buffer (rs->buf.data (), val);
9278
9279                         fprintf_unfiltered (gdb_stdlog,
9280                                             "  Notification received: %s\n",
9281                                             str.c_str ());
9282                       }
9283                     handle_notification (rs->notif_state, rs->buf.data ());
9284                     /* We're in sync now, rewait for the ack.  */
9285                     tcount = 0;
9286                   }
9287                 else
9288                   {
9289                     if (remote_debug)
9290                       {
9291                         if (!started_error_output)
9292                           {
9293                             started_error_output = 1;
9294                             fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9295                           }
9296                         fputc_unfiltered (ch & 0177, gdb_stdlog);
9297                         fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ());
9298                       }
9299                   }
9300                 continue;
9301               }
9302               /* fall-through */
9303             default:
9304               if (remote_debug)
9305                 {
9306                   if (!started_error_output)
9307                     {
9308                       started_error_output = 1;
9309                       fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9310                     }
9311                   fputc_unfiltered (ch & 0177, gdb_stdlog);
9312                 }
9313               continue;
9314             }
9315           break;                /* Here to retransmit.  */
9316         }
9317
9318 #if 0
9319       /* This is wrong.  If doing a long backtrace, the user should be
9320          able to get out next time we call QUIT, without anything as
9321          violent as interrupt_query.  If we want to provide a way out of
9322          here without getting to the next QUIT, it should be based on
9323          hitting ^C twice as in remote_wait.  */
9324       if (quit_flag)
9325         {
9326           quit_flag = 0;
9327           interrupt_query ();
9328         }
9329 #endif
9330     }
9331
9332   return 0;
9333 }
9334
9335 /* Come here after finding the start of a frame when we expected an
9336    ack.  Do our best to discard the rest of this packet.  */
9337
9338 void
9339 remote_target::skip_frame ()
9340 {
9341   int c;
9342
9343   while (1)
9344     {
9345       c = readchar (remote_timeout);
9346       switch (c)
9347         {
9348         case SERIAL_TIMEOUT:
9349           /* Nothing we can do.  */
9350           return;
9351         case '#':
9352           /* Discard the two bytes of checksum and stop.  */
9353           c = readchar (remote_timeout);
9354           if (c >= 0)
9355             c = readchar (remote_timeout);
9356
9357           return;
9358         case '*':               /* Run length encoding.  */
9359           /* Discard the repeat count.  */
9360           c = readchar (remote_timeout);
9361           if (c < 0)
9362             return;
9363           break;
9364         default:
9365           /* A regular character.  */
9366           break;
9367         }
9368     }
9369 }
9370
9371 /* Come here after finding the start of the frame.  Collect the rest
9372    into *BUF, verifying the checksum, length, and handling run-length
9373    compression.  NUL terminate the buffer.  If there is not enough room,
9374    expand *BUF.
9375
9376    Returns -1 on error, number of characters in buffer (ignoring the
9377    trailing NULL) on success. (could be extended to return one of the
9378    SERIAL status indications).  */
9379
9380 long
9381 remote_target::read_frame (gdb::char_vector *buf_p)
9382 {
9383   unsigned char csum;
9384   long bc;
9385   int c;
9386   char *buf = buf_p->data ();
9387   struct remote_state *rs = get_remote_state ();
9388
9389   csum = 0;
9390   bc = 0;
9391
9392   while (1)
9393     {
9394       c = readchar (remote_timeout);
9395       switch (c)
9396         {
9397         case SERIAL_TIMEOUT:
9398           if (remote_debug)
9399             fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
9400           return -1;
9401         case '$':
9402           if (remote_debug)
9403             fputs_filtered ("Saw new packet start in middle of old one\n",
9404                             gdb_stdlog);
9405           return -1;            /* Start a new packet, count retries.  */
9406         case '#':
9407           {
9408             unsigned char pktcsum;
9409             int check_0 = 0;
9410             int check_1 = 0;
9411
9412             buf[bc] = '\0';
9413
9414             check_0 = readchar (remote_timeout);
9415             if (check_0 >= 0)
9416               check_1 = readchar (remote_timeout);
9417
9418             if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
9419               {
9420                 if (remote_debug)
9421                   fputs_filtered ("Timeout in checksum, retrying\n",
9422                                   gdb_stdlog);
9423                 return -1;
9424               }
9425             else if (check_0 < 0 || check_1 < 0)
9426               {
9427                 if (remote_debug)
9428                   fputs_filtered ("Communication error in checksum\n",
9429                                   gdb_stdlog);
9430                 return -1;
9431               }
9432
9433             /* Don't recompute the checksum; with no ack packets we
9434                don't have any way to indicate a packet retransmission
9435                is necessary.  */
9436             if (rs->noack_mode)
9437               return bc;
9438
9439             pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
9440             if (csum == pktcsum)
9441               return bc;
9442
9443             if (remote_debug)
9444               {
9445                 std::string str = escape_buffer (buf, bc);
9446
9447                 fprintf_unfiltered (gdb_stdlog,
9448                                     "Bad checksum, sentsum=0x%x, "
9449                                     "csum=0x%x, buf=%s\n",
9450                                     pktcsum, csum, str.c_str ());
9451               }
9452             /* Number of characters in buffer ignoring trailing
9453                NULL.  */
9454             return -1;
9455           }
9456         case '*':               /* Run length encoding.  */
9457           {
9458             int repeat;
9459
9460             csum += c;
9461             c = readchar (remote_timeout);
9462             csum += c;
9463             repeat = c - ' ' + 3;       /* Compute repeat count.  */
9464
9465             /* The character before ``*'' is repeated.  */
9466
9467             if (repeat > 0 && repeat <= 255 && bc > 0)
9468               {
9469                 if (bc + repeat - 1 >= buf_p->size () - 1)
9470                   {
9471                     /* Make some more room in the buffer.  */
9472                     buf_p->resize (buf_p->size () + repeat);
9473                     buf = buf_p->data ();
9474                   }
9475
9476                 memset (&buf[bc], buf[bc - 1], repeat);
9477                 bc += repeat;
9478                 continue;
9479               }
9480
9481             buf[bc] = '\0';
9482             printf_filtered (_("Invalid run length encoding: %s\n"), buf);
9483             return -1;
9484           }
9485         default:
9486           if (bc >= buf_p->size () - 1)
9487             {
9488               /* Make some more room in the buffer.  */
9489               buf_p->resize (buf_p->size () * 2);
9490               buf = buf_p->data ();
9491             }
9492
9493           buf[bc++] = c;
9494           csum += c;
9495           continue;
9496         }
9497     }
9498 }
9499
9500 /* Read a packet from the remote machine, with error checking, and
9501    store it in *BUF.  Resize *BUF if necessary to hold the result.  If
9502    FOREVER, wait forever rather than timing out; this is used (in
9503    synchronous mode) to wait for a target that is is executing user
9504    code to stop.  */
9505 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9506    don't have to change all the calls to getpkt to deal with the
9507    return value, because at the moment I don't know what the right
9508    thing to do it for those.  */
9509
9510 void
9511 remote_target::getpkt (gdb::char_vector *buf, int forever)
9512 {
9513   getpkt_sane (buf, forever);
9514 }
9515
9516
9517 /* Read a packet from the remote machine, with error checking, and
9518    store it in *BUF.  Resize *BUF if necessary to hold the result.  If
9519    FOREVER, wait forever rather than timing out; this is used (in
9520    synchronous mode) to wait for a target that is is executing user
9521    code to stop.  If FOREVER == 0, this function is allowed to time
9522    out gracefully and return an indication of this to the caller.
9523    Otherwise return the number of bytes read.  If EXPECTING_NOTIF,
9524    consider receiving a notification enough reason to return to the
9525    caller.  *IS_NOTIF is an output boolean that indicates whether *BUF
9526    holds a notification or not (a regular packet).  */
9527
9528 int
9529 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf,
9530                                        int forever, int expecting_notif,
9531                                        int *is_notif)
9532 {
9533   struct remote_state *rs = get_remote_state ();
9534   int c;
9535   int tries;
9536   int timeout;
9537   int val = -1;
9538
9539   /* We're reading a new response.  Make sure we don't look at a
9540      previously cached response.  */
9541   rs->cached_wait_status = 0;
9542
9543   strcpy (buf->data (), "timeout");
9544
9545   if (forever)
9546     timeout = watchdog > 0 ? watchdog : -1;
9547   else if (expecting_notif)
9548     timeout = 0; /* There should already be a char in the buffer.  If
9549                     not, bail out.  */
9550   else
9551     timeout = remote_timeout;
9552
9553 #define MAX_TRIES 3
9554
9555   /* Process any number of notifications, and then return when
9556      we get a packet.  */
9557   for (;;)
9558     {
9559       /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9560          times.  */
9561       for (tries = 1; tries <= MAX_TRIES; tries++)
9562         {
9563           /* This can loop forever if the remote side sends us
9564              characters continuously, but if it pauses, we'll get
9565              SERIAL_TIMEOUT from readchar because of timeout.  Then
9566              we'll count that as a retry.
9567
9568              Note that even when forever is set, we will only wait
9569              forever prior to the start of a packet.  After that, we
9570              expect characters to arrive at a brisk pace.  They should
9571              show up within remote_timeout intervals.  */
9572           do
9573             c = readchar (timeout);
9574           while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
9575
9576           if (c == SERIAL_TIMEOUT)
9577             {
9578               if (expecting_notif)
9579                 return -1; /* Don't complain, it's normal to not get
9580                               anything in this case.  */
9581
9582               if (forever)      /* Watchdog went off?  Kill the target.  */
9583                 {
9584                   remote_unpush_target ();
9585                   throw_error (TARGET_CLOSE_ERROR,
9586                                _("Watchdog timeout has expired.  "
9587                                  "Target detached."));
9588                 }
9589               if (remote_debug)
9590                 fputs_filtered ("Timed out.\n", gdb_stdlog);
9591             }
9592           else
9593             {
9594               /* We've found the start of a packet or notification.
9595                  Now collect the data.  */
9596               val = read_frame (buf);
9597               if (val >= 0)
9598                 break;
9599             }
9600
9601           remote_serial_write ("-", 1);
9602         }
9603
9604       if (tries > MAX_TRIES)
9605         {
9606           /* We have tried hard enough, and just can't receive the
9607              packet/notification.  Give up.  */
9608           printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9609
9610           /* Skip the ack char if we're in no-ack mode.  */
9611           if (!rs->noack_mode)
9612             remote_serial_write ("+", 1);
9613           return -1;
9614         }
9615
9616       /* If we got an ordinary packet, return that to our caller.  */
9617       if (c == '$')
9618         {
9619           if (remote_debug)
9620             {
9621               std::string str
9622                 = escape_buffer (buf->data (),
9623                                  std::min (val, REMOTE_DEBUG_MAX_CHAR));
9624
9625               fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
9626                                   str.c_str ());
9627
9628               if (val > REMOTE_DEBUG_MAX_CHAR)
9629                 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9630                                     val - REMOTE_DEBUG_MAX_CHAR);
9631
9632               fprintf_unfiltered (gdb_stdlog, "\n");
9633             }
9634
9635           /* Skip the ack char if we're in no-ack mode.  */
9636           if (!rs->noack_mode)
9637             remote_serial_write ("+", 1);
9638           if (is_notif != NULL)
9639             *is_notif = 0;
9640           return val;
9641         }
9642
9643        /* If we got a notification, handle it, and go back to looking
9644          for a packet.  */
9645       else
9646         {
9647           gdb_assert (c == '%');
9648
9649           if (remote_debug)
9650             {
9651               std::string str = escape_buffer (buf->data (), val);
9652
9653               fprintf_unfiltered (gdb_stdlog,
9654                                   "  Notification received: %s\n",
9655                                   str.c_str ());
9656             }
9657           if (is_notif != NULL)
9658             *is_notif = 1;
9659
9660           handle_notification (rs->notif_state, buf->data ());
9661
9662           /* Notifications require no acknowledgement.  */
9663
9664           if (expecting_notif)
9665             return val;
9666         }
9667     }
9668 }
9669
9670 int
9671 remote_target::getpkt_sane (gdb::char_vector *buf, int forever)
9672 {
9673   return getpkt_or_notif_sane_1 (buf, forever, 0, NULL);
9674 }
9675
9676 int
9677 remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
9678                                      int *is_notif)
9679 {
9680   return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif);
9681 }
9682
9683 /* Kill any new fork children of process PID that haven't been
9684    processed by follow_fork.  */
9685
9686 void
9687 remote_target::kill_new_fork_children (int pid)
9688 {
9689   remote_state *rs = get_remote_state ();
9690   struct notif_client *notif = &notif_client_stop;
9691
9692   /* Kill the fork child threads of any threads in process PID
9693      that are stopped at a fork event.  */
9694   for (thread_info *thread : all_non_exited_threads ())
9695     {
9696       struct target_waitstatus *ws = &thread->pending_follow;
9697
9698       if (is_pending_fork_parent (ws, pid, thread->ptid))
9699         {
9700           int child_pid = ws->value.related_pid.pid ();
9701           int res;
9702
9703           res = remote_vkill (child_pid);
9704           if (res != 0)
9705             error (_("Can't kill fork child process %d"), child_pid);
9706         }
9707     }
9708
9709   /* Check for any pending fork events (not reported or processed yet)
9710      in process PID and kill those fork child threads as well.  */
9711   remote_notif_get_pending_events (notif);
9712   for (auto &event : rs->stop_reply_queue)
9713     if (is_pending_fork_parent (&event->ws, pid, event->ptid))
9714       {
9715         int child_pid = event->ws.value.related_pid.pid ();
9716         int res;
9717
9718         res = remote_vkill (child_pid);
9719         if (res != 0)
9720           error (_("Can't kill fork child process %d"), child_pid);
9721       }
9722 }
9723
9724 \f
9725 /* Target hook to kill the current inferior.  */
9726
9727 void
9728 remote_target::kill ()
9729 {
9730   int res = -1;
9731   int pid = inferior_ptid.pid ();
9732   struct remote_state *rs = get_remote_state ();
9733
9734   if (packet_support (PACKET_vKill) != PACKET_DISABLE)
9735     {
9736       /* If we're stopped while forking and we haven't followed yet,
9737          kill the child task.  We need to do this before killing the
9738          parent task because if this is a vfork then the parent will
9739          be sleeping.  */
9740       kill_new_fork_children (pid);
9741
9742       res = remote_vkill (pid);
9743       if (res == 0)
9744         {
9745           target_mourn_inferior (inferior_ptid);
9746           return;
9747         }
9748     }
9749
9750   /* If we are in 'target remote' mode and we are killing the only
9751      inferior, then we will tell gdbserver to exit and unpush the
9752      target.  */
9753   if (res == -1 && !remote_multi_process_p (rs)
9754       && number_of_live_inferiors () == 1)
9755     {
9756       remote_kill_k ();
9757
9758       /* We've killed the remote end, we get to mourn it.  If we are
9759          not in extended mode, mourning the inferior also unpushes
9760          remote_ops from the target stack, which closes the remote
9761          connection.  */
9762       target_mourn_inferior (inferior_ptid);
9763
9764       return;
9765     }
9766
9767   error (_("Can't kill process"));
9768 }
9769
9770 /* Send a kill request to the target using the 'vKill' packet.  */
9771
9772 int
9773 remote_target::remote_vkill (int pid)
9774 {
9775   if (packet_support (PACKET_vKill) == PACKET_DISABLE)
9776     return -1;
9777
9778   remote_state *rs = get_remote_state ();
9779
9780   /* Tell the remote target to detach.  */
9781   xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid);
9782   putpkt (rs->buf);
9783   getpkt (&rs->buf, 0);
9784
9785   switch (packet_ok (rs->buf,
9786                      &remote_protocol_packets[PACKET_vKill]))
9787     {
9788     case PACKET_OK:
9789       return 0;
9790     case PACKET_ERROR:
9791       return 1;
9792     case PACKET_UNKNOWN:
9793       return -1;
9794     default:
9795       internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
9796     }
9797 }
9798
9799 /* Send a kill request to the target using the 'k' packet.  */
9800
9801 void
9802 remote_target::remote_kill_k ()
9803 {
9804   /* Catch errors so the user can quit from gdb even when we
9805      aren't on speaking terms with the remote system.  */
9806   TRY
9807     {
9808       putpkt ("k");
9809     }
9810   CATCH (ex, RETURN_MASK_ERROR)
9811     {
9812       if (ex.error == TARGET_CLOSE_ERROR)
9813         {
9814           /* If we got an (EOF) error that caused the target
9815              to go away, then we're done, that's what we wanted.
9816              "k" is susceptible to cause a premature EOF, given
9817              that the remote server isn't actually required to
9818              reply to "k", and it can happen that it doesn't
9819              even get to reply ACK to the "k".  */
9820           return;
9821         }
9822
9823       /* Otherwise, something went wrong.  We didn't actually kill
9824          the target.  Just propagate the exception, and let the
9825          user or higher layers decide what to do.  */
9826       throw_exception (ex);
9827     }
9828   END_CATCH
9829 }
9830
9831 void
9832 remote_target::mourn_inferior ()
9833 {
9834   struct remote_state *rs = get_remote_state ();
9835
9836   /* We're no longer interested in notification events of an inferior
9837      that exited or was killed/detached.  */
9838   discard_pending_stop_replies (current_inferior ());
9839
9840   /* In 'target remote' mode with one inferior, we close the connection.  */
9841   if (!rs->extended && number_of_live_inferiors () <= 1)
9842     {
9843       unpush_target (this);
9844
9845       /* remote_close takes care of doing most of the clean up.  */
9846       generic_mourn_inferior ();
9847       return;
9848     }
9849
9850   /* In case we got here due to an error, but we're going to stay
9851      connected.  */
9852   rs->waiting_for_stop_reply = 0;
9853
9854   /* If the current general thread belonged to the process we just
9855      detached from or has exited, the remote side current general
9856      thread becomes undefined.  Considering a case like this:
9857
9858      - We just got here due to a detach.
9859      - The process that we're detaching from happens to immediately
9860        report a global breakpoint being hit in non-stop mode, in the
9861        same thread we had selected before.
9862      - GDB attaches to this process again.
9863      - This event happens to be the next event we handle.
9864
9865      GDB would consider that the current general thread didn't need to
9866      be set on the stub side (with Hg), since for all it knew,
9867      GENERAL_THREAD hadn't changed.
9868
9869      Notice that although in all-stop mode, the remote server always
9870      sets the current thread to the thread reporting the stop event,
9871      that doesn't happen in non-stop mode; in non-stop, the stub *must
9872      not* change the current thread when reporting a breakpoint hit,
9873      due to the decoupling of event reporting and event handling.
9874
9875      To keep things simple, we always invalidate our notion of the
9876      current thread.  */
9877   record_currthread (rs, minus_one_ptid);
9878
9879   /* Call common code to mark the inferior as not running.  */
9880   generic_mourn_inferior ();
9881
9882   if (!have_inferiors ())
9883     {
9884       if (!remote_multi_process_p (rs))
9885         {
9886           /* Check whether the target is running now - some remote stubs
9887              automatically restart after kill.  */
9888           putpkt ("?");
9889           getpkt (&rs->buf, 0);
9890
9891           if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
9892             {
9893               /* Assume that the target has been restarted.  Set
9894                  inferior_ptid so that bits of core GDB realizes
9895                  there's something here, e.g., so that the user can
9896                  say "kill" again.  */
9897               inferior_ptid = magic_null_ptid;
9898             }
9899         }
9900     }
9901 }
9902
9903 bool
9904 extended_remote_target::supports_disable_randomization ()
9905 {
9906   return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
9907 }
9908
9909 void
9910 remote_target::extended_remote_disable_randomization (int val)
9911 {
9912   struct remote_state *rs = get_remote_state ();
9913   char *reply;
9914
9915   xsnprintf (rs->buf.data (), get_remote_packet_size (),
9916              "QDisableRandomization:%x", val);
9917   putpkt (rs->buf);
9918   reply = remote_get_noisy_reply ();
9919   if (*reply == '\0')
9920     error (_("Target does not support QDisableRandomization."));
9921   if (strcmp (reply, "OK") != 0)
9922     error (_("Bogus QDisableRandomization reply from target: %s"), reply);
9923 }
9924
9925 int
9926 remote_target::extended_remote_run (const std::string &args)
9927 {
9928   struct remote_state *rs = get_remote_state ();
9929   int len;
9930   const char *remote_exec_file = get_remote_exec_file ();
9931
9932   /* If the user has disabled vRun support, or we have detected that
9933      support is not available, do not try it.  */
9934   if (packet_support (PACKET_vRun) == PACKET_DISABLE)
9935     return -1;
9936
9937   strcpy (rs->buf.data (), "vRun;");
9938   len = strlen (rs->buf.data ());
9939
9940   if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
9941     error (_("Remote file name too long for run packet"));
9942   len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len,
9943                       strlen (remote_exec_file));
9944
9945   if (!args.empty ())
9946     {
9947       int i;
9948
9949       gdb_argv argv (args.c_str ());
9950       for (i = 0; argv[i] != NULL; i++)
9951         {
9952           if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
9953             error (_("Argument list too long for run packet"));
9954           rs->buf[len++] = ';';
9955           len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len,
9956                               strlen (argv[i]));
9957         }
9958     }
9959
9960   rs->buf[len++] = '\0';
9961
9962   putpkt (rs->buf);
9963   getpkt (&rs->buf, 0);
9964
9965   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
9966     {
9967     case PACKET_OK:
9968       /* We have a wait response.  All is well.  */
9969       return 0;
9970     case PACKET_UNKNOWN:
9971       return -1;
9972     case PACKET_ERROR:
9973       if (remote_exec_file[0] == '\0')
9974         error (_("Running the default executable on the remote target failed; "
9975                  "try \"set remote exec-file\"?"));
9976       else
9977         error (_("Running \"%s\" on the remote target failed"),
9978                remote_exec_file);
9979     default:
9980       gdb_assert_not_reached (_("bad switch"));
9981     }
9982 }
9983
9984 /* Helper function to send set/unset environment packets.  ACTION is
9985    either "set" or "unset".  PACKET is either "QEnvironmentHexEncoded"
9986    or "QEnvironmentUnsetVariable".  VALUE is the variable to be
9987    sent.  */
9988
9989 void
9990 remote_target::send_environment_packet (const char *action,
9991                                         const char *packet,
9992                                         const char *value)
9993 {
9994   remote_state *rs = get_remote_state ();
9995
9996   /* Convert the environment variable to an hex string, which
9997      is the best format to be transmitted over the wire.  */
9998   std::string encoded_value = bin2hex ((const gdb_byte *) value,
9999                                          strlen (value));
10000
10001   xsnprintf (rs->buf.data (), get_remote_packet_size (),
10002              "%s:%s", packet, encoded_value.c_str ());
10003
10004   putpkt (rs->buf);
10005   getpkt (&rs->buf, 0);
10006   if (strcmp (rs->buf.data (), "OK") != 0)
10007     warning (_("Unable to %s environment variable '%s' on remote."),
10008              action, value);
10009 }
10010
10011 /* Helper function to handle the QEnvironment* packets.  */
10012
10013 void
10014 remote_target::extended_remote_environment_support ()
10015 {
10016   remote_state *rs = get_remote_state ();
10017
10018   if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
10019     {
10020       putpkt ("QEnvironmentReset");
10021       getpkt (&rs->buf, 0);
10022       if (strcmp (rs->buf.data (), "OK") != 0)
10023         warning (_("Unable to reset environment on remote."));
10024     }
10025
10026   gdb_environ *e = &current_inferior ()->environment;
10027
10028   if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
10029     for (const std::string &el : e->user_set_env ())
10030       send_environment_packet ("set", "QEnvironmentHexEncoded",
10031                                el.c_str ());
10032
10033   if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
10034     for (const std::string &el : e->user_unset_env ())
10035       send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ());
10036 }
10037
10038 /* Helper function to set the current working directory for the
10039    inferior in the remote target.  */
10040
10041 void
10042 remote_target::extended_remote_set_inferior_cwd ()
10043 {
10044   if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
10045     {
10046       const char *inferior_cwd = get_inferior_cwd ();
10047       remote_state *rs = get_remote_state ();
10048
10049       if (inferior_cwd != NULL)
10050         {
10051           std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
10052                                          strlen (inferior_cwd));
10053
10054           xsnprintf (rs->buf.data (), get_remote_packet_size (),
10055                      "QSetWorkingDir:%s", hexpath.c_str ());
10056         }
10057       else
10058         {
10059           /* An empty inferior_cwd means that the user wants us to
10060              reset the remote server's inferior's cwd.  */
10061           xsnprintf (rs->buf.data (), get_remote_packet_size (),
10062                      "QSetWorkingDir:");
10063         }
10064
10065       putpkt (rs->buf);
10066       getpkt (&rs->buf, 0);
10067       if (packet_ok (rs->buf,
10068                      &remote_protocol_packets[PACKET_QSetWorkingDir])
10069           != PACKET_OK)
10070         error (_("\
10071 Remote replied unexpectedly while setting the inferior's working\n\
10072 directory: %s"),
10073                rs->buf.data ());
10074
10075     }
10076 }
10077
10078 /* In the extended protocol we want to be able to do things like
10079    "run" and have them basically work as expected.  So we need
10080    a special create_inferior function.  We support changing the
10081    executable file and the command line arguments, but not the
10082    environment.  */
10083
10084 void
10085 extended_remote_target::create_inferior (const char *exec_file,
10086                                          const std::string &args,
10087                                          char **env, int from_tty)
10088 {
10089   int run_worked;
10090   char *stop_reply;
10091   struct remote_state *rs = get_remote_state ();
10092   const char *remote_exec_file = get_remote_exec_file ();
10093
10094   /* If running asynchronously, register the target file descriptor
10095      with the event loop.  */
10096   if (target_can_async_p ())
10097     target_async (1);
10098
10099   /* Disable address space randomization if requested (and supported).  */
10100   if (supports_disable_randomization ())
10101     extended_remote_disable_randomization (disable_randomization);
10102
10103   /* If startup-with-shell is on, we inform gdbserver to start the
10104      remote inferior using a shell.  */
10105   if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
10106     {
10107       xsnprintf (rs->buf.data (), get_remote_packet_size (),
10108                  "QStartupWithShell:%d", startup_with_shell ? 1 : 0);
10109       putpkt (rs->buf);
10110       getpkt (&rs->buf, 0);
10111       if (strcmp (rs->buf.data (), "OK") != 0)
10112         error (_("\
10113 Remote replied unexpectedly while setting startup-with-shell: %s"),
10114                rs->buf.data ());
10115     }
10116
10117   extended_remote_environment_support ();
10118
10119   extended_remote_set_inferior_cwd ();
10120
10121   /* Now restart the remote server.  */
10122   run_worked = extended_remote_run (args) != -1;
10123   if (!run_worked)
10124     {
10125       /* vRun was not supported.  Fail if we need it to do what the
10126          user requested.  */
10127       if (remote_exec_file[0])
10128         error (_("Remote target does not support \"set remote exec-file\""));
10129       if (!args.empty ())
10130         error (_("Remote target does not support \"set args\" or run ARGS"));
10131
10132       /* Fall back to "R".  */
10133       extended_remote_restart ();
10134     }
10135
10136   /* vRun's success return is a stop reply.  */
10137   stop_reply = run_worked ? rs->buf.data () : NULL;
10138   add_current_inferior_and_thread (stop_reply);
10139
10140   /* Get updated offsets, if the stub uses qOffsets.  */
10141   get_offsets ();
10142 }
10143 \f
10144
10145 /* Given a location's target info BP_TGT and the packet buffer BUF,  output
10146    the list of conditions (in agent expression bytecode format), if any, the
10147    target needs to evaluate.  The output is placed into the packet buffer
10148    started from BUF and ended at BUF_END.  */
10149
10150 static int
10151 remote_add_target_side_condition (struct gdbarch *gdbarch,
10152                                   struct bp_target_info *bp_tgt, char *buf,
10153                                   char *buf_end)
10154 {
10155   if (bp_tgt->conditions.empty ())
10156     return 0;
10157
10158   buf += strlen (buf);
10159   xsnprintf (buf, buf_end - buf, "%s", ";");
10160   buf++;
10161
10162   /* Send conditions to the target.  */
10163   for (agent_expr *aexpr : bp_tgt->conditions)
10164     {
10165       xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
10166       buf += strlen (buf);
10167       for (int i = 0; i < aexpr->len; ++i)
10168         buf = pack_hex_byte (buf, aexpr->buf[i]);
10169       *buf = '\0';
10170     }
10171   return 0;
10172 }
10173
10174 static void
10175 remote_add_target_side_commands (struct gdbarch *gdbarch,
10176                                  struct bp_target_info *bp_tgt, char *buf)
10177 {
10178   if (bp_tgt->tcommands.empty ())
10179     return;
10180
10181   buf += strlen (buf);
10182
10183   sprintf (buf, ";cmds:%x,", bp_tgt->persist);
10184   buf += strlen (buf);
10185
10186   /* Concatenate all the agent expressions that are commands into the
10187      cmds parameter.  */
10188   for (agent_expr *aexpr : bp_tgt->tcommands)
10189     {
10190       sprintf (buf, "X%x,", aexpr->len);
10191       buf += strlen (buf);
10192       for (int i = 0; i < aexpr->len; ++i)
10193         buf = pack_hex_byte (buf, aexpr->buf[i]);
10194       *buf = '\0';
10195     }
10196 }
10197
10198 /* Insert a breakpoint.  On targets that have software breakpoint
10199    support, we ask the remote target to do the work; on targets
10200    which don't, we insert a traditional memory breakpoint.  */
10201
10202 int
10203 remote_target::insert_breakpoint (struct gdbarch *gdbarch,
10204                                   struct bp_target_info *bp_tgt)
10205 {
10206   /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10207      If it succeeds, then set the support to PACKET_ENABLE.  If it
10208      fails, and the user has explicitly requested the Z support then
10209      report an error, otherwise, mark it disabled and go on.  */
10210
10211   if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10212     {
10213       CORE_ADDR addr = bp_tgt->reqstd_address;
10214       struct remote_state *rs;
10215       char *p, *endbuf;
10216
10217       /* Make sure the remote is pointing at the right process, if
10218          necessary.  */
10219       if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10220         set_general_process ();
10221
10222       rs = get_remote_state ();
10223       p = rs->buf.data ();
10224       endbuf = p + get_remote_packet_size ();
10225
10226       *(p++) = 'Z';
10227       *(p++) = '0';
10228       *(p++) = ',';
10229       addr = (ULONGEST) remote_address_masked (addr);
10230       p += hexnumstr (p, addr);
10231       xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10232
10233       if (supports_evaluation_of_breakpoint_conditions ())
10234         remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10235
10236       if (can_run_breakpoint_commands ())
10237         remote_add_target_side_commands (gdbarch, bp_tgt, p);
10238
10239       putpkt (rs->buf);
10240       getpkt (&rs->buf, 0);
10241
10242       switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
10243         {
10244         case PACKET_ERROR:
10245           return -1;
10246         case PACKET_OK:
10247           return 0;
10248         case PACKET_UNKNOWN:
10249           break;
10250         }
10251     }
10252
10253   /* If this breakpoint has target-side commands but this stub doesn't
10254      support Z0 packets, throw error.  */
10255   if (!bp_tgt->tcommands.empty ())
10256     throw_error (NOT_SUPPORTED_ERROR, _("\
10257 Target doesn't support breakpoints that have target side commands."));
10258
10259   return memory_insert_breakpoint (this, gdbarch, bp_tgt);
10260 }
10261
10262 int
10263 remote_target::remove_breakpoint (struct gdbarch *gdbarch,
10264                                   struct bp_target_info *bp_tgt,
10265                                   enum remove_bp_reason reason)
10266 {
10267   CORE_ADDR addr = bp_tgt->placed_address;
10268   struct remote_state *rs = get_remote_state ();
10269
10270   if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10271     {
10272       char *p = rs->buf.data ();
10273       char *endbuf = p + get_remote_packet_size ();
10274
10275       /* Make sure the remote is pointing at the right process, if
10276          necessary.  */
10277       if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10278         set_general_process ();
10279
10280       *(p++) = 'z';
10281       *(p++) = '0';
10282       *(p++) = ',';
10283
10284       addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
10285       p += hexnumstr (p, addr);
10286       xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10287
10288       putpkt (rs->buf);
10289       getpkt (&rs->buf, 0);
10290
10291       return (rs->buf[0] == 'E');
10292     }
10293
10294   return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason);
10295 }
10296
10297 static enum Z_packet_type
10298 watchpoint_to_Z_packet (int type)
10299 {
10300   switch (type)
10301     {
10302     case hw_write:
10303       return Z_PACKET_WRITE_WP;
10304       break;
10305     case hw_read:
10306       return Z_PACKET_READ_WP;
10307       break;
10308     case hw_access:
10309       return Z_PACKET_ACCESS_WP;
10310       break;
10311     default:
10312       internal_error (__FILE__, __LINE__,
10313                       _("hw_bp_to_z: bad watchpoint type %d"), type);
10314     }
10315 }
10316
10317 int
10318 remote_target::insert_watchpoint (CORE_ADDR addr, int len,
10319                                   enum target_hw_bp_type type, struct expression *cond)
10320 {
10321   struct remote_state *rs = get_remote_state ();
10322   char *endbuf = rs->buf.data () + get_remote_packet_size ();
10323   char *p;
10324   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10325
10326   if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10327     return 1;
10328
10329   /* Make sure the remote is pointing at the right process, if
10330      necessary.  */
10331   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10332     set_general_process ();
10333
10334   xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet);
10335   p = strchr (rs->buf.data (), '\0');
10336   addr = remote_address_masked (addr);
10337   p += hexnumstr (p, (ULONGEST) addr);
10338   xsnprintf (p, endbuf - p, ",%x", len);
10339
10340   putpkt (rs->buf);
10341   getpkt (&rs->buf, 0);
10342
10343   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10344     {
10345     case PACKET_ERROR:
10346       return -1;
10347     case PACKET_UNKNOWN:
10348       return 1;
10349     case PACKET_OK:
10350       return 0;
10351     }
10352   internal_error (__FILE__, __LINE__,
10353                   _("remote_insert_watchpoint: reached end of function"));
10354 }
10355
10356 bool
10357 remote_target::watchpoint_addr_within_range (CORE_ADDR addr,
10358                                              CORE_ADDR start, int length)
10359 {
10360   CORE_ADDR diff = remote_address_masked (addr - start);
10361
10362   return diff < length;
10363 }
10364
10365
10366 int
10367 remote_target::remove_watchpoint (CORE_ADDR addr, int len,
10368                                   enum target_hw_bp_type type, struct expression *cond)
10369 {
10370   struct remote_state *rs = get_remote_state ();
10371   char *endbuf = rs->buf.data () + get_remote_packet_size ();
10372   char *p;
10373   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10374
10375   if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10376     return -1;
10377
10378   /* Make sure the remote is pointing at the right process, if
10379      necessary.  */
10380   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10381     set_general_process ();
10382
10383   xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet);
10384   p = strchr (rs->buf.data (), '\0');
10385   addr = remote_address_masked (addr);
10386   p += hexnumstr (p, (ULONGEST) addr);
10387   xsnprintf (p, endbuf - p, ",%x", len);
10388   putpkt (rs->buf);
10389   getpkt (&rs->buf, 0);
10390
10391   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10392     {
10393     case PACKET_ERROR:
10394     case PACKET_UNKNOWN:
10395       return -1;
10396     case PACKET_OK:
10397       return 0;
10398     }
10399   internal_error (__FILE__, __LINE__,
10400                   _("remote_remove_watchpoint: reached end of function"));
10401 }
10402
10403
10404 int remote_hw_watchpoint_limit = -1;
10405 int remote_hw_watchpoint_length_limit = -1;
10406 int remote_hw_breakpoint_limit = -1;
10407
10408 int
10409 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
10410 {
10411   if (remote_hw_watchpoint_length_limit == 0)
10412     return 0;
10413   else if (remote_hw_watchpoint_length_limit < 0)
10414     return 1;
10415   else if (len <= remote_hw_watchpoint_length_limit)
10416     return 1;
10417   else
10418     return 0;
10419 }
10420
10421 int
10422 remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot)
10423 {
10424   if (type == bp_hardware_breakpoint)
10425     {
10426       if (remote_hw_breakpoint_limit == 0)
10427         return 0;
10428       else if (remote_hw_breakpoint_limit < 0)
10429         return 1;
10430       else if (cnt <= remote_hw_breakpoint_limit)
10431         return 1;
10432     }
10433   else
10434     {
10435       if (remote_hw_watchpoint_limit == 0)
10436         return 0;
10437       else if (remote_hw_watchpoint_limit < 0)
10438         return 1;
10439       else if (ot)
10440         return -1;
10441       else if (cnt <= remote_hw_watchpoint_limit)
10442         return 1;
10443     }
10444   return -1;
10445 }
10446
10447 /* The to_stopped_by_sw_breakpoint method of target remote.  */
10448
10449 bool
10450 remote_target::stopped_by_sw_breakpoint ()
10451 {
10452   struct thread_info *thread = inferior_thread ();
10453
10454   return (thread->priv != NULL
10455           && (get_remote_thread_info (thread)->stop_reason
10456               == TARGET_STOPPED_BY_SW_BREAKPOINT));
10457 }
10458
10459 /* The to_supports_stopped_by_sw_breakpoint method of target
10460    remote.  */
10461
10462 bool
10463 remote_target::supports_stopped_by_sw_breakpoint ()
10464 {
10465   return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
10466 }
10467
10468 /* The to_stopped_by_hw_breakpoint method of target remote.  */
10469
10470 bool
10471 remote_target::stopped_by_hw_breakpoint ()
10472 {
10473   struct thread_info *thread = inferior_thread ();
10474
10475   return (thread->priv != NULL
10476           && (get_remote_thread_info (thread)->stop_reason
10477               == TARGET_STOPPED_BY_HW_BREAKPOINT));
10478 }
10479
10480 /* The to_supports_stopped_by_hw_breakpoint method of target
10481    remote.  */
10482
10483 bool
10484 remote_target::supports_stopped_by_hw_breakpoint ()
10485 {
10486   return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
10487 }
10488
10489 bool
10490 remote_target::stopped_by_watchpoint ()
10491 {
10492   struct thread_info *thread = inferior_thread ();
10493
10494   return (thread->priv != NULL
10495           && (get_remote_thread_info (thread)->stop_reason
10496               == TARGET_STOPPED_BY_WATCHPOINT));
10497 }
10498
10499 bool
10500 remote_target::stopped_data_address (CORE_ADDR *addr_p)
10501 {
10502   struct thread_info *thread = inferior_thread ();
10503
10504   if (thread->priv != NULL
10505       && (get_remote_thread_info (thread)->stop_reason
10506           == TARGET_STOPPED_BY_WATCHPOINT))
10507     {
10508       *addr_p = get_remote_thread_info (thread)->watch_data_address;
10509       return true;
10510     }
10511
10512   return false;
10513 }
10514
10515
10516 int
10517 remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
10518                                      struct bp_target_info *bp_tgt)
10519 {
10520   CORE_ADDR addr = bp_tgt->reqstd_address;
10521   struct remote_state *rs;
10522   char *p, *endbuf;
10523   char *message;
10524
10525   if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10526     return -1;
10527
10528   /* Make sure the remote is pointing at the right process, if
10529      necessary.  */
10530   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10531     set_general_process ();
10532
10533   rs = get_remote_state ();
10534   p = rs->buf.data ();
10535   endbuf = p + get_remote_packet_size ();
10536
10537   *(p++) = 'Z';
10538   *(p++) = '1';
10539   *(p++) = ',';
10540
10541   addr = remote_address_masked (addr);
10542   p += hexnumstr (p, (ULONGEST) addr);
10543   xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10544
10545   if (supports_evaluation_of_breakpoint_conditions ())
10546     remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10547
10548   if (can_run_breakpoint_commands ())
10549     remote_add_target_side_commands (gdbarch, bp_tgt, p);
10550
10551   putpkt (rs->buf);
10552   getpkt (&rs->buf, 0);
10553
10554   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10555     {
10556     case PACKET_ERROR:
10557       if (rs->buf[1] == '.')
10558         {
10559           message = strchr (&rs->buf[2], '.');
10560           if (message)
10561             error (_("Remote failure reply: %s"), message + 1);
10562         }
10563       return -1;
10564     case PACKET_UNKNOWN:
10565       return -1;
10566     case PACKET_OK:
10567       return 0;
10568     }
10569   internal_error (__FILE__, __LINE__,
10570                   _("remote_insert_hw_breakpoint: reached end of function"));
10571 }
10572
10573
10574 int
10575 remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
10576                                      struct bp_target_info *bp_tgt)
10577 {
10578   CORE_ADDR addr;
10579   struct remote_state *rs = get_remote_state ();
10580   char *p = rs->buf.data ();
10581   char *endbuf = p + get_remote_packet_size ();
10582
10583   if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10584     return -1;
10585
10586   /* Make sure the remote is pointing at the right process, if
10587      necessary.  */
10588   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10589     set_general_process ();
10590
10591   *(p++) = 'z';
10592   *(p++) = '1';
10593   *(p++) = ',';
10594
10595   addr = remote_address_masked (bp_tgt->placed_address);
10596   p += hexnumstr (p, (ULONGEST) addr);
10597   xsnprintf (p, endbuf  - p, ",%x", bp_tgt->kind);
10598
10599   putpkt (rs->buf);
10600   getpkt (&rs->buf, 0);
10601
10602   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10603     {
10604     case PACKET_ERROR:
10605     case PACKET_UNKNOWN:
10606       return -1;
10607     case PACKET_OK:
10608       return 0;
10609     }
10610   internal_error (__FILE__, __LINE__,
10611                   _("remote_remove_hw_breakpoint: reached end of function"));
10612 }
10613
10614 /* Verify memory using the "qCRC:" request.  */
10615
10616 int
10617 remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
10618 {
10619   struct remote_state *rs = get_remote_state ();
10620   unsigned long host_crc, target_crc;
10621   char *tmp;
10622
10623   /* It doesn't make sense to use qCRC if the remote target is
10624      connected but not running.  */
10625   if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
10626     {
10627       enum packet_result result;
10628
10629       /* Make sure the remote is pointing at the right process.  */
10630       set_general_process ();
10631
10632       /* FIXME: assumes lma can fit into long.  */
10633       xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10634                  (long) lma, (long) size);
10635       putpkt (rs->buf);
10636
10637       /* Be clever; compute the host_crc before waiting for target
10638          reply.  */
10639       host_crc = xcrc32 (data, size, 0xffffffff);
10640
10641       getpkt (&rs->buf, 0);
10642
10643       result = packet_ok (rs->buf,
10644                           &remote_protocol_packets[PACKET_qCRC]);
10645       if (result == PACKET_ERROR)
10646         return -1;
10647       else if (result == PACKET_OK)
10648         {
10649           for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
10650             target_crc = target_crc * 16 + fromhex (*tmp);
10651
10652           return (host_crc == target_crc);
10653         }
10654     }
10655
10656   return simple_verify_memory (this, data, lma, size);
10657 }
10658
10659 /* compare-sections command
10660
10661    With no arguments, compares each loadable section in the exec bfd
10662    with the same memory range on the target, and reports mismatches.
10663    Useful for verifying the image on the target against the exec file.  */
10664
10665 static void
10666 compare_sections_command (const char *args, int from_tty)
10667 {
10668   asection *s;
10669   const char *sectname;
10670   bfd_size_type size;
10671   bfd_vma lma;
10672   int matched = 0;
10673   int mismatched = 0;
10674   int res;
10675   int read_only = 0;
10676
10677   if (!exec_bfd)
10678     error (_("command cannot be used without an exec file"));
10679
10680   if (args != NULL && strcmp (args, "-r") == 0)
10681     {
10682       read_only = 1;
10683       args = NULL;
10684     }
10685
10686   for (s = exec_bfd->sections; s; s = s->next)
10687     {
10688       if (!(s->flags & SEC_LOAD))
10689         continue;               /* Skip non-loadable section.  */
10690
10691       if (read_only && (s->flags & SEC_READONLY) == 0)
10692         continue;               /* Skip writeable sections */
10693
10694       size = bfd_get_section_size (s);
10695       if (size == 0)
10696         continue;               /* Skip zero-length section.  */
10697
10698       sectname = bfd_get_section_name (exec_bfd, s);
10699       if (args && strcmp (args, sectname) != 0)
10700         continue;               /* Not the section selected by user.  */
10701
10702       matched = 1;              /* Do this section.  */
10703       lma = s->lma;
10704
10705       gdb::byte_vector sectdata (size);
10706       bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
10707
10708       res = target_verify_memory (sectdata.data (), lma, size);
10709
10710       if (res == -1)
10711         error (_("target memory fault, section %s, range %s -- %s"), sectname,
10712                paddress (target_gdbarch (), lma),
10713                paddress (target_gdbarch (), lma + size));
10714
10715       printf_filtered ("Section %s, range %s -- %s: ", sectname,
10716                        paddress (target_gdbarch (), lma),
10717                        paddress (target_gdbarch (), lma + size));
10718       if (res)
10719         printf_filtered ("matched.\n");
10720       else
10721         {
10722           printf_filtered ("MIS-MATCHED!\n");
10723           mismatched++;
10724         }
10725     }
10726   if (mismatched > 0)
10727     warning (_("One or more sections of the target image does not match\n\
10728 the loaded file\n"));
10729   if (args && !matched)
10730     printf_filtered (_("No loaded section named '%s'.\n"), args);
10731 }
10732
10733 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10734    into remote target.  The number of bytes written to the remote
10735    target is returned, or -1 for error.  */
10736
10737 target_xfer_status
10738 remote_target::remote_write_qxfer (const char *object_name,
10739                                    const char *annex, const gdb_byte *writebuf,
10740                                    ULONGEST offset, LONGEST len,
10741                                    ULONGEST *xfered_len,
10742                                    struct packet_config *packet)
10743 {
10744   int i, buf_len;
10745   ULONGEST n;
10746   struct remote_state *rs = get_remote_state ();
10747   int max_size = get_memory_write_packet_size (); 
10748
10749   if (packet_config_support (packet) == PACKET_DISABLE)
10750     return TARGET_XFER_E_IO;
10751
10752   /* Insert header.  */
10753   i = snprintf (rs->buf.data (), max_size, 
10754                 "qXfer:%s:write:%s:%s:",
10755                 object_name, annex ? annex : "",
10756                 phex_nz (offset, sizeof offset));
10757   max_size -= (i + 1);
10758
10759   /* Escape as much data as fits into rs->buf.  */
10760   buf_len = remote_escape_output 
10761     (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size);
10762
10763   if (putpkt_binary (rs->buf.data (), i + buf_len) < 0
10764       || getpkt_sane (&rs->buf, 0) < 0
10765       || packet_ok (rs->buf, packet) != PACKET_OK)
10766     return TARGET_XFER_E_IO;
10767
10768   unpack_varlen_hex (rs->buf.data (), &n);
10769
10770   *xfered_len = n;
10771   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
10772 }
10773
10774 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10775    Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10776    number of bytes read is returned, or 0 for EOF, or -1 for error.
10777    The number of bytes read may be less than LEN without indicating an
10778    EOF.  PACKET is checked and updated to indicate whether the remote
10779    target supports this object.  */
10780
10781 target_xfer_status
10782 remote_target::remote_read_qxfer (const char *object_name,
10783                                   const char *annex,
10784                                   gdb_byte *readbuf, ULONGEST offset,
10785                                   LONGEST len,
10786                                   ULONGEST *xfered_len,
10787                                   struct packet_config *packet)
10788 {
10789   struct remote_state *rs = get_remote_state ();
10790   LONGEST i, n, packet_len;
10791
10792   if (packet_config_support (packet) == PACKET_DISABLE)
10793     return TARGET_XFER_E_IO;
10794
10795   /* Check whether we've cached an end-of-object packet that matches
10796      this request.  */
10797   if (rs->finished_object)
10798     {
10799       if (strcmp (object_name, rs->finished_object) == 0
10800           && strcmp (annex ? annex : "", rs->finished_annex) == 0
10801           && offset == rs->finished_offset)
10802         return TARGET_XFER_EOF;
10803
10804
10805       /* Otherwise, we're now reading something different.  Discard
10806          the cache.  */
10807       xfree (rs->finished_object);
10808       xfree (rs->finished_annex);
10809       rs->finished_object = NULL;
10810       rs->finished_annex = NULL;
10811     }
10812
10813   /* Request only enough to fit in a single packet.  The actual data
10814      may not, since we don't know how much of it will need to be escaped;
10815      the target is free to respond with slightly less data.  We subtract
10816      five to account for the response type and the protocol frame.  */
10817   n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
10818   snprintf (rs->buf.data (), get_remote_packet_size () - 4,
10819             "qXfer:%s:read:%s:%s,%s",
10820             object_name, annex ? annex : "",
10821             phex_nz (offset, sizeof offset),
10822             phex_nz (n, sizeof n));
10823   i = putpkt (rs->buf);
10824   if (i < 0)
10825     return TARGET_XFER_E_IO;
10826
10827   rs->buf[0] = '\0';
10828   packet_len = getpkt_sane (&rs->buf, 0);
10829   if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
10830     return TARGET_XFER_E_IO;
10831
10832   if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
10833     error (_("Unknown remote qXfer reply: %s"), rs->buf.data ());
10834
10835   /* 'm' means there is (or at least might be) more data after this
10836      batch.  That does not make sense unless there's at least one byte
10837      of data in this reply.  */
10838   if (rs->buf[0] == 'm' && packet_len == 1)
10839     error (_("Remote qXfer reply contained no data."));
10840
10841   /* Got some data.  */
10842   i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1,
10843                              packet_len - 1, readbuf, n);
10844
10845   /* 'l' is an EOF marker, possibly including a final block of data,
10846      or possibly empty.  If we have the final block of a non-empty
10847      object, record this fact to bypass a subsequent partial read.  */
10848   if (rs->buf[0] == 'l' && offset + i > 0)
10849     {
10850       rs->finished_object = xstrdup (object_name);
10851       rs->finished_annex = xstrdup (annex ? annex : "");
10852       rs->finished_offset = offset + i;
10853     }
10854
10855   if (i == 0)
10856     return TARGET_XFER_EOF;
10857   else
10858     {
10859       *xfered_len = i;
10860       return TARGET_XFER_OK;
10861     }
10862 }
10863
10864 enum target_xfer_status
10865 remote_target::xfer_partial (enum target_object object,
10866                              const char *annex, gdb_byte *readbuf,
10867                              const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
10868                              ULONGEST *xfered_len)
10869 {
10870   struct remote_state *rs;
10871   int i;
10872   char *p2;
10873   char query_type;
10874   int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
10875
10876   set_remote_traceframe ();
10877   set_general_thread (inferior_ptid);
10878
10879   rs = get_remote_state ();
10880
10881   /* Handle memory using the standard memory routines.  */
10882   if (object == TARGET_OBJECT_MEMORY)
10883     {
10884       /* If the remote target is connected but not running, we should
10885          pass this request down to a lower stratum (e.g. the executable
10886          file).  */
10887       if (!target_has_execution)
10888         return TARGET_XFER_EOF;
10889
10890       if (writebuf != NULL)
10891         return remote_write_bytes (offset, writebuf, len, unit_size,
10892                                    xfered_len);
10893       else
10894         return remote_read_bytes (offset, readbuf, len, unit_size,
10895                                   xfered_len);
10896     }
10897
10898   /* Handle SPU memory using qxfer packets.  */
10899   if (object == TARGET_OBJECT_SPU)
10900     {
10901       if (readbuf)
10902         return remote_read_qxfer ("spu", annex, readbuf, offset, len,
10903                                   xfered_len, &remote_protocol_packets
10904                                   [PACKET_qXfer_spu_read]);
10905       else
10906         return remote_write_qxfer ("spu", annex, writebuf, offset, len,
10907                                    xfered_len, &remote_protocol_packets
10908                                    [PACKET_qXfer_spu_write]);
10909     }
10910
10911   /* Handle extra signal info using qxfer packets.  */
10912   if (object == TARGET_OBJECT_SIGNAL_INFO)
10913     {
10914       if (readbuf)
10915         return remote_read_qxfer ("siginfo", annex, readbuf, offset, len,
10916                                   xfered_len, &remote_protocol_packets
10917                                   [PACKET_qXfer_siginfo_read]);
10918       else
10919         return remote_write_qxfer ("siginfo", annex,
10920                                    writebuf, offset, len, xfered_len,
10921                                    &remote_protocol_packets
10922                                    [PACKET_qXfer_siginfo_write]);
10923     }
10924
10925   if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
10926     {
10927       if (readbuf)
10928         return remote_read_qxfer ("statictrace", annex,
10929                                   readbuf, offset, len, xfered_len,
10930                                   &remote_protocol_packets
10931                                   [PACKET_qXfer_statictrace_read]);
10932       else
10933         return TARGET_XFER_E_IO;
10934     }
10935
10936   /* Only handle flash writes.  */
10937   if (writebuf != NULL)
10938     {
10939       switch (object)
10940         {
10941         case TARGET_OBJECT_FLASH:
10942           return remote_flash_write (offset, len, xfered_len,
10943                                      writebuf);
10944
10945         default:
10946           return TARGET_XFER_E_IO;
10947         }
10948     }
10949
10950   /* Map pre-existing objects onto letters.  DO NOT do this for new
10951      objects!!!  Instead specify new query packets.  */
10952   switch (object)
10953     {
10954     case TARGET_OBJECT_AVR:
10955       query_type = 'R';
10956       break;
10957
10958     case TARGET_OBJECT_AUXV:
10959       gdb_assert (annex == NULL);
10960       return remote_read_qxfer ("auxv", annex, readbuf, offset, len,
10961                                 xfered_len,
10962                                 &remote_protocol_packets[PACKET_qXfer_auxv]);
10963
10964     case TARGET_OBJECT_AVAILABLE_FEATURES:
10965       return remote_read_qxfer
10966         ("features", annex, readbuf, offset, len, xfered_len,
10967          &remote_protocol_packets[PACKET_qXfer_features]);
10968
10969     case TARGET_OBJECT_LIBRARIES:
10970       return remote_read_qxfer
10971         ("libraries", annex, readbuf, offset, len, xfered_len,
10972          &remote_protocol_packets[PACKET_qXfer_libraries]);
10973
10974     case TARGET_OBJECT_LIBRARIES_SVR4:
10975       return remote_read_qxfer
10976         ("libraries-svr4", annex, readbuf, offset, len, xfered_len,
10977          &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
10978
10979     case TARGET_OBJECT_MEMORY_MAP:
10980       gdb_assert (annex == NULL);
10981       return remote_read_qxfer ("memory-map", annex, readbuf, offset, len,
10982                                  xfered_len,
10983                                 &remote_protocol_packets[PACKET_qXfer_memory_map]);
10984
10985     case TARGET_OBJECT_OSDATA:
10986       /* Should only get here if we're connected.  */
10987       gdb_assert (rs->remote_desc);
10988       return remote_read_qxfer
10989         ("osdata", annex, readbuf, offset, len, xfered_len,
10990         &remote_protocol_packets[PACKET_qXfer_osdata]);
10991
10992     case TARGET_OBJECT_THREADS:
10993       gdb_assert (annex == NULL);
10994       return remote_read_qxfer ("threads", annex, readbuf, offset, len,
10995                                 xfered_len,
10996                                 &remote_protocol_packets[PACKET_qXfer_threads]);
10997
10998     case TARGET_OBJECT_TRACEFRAME_INFO:
10999       gdb_assert (annex == NULL);
11000       return remote_read_qxfer
11001         ("traceframe-info", annex, readbuf, offset, len, xfered_len,
11002          &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
11003
11004     case TARGET_OBJECT_FDPIC:
11005       return remote_read_qxfer ("fdpic", annex, readbuf, offset, len,
11006                                 xfered_len,
11007                                 &remote_protocol_packets[PACKET_qXfer_fdpic]);
11008
11009     case TARGET_OBJECT_OPENVMS_UIB:
11010       return remote_read_qxfer ("uib", annex, readbuf, offset, len,
11011                                 xfered_len,
11012                                 &remote_protocol_packets[PACKET_qXfer_uib]);
11013
11014     case TARGET_OBJECT_BTRACE:
11015       return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
11016                                 xfered_len,
11017         &remote_protocol_packets[PACKET_qXfer_btrace]);
11018
11019     case TARGET_OBJECT_BTRACE_CONF:
11020       return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
11021                                 len, xfered_len,
11022         &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
11023
11024     case TARGET_OBJECT_EXEC_FILE:
11025       return remote_read_qxfer ("exec-file", annex, readbuf, offset,
11026                                 len, xfered_len,
11027         &remote_protocol_packets[PACKET_qXfer_exec_file]);
11028
11029     default:
11030       return TARGET_XFER_E_IO;
11031     }
11032
11033   /* Minimum outbuf size is get_remote_packet_size ().  If LEN is not
11034      large enough let the caller deal with it.  */
11035   if (len < get_remote_packet_size ())
11036     return TARGET_XFER_E_IO;
11037   len = get_remote_packet_size ();
11038
11039   /* Except for querying the minimum buffer size, target must be open.  */
11040   if (!rs->remote_desc)
11041     error (_("remote query is only available after target open"));
11042
11043   gdb_assert (annex != NULL);
11044   gdb_assert (readbuf != NULL);
11045
11046   p2 = rs->buf.data ();
11047   *p2++ = 'q';
11048   *p2++ = query_type;
11049
11050   /* We used one buffer char for the remote protocol q command and
11051      another for the query type.  As the remote protocol encapsulation
11052      uses 4 chars plus one extra in case we are debugging
11053      (remote_debug), we have PBUFZIZ - 7 left to pack the query
11054      string.  */
11055   i = 0;
11056   while (annex[i] && (i < (get_remote_packet_size () - 8)))
11057     {
11058       /* Bad caller may have sent forbidden characters.  */
11059       gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
11060       *p2++ = annex[i];
11061       i++;
11062     }
11063   *p2 = '\0';
11064   gdb_assert (annex[i] == '\0');
11065
11066   i = putpkt (rs->buf);
11067   if (i < 0)
11068     return TARGET_XFER_E_IO;
11069
11070   getpkt (&rs->buf, 0);
11071   strcpy ((char *) readbuf, rs->buf.data ());
11072
11073   *xfered_len = strlen ((char *) readbuf);
11074   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
11075 }
11076
11077 /* Implementation of to_get_memory_xfer_limit.  */
11078
11079 ULONGEST
11080 remote_target::get_memory_xfer_limit ()
11081 {
11082   return get_memory_write_packet_size ();
11083 }
11084
11085 int
11086 remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
11087                               const gdb_byte *pattern, ULONGEST pattern_len,
11088                               CORE_ADDR *found_addrp)
11089 {
11090   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
11091   struct remote_state *rs = get_remote_state ();
11092   int max_size = get_memory_write_packet_size ();
11093   struct packet_config *packet =
11094     &remote_protocol_packets[PACKET_qSearch_memory];
11095   /* Number of packet bytes used to encode the pattern;
11096      this could be more than PATTERN_LEN due to escape characters.  */
11097   int escaped_pattern_len;
11098   /* Amount of pattern that was encodable in the packet.  */
11099   int used_pattern_len;
11100   int i;
11101   int found;
11102   ULONGEST found_addr;
11103
11104   /* Don't go to the target if we don't have to.  This is done before
11105      checking packet_config_support to avoid the possibility that a
11106      success for this edge case means the facility works in
11107      general.  */
11108   if (pattern_len > search_space_len)
11109     return 0;
11110   if (pattern_len == 0)
11111     {
11112       *found_addrp = start_addr;
11113       return 1;
11114     }
11115
11116   /* If we already know the packet isn't supported, fall back to the simple
11117      way of searching memory.  */
11118
11119   if (packet_config_support (packet) == PACKET_DISABLE)
11120     {
11121       /* Target doesn't provided special support, fall back and use the
11122          standard support (copy memory and do the search here).  */
11123       return simple_search_memory (this, start_addr, search_space_len,
11124                                    pattern, pattern_len, found_addrp);
11125     }
11126
11127   /* Make sure the remote is pointing at the right process.  */
11128   set_general_process ();
11129
11130   /* Insert header.  */
11131   i = snprintf (rs->buf.data (), max_size, 
11132                 "qSearch:memory:%s;%s;",
11133                 phex_nz (start_addr, addr_size),
11134                 phex_nz (search_space_len, sizeof (search_space_len)));
11135   max_size -= (i + 1);
11136
11137   /* Escape as much data as fits into rs->buf.  */
11138   escaped_pattern_len =
11139     remote_escape_output (pattern, pattern_len, 1,
11140                           (gdb_byte *) rs->buf.data () + i,
11141                           &used_pattern_len, max_size);
11142
11143   /* Bail if the pattern is too large.  */
11144   if (used_pattern_len != pattern_len)
11145     error (_("Pattern is too large to transmit to remote target."));
11146
11147   if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0
11148       || getpkt_sane (&rs->buf, 0) < 0
11149       || packet_ok (rs->buf, packet) != PACKET_OK)
11150     {
11151       /* The request may not have worked because the command is not
11152          supported.  If so, fall back to the simple way.  */
11153       if (packet_config_support (packet) == PACKET_DISABLE)
11154         {
11155           return simple_search_memory (this, start_addr, search_space_len,
11156                                        pattern, pattern_len, found_addrp);
11157         }
11158       return -1;
11159     }
11160
11161   if (rs->buf[0] == '0')
11162     found = 0;
11163   else if (rs->buf[0] == '1')
11164     {
11165       found = 1;
11166       if (rs->buf[1] != ',')
11167         error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
11168       unpack_varlen_hex (&rs->buf[2], &found_addr);
11169       *found_addrp = found_addr;
11170     }
11171   else
11172     error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
11173
11174   return found;
11175 }
11176
11177 void
11178 remote_target::rcmd (const char *command, struct ui_file *outbuf)
11179 {
11180   struct remote_state *rs = get_remote_state ();
11181   char *p = rs->buf.data ();
11182
11183   if (!rs->remote_desc)
11184     error (_("remote rcmd is only available after target open"));
11185
11186   /* Send a NULL command across as an empty command.  */
11187   if (command == NULL)
11188     command = "";
11189
11190   /* The query prefix.  */
11191   strcpy (rs->buf.data (), "qRcmd,");
11192   p = strchr (rs->buf.data (), '\0');
11193
11194   if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/)
11195       > get_remote_packet_size ())
11196     error (_("\"monitor\" command ``%s'' is too long."), command);
11197
11198   /* Encode the actual command.  */
11199   bin2hex ((const gdb_byte *) command, p, strlen (command));
11200
11201   if (putpkt (rs->buf) < 0)
11202     error (_("Communication problem with target."));
11203
11204   /* get/display the response */
11205   while (1)
11206     {
11207       char *buf;
11208
11209       /* XXX - see also remote_get_noisy_reply().  */
11210       QUIT;                     /* Allow user to bail out with ^C.  */
11211       rs->buf[0] = '\0';
11212       if (getpkt_sane (&rs->buf, 0) == -1)
11213         { 
11214           /* Timeout.  Continue to (try to) read responses.
11215              This is better than stopping with an error, assuming the stub
11216              is still executing the (long) monitor command.
11217              If needed, the user can interrupt gdb using C-c, obtaining
11218              an effect similar to stop on timeout.  */
11219           continue;
11220         }
11221       buf = rs->buf.data ();
11222       if (buf[0] == '\0')
11223         error (_("Target does not support this command."));
11224       if (buf[0] == 'O' && buf[1] != 'K')
11225         {
11226           remote_console_output (buf + 1); /* 'O' message from stub.  */
11227           continue;
11228         }
11229       if (strcmp (buf, "OK") == 0)
11230         break;
11231       if (strlen (buf) == 3 && buf[0] == 'E'
11232           && isdigit (buf[1]) && isdigit (buf[2]))
11233         {
11234           error (_("Protocol error with Rcmd"));
11235         }
11236       for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
11237         {
11238           char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
11239
11240           fputc_unfiltered (c, outbuf);
11241         }
11242       break;
11243     }
11244 }
11245
11246 std::vector<mem_region>
11247 remote_target::memory_map ()
11248 {
11249   std::vector<mem_region> result;
11250   gdb::optional<gdb::char_vector> text
11251     = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL);
11252
11253   if (text)
11254     result = parse_memory_map (text->data ());
11255
11256   return result;
11257 }
11258
11259 static void
11260 packet_command (const char *args, int from_tty)
11261 {
11262   remote_target *remote = get_current_remote_target ();
11263
11264   if (remote == nullptr)
11265     error (_("command can only be used with remote target"));
11266
11267   remote->packet_command (args, from_tty);
11268 }
11269
11270 void
11271 remote_target::packet_command (const char *args, int from_tty)
11272 {
11273   if (!args)
11274     error (_("remote-packet command requires packet text as argument"));
11275
11276   puts_filtered ("sending: ");
11277   print_packet (args);
11278   puts_filtered ("\n");
11279   putpkt (args);
11280
11281   remote_state *rs = get_remote_state ();
11282
11283   getpkt (&rs->buf, 0);
11284   puts_filtered ("received: ");
11285   print_packet (rs->buf.data ());
11286   puts_filtered ("\n");
11287 }
11288
11289 #if 0
11290 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11291
11292 static void display_thread_info (struct gdb_ext_thread_info *info);
11293
11294 static void threadset_test_cmd (char *cmd, int tty);
11295
11296 static void threadalive_test (char *cmd, int tty);
11297
11298 static void threadlist_test_cmd (char *cmd, int tty);
11299
11300 int get_and_display_threadinfo (threadref *ref);
11301
11302 static void threadinfo_test_cmd (char *cmd, int tty);
11303
11304 static int thread_display_step (threadref *ref, void *context);
11305
11306 static void threadlist_update_test_cmd (char *cmd, int tty);
11307
11308 static void init_remote_threadtests (void);
11309
11310 #define SAMPLE_THREAD  0x05060708       /* Truncated 64 bit threadid.  */
11311
11312 static void
11313 threadset_test_cmd (const char *cmd, int tty)
11314 {
11315   int sample_thread = SAMPLE_THREAD;
11316
11317   printf_filtered (_("Remote threadset test\n"));
11318   set_general_thread (sample_thread);
11319 }
11320
11321
11322 static void
11323 threadalive_test (const char *cmd, int tty)
11324 {
11325   int sample_thread = SAMPLE_THREAD;
11326   int pid = inferior_ptid.pid ();
11327   ptid_t ptid = ptid_t (pid, sample_thread, 0);
11328
11329   if (remote_thread_alive (ptid))
11330     printf_filtered ("PASS: Thread alive test\n");
11331   else
11332     printf_filtered ("FAIL: Thread alive test\n");
11333 }
11334
11335 void output_threadid (char *title, threadref *ref);
11336
11337 void
11338 output_threadid (char *title, threadref *ref)
11339 {
11340   char hexid[20];
11341
11342   pack_threadid (&hexid[0], ref);       /* Convert threead id into hex.  */
11343   hexid[16] = 0;
11344   printf_filtered ("%s  %s\n", title, (&hexid[0]));
11345 }
11346
11347 static void
11348 threadlist_test_cmd (const char *cmd, int tty)
11349 {
11350   int startflag = 1;
11351   threadref nextthread;
11352   int done, result_count;
11353   threadref threadlist[3];
11354
11355   printf_filtered ("Remote Threadlist test\n");
11356   if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
11357                               &result_count, &threadlist[0]))
11358     printf_filtered ("FAIL: threadlist test\n");
11359   else
11360     {
11361       threadref *scan = threadlist;
11362       threadref *limit = scan + result_count;
11363
11364       while (scan < limit)
11365         output_threadid (" thread ", scan++);
11366     }
11367 }
11368
11369 void
11370 display_thread_info (struct gdb_ext_thread_info *info)
11371 {
11372   output_threadid ("Threadid: ", &info->threadid);
11373   printf_filtered ("Name: %s\n ", info->shortname);
11374   printf_filtered ("State: %s\n", info->display);
11375   printf_filtered ("other: %s\n\n", info->more_display);
11376 }
11377
11378 int
11379 get_and_display_threadinfo (threadref *ref)
11380 {
11381   int result;
11382   int set;
11383   struct gdb_ext_thread_info threadinfo;
11384
11385   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
11386     | TAG_MOREDISPLAY | TAG_DISPLAY;
11387   if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
11388     display_thread_info (&threadinfo);
11389   return result;
11390 }
11391
11392 static void
11393 threadinfo_test_cmd (const char *cmd, int tty)
11394 {
11395   int athread = SAMPLE_THREAD;
11396   threadref thread;
11397   int set;
11398
11399   int_to_threadref (&thread, athread);
11400   printf_filtered ("Remote Threadinfo test\n");
11401   if (!get_and_display_threadinfo (&thread))
11402     printf_filtered ("FAIL cannot get thread info\n");
11403 }
11404
11405 static int
11406 thread_display_step (threadref *ref, void *context)
11407 {
11408   /* output_threadid(" threadstep ",ref); *//* simple test */
11409   return get_and_display_threadinfo (ref);
11410 }
11411
11412 static void
11413 threadlist_update_test_cmd (const char *cmd, int tty)
11414 {
11415   printf_filtered ("Remote Threadlist update test\n");
11416   remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
11417 }
11418
11419 static void
11420 init_remote_threadtests (void)
11421 {
11422   add_com ("tlist", class_obscure, threadlist_test_cmd,
11423            _("Fetch and print the remote list of "
11424              "thread identifiers, one pkt only"));
11425   add_com ("tinfo", class_obscure, threadinfo_test_cmd,
11426            _("Fetch and display info about one thread"));
11427   add_com ("tset", class_obscure, threadset_test_cmd,
11428            _("Test setting to a different thread"));
11429   add_com ("tupd", class_obscure, threadlist_update_test_cmd,
11430            _("Iterate through updating all remote thread info"));
11431   add_com ("talive", class_obscure, threadalive_test,
11432            _(" Remote thread alive test "));
11433 }
11434
11435 #endif /* 0 */
11436
11437 /* Convert a thread ID to a string.  Returns the string in a static
11438    buffer.  */
11439
11440 const char *
11441 remote_target::pid_to_str (ptid_t ptid)
11442 {
11443   static char buf[64];
11444   struct remote_state *rs = get_remote_state ();
11445
11446   if (ptid == null_ptid)
11447     return normal_pid_to_str (ptid);
11448   else if (ptid.is_pid ())
11449     {
11450       /* Printing an inferior target id.  */
11451
11452       /* When multi-process extensions are off, there's no way in the
11453          remote protocol to know the remote process id, if there's any
11454          at all.  There's one exception --- when we're connected with
11455          target extended-remote, and we manually attached to a process
11456          with "attach PID".  We don't record anywhere a flag that
11457          allows us to distinguish that case from the case of
11458          connecting with extended-remote and the stub already being
11459          attached to a process, and reporting yes to qAttached, hence
11460          no smart special casing here.  */
11461       if (!remote_multi_process_p (rs))
11462         {
11463           xsnprintf (buf, sizeof buf, "Remote target");
11464           return buf;
11465         }
11466
11467       return normal_pid_to_str (ptid);
11468     }
11469   else
11470     {
11471       if (magic_null_ptid == ptid)
11472         xsnprintf (buf, sizeof buf, "Thread <main>");
11473       else if (remote_multi_process_p (rs))
11474         if (ptid.lwp () == 0)
11475           return normal_pid_to_str (ptid);
11476         else
11477           xsnprintf (buf, sizeof buf, "Thread %d.%ld",
11478                      ptid.pid (), ptid.lwp ());
11479       else
11480         xsnprintf (buf, sizeof buf, "Thread %ld",
11481                    ptid.lwp ());
11482       return buf;
11483     }
11484 }
11485
11486 /* Get the address of the thread local variable in OBJFILE which is
11487    stored at OFFSET within the thread local storage for thread PTID.  */
11488
11489 CORE_ADDR
11490 remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
11491                                          CORE_ADDR offset)
11492 {
11493   if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
11494     {
11495       struct remote_state *rs = get_remote_state ();
11496       char *p = rs->buf.data ();
11497       char *endp = p + get_remote_packet_size ();
11498       enum packet_result result;
11499
11500       strcpy (p, "qGetTLSAddr:");
11501       p += strlen (p);
11502       p = write_ptid (p, endp, ptid);
11503       *p++ = ',';
11504       p += hexnumstr (p, offset);
11505       *p++ = ',';
11506       p += hexnumstr (p, lm);
11507       *p++ = '\0';
11508
11509       putpkt (rs->buf);
11510       getpkt (&rs->buf, 0);
11511       result = packet_ok (rs->buf,
11512                           &remote_protocol_packets[PACKET_qGetTLSAddr]);
11513       if (result == PACKET_OK)
11514         {
11515           ULONGEST addr;
11516
11517           unpack_varlen_hex (rs->buf.data (), &addr);
11518           return addr;
11519         }
11520       else if (result == PACKET_UNKNOWN)
11521         throw_error (TLS_GENERIC_ERROR,
11522                      _("Remote target doesn't support qGetTLSAddr packet"));
11523       else
11524         throw_error (TLS_GENERIC_ERROR,
11525                      _("Remote target failed to process qGetTLSAddr request"));
11526     }
11527   else
11528     throw_error (TLS_GENERIC_ERROR,
11529                  _("TLS not supported or disabled on this target"));
11530   /* Not reached.  */
11531   return 0;
11532 }
11533
11534 /* Provide thread local base, i.e. Thread Information Block address.
11535    Returns 1 if ptid is found and thread_local_base is non zero.  */
11536
11537 bool
11538 remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
11539 {
11540   if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
11541     {
11542       struct remote_state *rs = get_remote_state ();
11543       char *p = rs->buf.data ();
11544       char *endp = p + get_remote_packet_size ();
11545       enum packet_result result;
11546
11547       strcpy (p, "qGetTIBAddr:");
11548       p += strlen (p);
11549       p = write_ptid (p, endp, ptid);
11550       *p++ = '\0';
11551
11552       putpkt (rs->buf);
11553       getpkt (&rs->buf, 0);
11554       result = packet_ok (rs->buf,
11555                           &remote_protocol_packets[PACKET_qGetTIBAddr]);
11556       if (result == PACKET_OK)
11557         {
11558           ULONGEST val;
11559           unpack_varlen_hex (rs->buf.data (), &val);
11560           if (addr)
11561             *addr = (CORE_ADDR) val;
11562           return true;
11563         }
11564       else if (result == PACKET_UNKNOWN)
11565         error (_("Remote target doesn't support qGetTIBAddr packet"));
11566       else
11567         error (_("Remote target failed to process qGetTIBAddr request"));
11568     }
11569   else
11570     error (_("qGetTIBAddr not supported or disabled on this target"));
11571   /* Not reached.  */
11572   return false;
11573 }
11574
11575 /* Support for inferring a target description based on the current
11576    architecture and the size of a 'g' packet.  While the 'g' packet
11577    can have any size (since optional registers can be left off the
11578    end), some sizes are easily recognizable given knowledge of the
11579    approximate architecture.  */
11580
11581 struct remote_g_packet_guess
11582 {
11583   remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_)
11584     : bytes (bytes_),
11585       tdesc (tdesc_)
11586   {
11587   }
11588
11589   int bytes;
11590   const struct target_desc *tdesc;
11591 };
11592
11593 struct remote_g_packet_data : public allocate_on_obstack
11594 {
11595   std::vector<remote_g_packet_guess> guesses;
11596 };
11597
11598 static struct gdbarch_data *remote_g_packet_data_handle;
11599
11600 static void *
11601 remote_g_packet_data_init (struct obstack *obstack)
11602 {
11603   return new (obstack) remote_g_packet_data;
11604 }
11605
11606 void
11607 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
11608                                 const struct target_desc *tdesc)
11609 {
11610   struct remote_g_packet_data *data
11611     = ((struct remote_g_packet_data *)
11612        gdbarch_data (gdbarch, remote_g_packet_data_handle));
11613
11614   gdb_assert (tdesc != NULL);
11615
11616   for (const remote_g_packet_guess &guess : data->guesses)
11617     if (guess.bytes == bytes)
11618       internal_error (__FILE__, __LINE__,
11619                       _("Duplicate g packet description added for size %d"),
11620                       bytes);
11621
11622   data->guesses.emplace_back (bytes, tdesc);
11623 }
11624
11625 /* Return true if remote_read_description would do anything on this target
11626    and architecture, false otherwise.  */
11627
11628 static bool
11629 remote_read_description_p (struct target_ops *target)
11630 {
11631   struct remote_g_packet_data *data
11632     = ((struct remote_g_packet_data *)
11633        gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11634
11635   return !data->guesses.empty ();
11636 }
11637
11638 const struct target_desc *
11639 remote_target::read_description ()
11640 {
11641   struct remote_g_packet_data *data
11642     = ((struct remote_g_packet_data *)
11643        gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11644
11645   /* Do not try this during initial connection, when we do not know
11646      whether there is a running but stopped thread.  */
11647   if (!target_has_execution || inferior_ptid == null_ptid)
11648     return beneath ()->read_description ();
11649
11650   if (!data->guesses.empty ())
11651     {
11652       int bytes = send_g_packet ();
11653
11654       for (const remote_g_packet_guess &guess : data->guesses)
11655         if (guess.bytes == bytes)
11656           return guess.tdesc;
11657
11658       /* We discard the g packet.  A minor optimization would be to
11659          hold on to it, and fill the register cache once we have selected
11660          an architecture, but it's too tricky to do safely.  */
11661     }
11662
11663   return beneath ()->read_description ();
11664 }
11665
11666 /* Remote file transfer support.  This is host-initiated I/O, not
11667    target-initiated; for target-initiated, see remote-fileio.c.  */
11668
11669 /* If *LEFT is at least the length of STRING, copy STRING to
11670    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11671    decrease *LEFT.  Otherwise raise an error.  */
11672
11673 static void
11674 remote_buffer_add_string (char **buffer, int *left, const char *string)
11675 {
11676   int len = strlen (string);
11677
11678   if (len > *left)
11679     error (_("Packet too long for target."));
11680
11681   memcpy (*buffer, string, len);
11682   *buffer += len;
11683   *left -= len;
11684
11685   /* NUL-terminate the buffer as a convenience, if there is
11686      room.  */
11687   if (*left)
11688     **buffer = '\0';
11689 }
11690
11691 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11692    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11693    decrease *LEFT.  Otherwise raise an error.  */
11694
11695 static void
11696 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
11697                          int len)
11698 {
11699   if (2 * len > *left)
11700     error (_("Packet too long for target."));
11701
11702   bin2hex (bytes, *buffer, len);
11703   *buffer += 2 * len;
11704   *left -= 2 * len;
11705
11706   /* NUL-terminate the buffer as a convenience, if there is
11707      room.  */
11708   if (*left)
11709     **buffer = '\0';
11710 }
11711
11712 /* If *LEFT is large enough, convert VALUE to hex and add it to
11713    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11714    decrease *LEFT.  Otherwise raise an error.  */
11715
11716 static void
11717 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
11718 {
11719   int len = hexnumlen (value);
11720
11721   if (len > *left)
11722     error (_("Packet too long for target."));
11723
11724   hexnumstr (*buffer, value);
11725   *buffer += len;
11726   *left -= len;
11727
11728   /* NUL-terminate the buffer as a convenience, if there is
11729      room.  */
11730   if (*left)
11731     **buffer = '\0';
11732 }
11733
11734 /* Parse an I/O result packet from BUFFER.  Set RETCODE to the return
11735    value, *REMOTE_ERRNO to the remote error number or zero if none
11736    was included, and *ATTACHMENT to point to the start of the annex
11737    if any.  The length of the packet isn't needed here; there may
11738    be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11739
11740    Return 0 if the packet could be parsed, -1 if it could not.  If
11741    -1 is returned, the other variables may not be initialized.  */
11742
11743 static int
11744 remote_hostio_parse_result (char *buffer, int *retcode,
11745                             int *remote_errno, char **attachment)
11746 {
11747   char *p, *p2;
11748
11749   *remote_errno = 0;
11750   *attachment = NULL;
11751
11752   if (buffer[0] != 'F')
11753     return -1;
11754
11755   errno = 0;
11756   *retcode = strtol (&buffer[1], &p, 16);
11757   if (errno != 0 || p == &buffer[1])
11758     return -1;
11759
11760   /* Check for ",errno".  */
11761   if (*p == ',')
11762     {
11763       errno = 0;
11764       *remote_errno = strtol (p + 1, &p2, 16);
11765       if (errno != 0 || p + 1 == p2)
11766         return -1;
11767       p = p2;
11768     }
11769
11770   /* Check for ";attachment".  If there is no attachment, the
11771      packet should end here.  */
11772   if (*p == ';')
11773     {
11774       *attachment = p + 1;
11775       return 0;
11776     }
11777   else if (*p == '\0')
11778     return 0;
11779   else
11780     return -1;
11781 }
11782
11783 /* Send a prepared I/O packet to the target and read its response.
11784    The prepared packet is in the global RS->BUF before this function
11785    is called, and the answer is there when we return.
11786
11787    COMMAND_BYTES is the length of the request to send, which may include
11788    binary data.  WHICH_PACKET is the packet configuration to check
11789    before attempting a packet.  If an error occurs, *REMOTE_ERRNO
11790    is set to the error number and -1 is returned.  Otherwise the value
11791    returned by the function is returned.
11792
11793    ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11794    attachment is expected; an error will be reported if there's a
11795    mismatch.  If one is found, *ATTACHMENT will be set to point into
11796    the packet buffer and *ATTACHMENT_LEN will be set to the
11797    attachment's length.  */
11798
11799 int
11800 remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
11801                                            int *remote_errno, char **attachment,
11802                                            int *attachment_len)
11803 {
11804   struct remote_state *rs = get_remote_state ();
11805   int ret, bytes_read;
11806   char *attachment_tmp;
11807
11808   if (packet_support (which_packet) == PACKET_DISABLE)
11809     {
11810       *remote_errno = FILEIO_ENOSYS;
11811       return -1;
11812     }
11813
11814   putpkt_binary (rs->buf.data (), command_bytes);
11815   bytes_read = getpkt_sane (&rs->buf, 0);
11816
11817   /* If it timed out, something is wrong.  Don't try to parse the
11818      buffer.  */
11819   if (bytes_read < 0)
11820     {
11821       *remote_errno = FILEIO_EINVAL;
11822       return -1;
11823     }
11824
11825   switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
11826     {
11827     case PACKET_ERROR:
11828       *remote_errno = FILEIO_EINVAL;
11829       return -1;
11830     case PACKET_UNKNOWN:
11831       *remote_errno = FILEIO_ENOSYS;
11832       return -1;
11833     case PACKET_OK:
11834       break;
11835     }
11836
11837   if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno,
11838                                   &attachment_tmp))
11839     {
11840       *remote_errno = FILEIO_EINVAL;
11841       return -1;
11842     }
11843
11844   /* Make sure we saw an attachment if and only if we expected one.  */
11845   if ((attachment_tmp == NULL && attachment != NULL)
11846       || (attachment_tmp != NULL && attachment == NULL))
11847     {
11848       *remote_errno = FILEIO_EINVAL;
11849       return -1;
11850     }
11851
11852   /* If an attachment was found, it must point into the packet buffer;
11853      work out how many bytes there were.  */
11854   if (attachment_tmp != NULL)
11855     {
11856       *attachment = attachment_tmp;
11857       *attachment_len = bytes_read - (*attachment - rs->buf.data ());
11858     }
11859
11860   return ret;
11861 }
11862
11863 /* See declaration.h.  */
11864
11865 void
11866 readahead_cache::invalidate ()
11867 {
11868   this->fd = -1;
11869 }
11870
11871 /* See declaration.h.  */
11872
11873 void
11874 readahead_cache::invalidate_fd (int fd)
11875 {
11876   if (this->fd == fd)
11877     this->fd = -1;
11878 }
11879
11880 /* Set the filesystem remote_hostio functions that take FILENAME
11881    arguments will use.  Return 0 on success, or -1 if an error
11882    occurs (and set *REMOTE_ERRNO).  */
11883
11884 int
11885 remote_target::remote_hostio_set_filesystem (struct inferior *inf,
11886                                              int *remote_errno)
11887 {
11888   struct remote_state *rs = get_remote_state ();
11889   int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
11890   char *p = rs->buf.data ();
11891   int left = get_remote_packet_size () - 1;
11892   char arg[9];
11893   int ret;
11894
11895   if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11896     return 0;
11897
11898   if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
11899     return 0;
11900
11901   remote_buffer_add_string (&p, &left, "vFile:setfs:");
11902
11903   xsnprintf (arg, sizeof (arg), "%x", required_pid);
11904   remote_buffer_add_string (&p, &left, arg);
11905
11906   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs,
11907                                     remote_errno, NULL, NULL);
11908
11909   if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11910     return 0;
11911
11912   if (ret == 0)
11913     rs->fs_pid = required_pid;
11914
11915   return ret;
11916 }
11917
11918 /* Implementation of to_fileio_open.  */
11919
11920 int
11921 remote_target::remote_hostio_open (inferior *inf, const char *filename,
11922                                    int flags, int mode, int warn_if_slow,
11923                                    int *remote_errno)
11924 {
11925   struct remote_state *rs = get_remote_state ();
11926   char *p = rs->buf.data ();
11927   int left = get_remote_packet_size () - 1;
11928
11929   if (warn_if_slow)
11930     {
11931       static int warning_issued = 0;
11932
11933       printf_unfiltered (_("Reading %s from remote target...\n"),
11934                          filename);
11935
11936       if (!warning_issued)
11937         {
11938           warning (_("File transfers from remote targets can be slow."
11939                      " Use \"set sysroot\" to access files locally"
11940                      " instead."));
11941           warning_issued = 1;
11942         }
11943     }
11944
11945   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11946     return -1;
11947
11948   remote_buffer_add_string (&p, &left, "vFile:open:");
11949
11950   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11951                            strlen (filename));
11952   remote_buffer_add_string (&p, &left, ",");
11953
11954   remote_buffer_add_int (&p, &left, flags);
11955   remote_buffer_add_string (&p, &left, ",");
11956
11957   remote_buffer_add_int (&p, &left, mode);
11958
11959   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open,
11960                                      remote_errno, NULL, NULL);
11961 }
11962
11963 int
11964 remote_target::fileio_open (struct inferior *inf, const char *filename,
11965                             int flags, int mode, int warn_if_slow,
11966                             int *remote_errno)
11967 {
11968   return remote_hostio_open (inf, filename, flags, mode, warn_if_slow,
11969                              remote_errno);
11970 }
11971
11972 /* Implementation of to_fileio_pwrite.  */
11973
11974 int
11975 remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
11976                                      ULONGEST offset, int *remote_errno)
11977 {
11978   struct remote_state *rs = get_remote_state ();
11979   char *p = rs->buf.data ();
11980   int left = get_remote_packet_size ();
11981   int out_len;
11982
11983   rs->readahead_cache.invalidate_fd (fd);
11984
11985   remote_buffer_add_string (&p, &left, "vFile:pwrite:");
11986
11987   remote_buffer_add_int (&p, &left, fd);
11988   remote_buffer_add_string (&p, &left, ",");
11989
11990   remote_buffer_add_int (&p, &left, offset);
11991   remote_buffer_add_string (&p, &left, ",");
11992
11993   p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
11994                              (get_remote_packet_size ()
11995                               - (p - rs->buf.data ())));
11996
11997   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite,
11998                                      remote_errno, NULL, NULL);
11999 }
12000
12001 int
12002 remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
12003                               ULONGEST offset, int *remote_errno)
12004 {
12005   return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno);
12006 }
12007
12008 /* Helper for the implementation of to_fileio_pread.  Read the file
12009    from the remote side with vFile:pread.  */
12010
12011 int
12012 remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
12013                                           ULONGEST offset, int *remote_errno)
12014 {
12015   struct remote_state *rs = get_remote_state ();
12016   char *p = rs->buf.data ();
12017   char *attachment;
12018   int left = get_remote_packet_size ();
12019   int ret, attachment_len;
12020   int read_len;
12021
12022   remote_buffer_add_string (&p, &left, "vFile:pread:");
12023
12024   remote_buffer_add_int (&p, &left, fd);
12025   remote_buffer_add_string (&p, &left, ",");
12026
12027   remote_buffer_add_int (&p, &left, len);
12028   remote_buffer_add_string (&p, &left, ",");
12029
12030   remote_buffer_add_int (&p, &left, offset);
12031
12032   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread,
12033                                     remote_errno, &attachment,
12034                                     &attachment_len);
12035
12036   if (ret < 0)
12037     return ret;
12038
12039   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12040                                     read_buf, len);
12041   if (read_len != ret)
12042     error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
12043
12044   return ret;
12045 }
12046
12047 /* See declaration.h.  */
12048
12049 int
12050 readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len,
12051                         ULONGEST offset)
12052 {
12053   if (this->fd == fd
12054       && this->offset <= offset
12055       && offset < this->offset + this->bufsize)
12056     {
12057       ULONGEST max = this->offset + this->bufsize;
12058
12059       if (offset + len > max)
12060         len = max - offset;
12061
12062       memcpy (read_buf, this->buf + offset - this->offset, len);
12063       return len;
12064     }
12065
12066   return 0;
12067 }
12068
12069 /* Implementation of to_fileio_pread.  */
12070
12071 int
12072 remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
12073                                     ULONGEST offset, int *remote_errno)
12074 {
12075   int ret;
12076   struct remote_state *rs = get_remote_state ();
12077   readahead_cache *cache = &rs->readahead_cache;
12078
12079   ret = cache->pread (fd, read_buf, len, offset);
12080   if (ret > 0)
12081     {
12082       cache->hit_count++;
12083
12084       if (remote_debug)
12085         fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
12086                             pulongest (cache->hit_count));
12087       return ret;
12088     }
12089
12090   cache->miss_count++;
12091   if (remote_debug)
12092     fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
12093                         pulongest (cache->miss_count));
12094
12095   cache->fd = fd;
12096   cache->offset = offset;
12097   cache->bufsize = get_remote_packet_size ();
12098   cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
12099
12100   ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize,
12101                                    cache->offset, remote_errno);
12102   if (ret <= 0)
12103     {
12104       cache->invalidate_fd (fd);
12105       return ret;
12106     }
12107
12108   cache->bufsize = ret;
12109   return cache->pread (fd, read_buf, len, offset);
12110 }
12111
12112 int
12113 remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
12114                              ULONGEST offset, int *remote_errno)
12115 {
12116   return remote_hostio_pread (fd, read_buf, len, offset, remote_errno);
12117 }
12118
12119 /* Implementation of to_fileio_close.  */
12120
12121 int
12122 remote_target::remote_hostio_close (int fd, int *remote_errno)
12123 {
12124   struct remote_state *rs = get_remote_state ();
12125   char *p = rs->buf.data ();
12126   int left = get_remote_packet_size () - 1;
12127
12128   rs->readahead_cache.invalidate_fd (fd);
12129
12130   remote_buffer_add_string (&p, &left, "vFile:close:");
12131
12132   remote_buffer_add_int (&p, &left, fd);
12133
12134   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close,
12135                                      remote_errno, NULL, NULL);
12136 }
12137
12138 int
12139 remote_target::fileio_close (int fd, int *remote_errno)
12140 {
12141   return remote_hostio_close (fd, remote_errno);
12142 }
12143
12144 /* Implementation of to_fileio_unlink.  */
12145
12146 int
12147 remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
12148                                      int *remote_errno)
12149 {
12150   struct remote_state *rs = get_remote_state ();
12151   char *p = rs->buf.data ();
12152   int left = get_remote_packet_size () - 1;
12153
12154   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12155     return -1;
12156
12157   remote_buffer_add_string (&p, &left, "vFile:unlink:");
12158
12159   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12160                            strlen (filename));
12161
12162   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink,
12163                                      remote_errno, NULL, NULL);
12164 }
12165
12166 int
12167 remote_target::fileio_unlink (struct inferior *inf, const char *filename,
12168                               int *remote_errno)
12169 {
12170   return remote_hostio_unlink (inf, filename, remote_errno);
12171 }
12172
12173 /* Implementation of to_fileio_readlink.  */
12174
12175 gdb::optional<std::string>
12176 remote_target::fileio_readlink (struct inferior *inf, const char *filename,
12177                                 int *remote_errno)
12178 {
12179   struct remote_state *rs = get_remote_state ();
12180   char *p = rs->buf.data ();
12181   char *attachment;
12182   int left = get_remote_packet_size ();
12183   int len, attachment_len;
12184   int read_len;
12185
12186   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12187     return {};
12188
12189   remote_buffer_add_string (&p, &left, "vFile:readlink:");
12190
12191   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12192                            strlen (filename));
12193
12194   len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink,
12195                                     remote_errno, &attachment,
12196                                     &attachment_len);
12197
12198   if (len < 0)
12199     return {};
12200
12201   std::string ret (len, '\0');
12202
12203   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12204                                     (gdb_byte *) &ret[0], len);
12205   if (read_len != len)
12206     error (_("Readlink returned %d, but %d bytes."), len, read_len);
12207
12208   return ret;
12209 }
12210
12211 /* Implementation of to_fileio_fstat.  */
12212
12213 int
12214 remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
12215 {
12216   struct remote_state *rs = get_remote_state ();
12217   char *p = rs->buf.data ();
12218   int left = get_remote_packet_size ();
12219   int attachment_len, ret;
12220   char *attachment;
12221   struct fio_stat fst;
12222   int read_len;
12223
12224   remote_buffer_add_string (&p, &left, "vFile:fstat:");
12225
12226   remote_buffer_add_int (&p, &left, fd);
12227
12228   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat,
12229                                     remote_errno, &attachment,
12230                                     &attachment_len);
12231   if (ret < 0)
12232     {
12233       if (*remote_errno != FILEIO_ENOSYS)
12234         return ret;
12235
12236       /* Strictly we should return -1, ENOSYS here, but when
12237          "set sysroot remote:" was implemented in August 2008
12238          BFD's need for a stat function was sidestepped with
12239          this hack.  This was not remedied until March 2015
12240          so we retain the previous behavior to avoid breaking
12241          compatibility.
12242
12243          Note that the memset is a March 2015 addition; older
12244          GDBs set st_size *and nothing else* so the structure
12245          would have garbage in all other fields.  This might
12246          break something but retaining the previous behavior
12247          here would be just too wrong.  */
12248
12249       memset (st, 0, sizeof (struct stat));
12250       st->st_size = INT_MAX;
12251       return 0;
12252     }
12253
12254   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12255                                     (gdb_byte *) &fst, sizeof (fst));
12256
12257   if (read_len != ret)
12258     error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len);
12259
12260   if (read_len != sizeof (fst))
12261     error (_("vFile:fstat returned %d bytes, but expecting %d."),
12262            read_len, (int) sizeof (fst));
12263
12264   remote_fileio_to_host_stat (&fst, st);
12265
12266   return 0;
12267 }
12268
12269 /* Implementation of to_filesystem_is_local.  */
12270
12271 bool
12272 remote_target::filesystem_is_local ()
12273 {
12274   /* Valgrind GDB presents itself as a remote target but works
12275      on the local filesystem: it does not implement remote get
12276      and users are not expected to set a sysroot.  To handle
12277      this case we treat the remote filesystem as local if the
12278      sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12279      does not support vFile:open.  */
12280   if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
12281     {
12282       enum packet_support ps = packet_support (PACKET_vFile_open);
12283
12284       if (ps == PACKET_SUPPORT_UNKNOWN)
12285         {
12286           int fd, remote_errno;
12287
12288           /* Try opening a file to probe support.  The supplied
12289              filename is irrelevant, we only care about whether
12290              the stub recognizes the packet or not.  */
12291           fd = remote_hostio_open (NULL, "just probing",
12292                                    FILEIO_O_RDONLY, 0700, 0,
12293                                    &remote_errno);
12294
12295           if (fd >= 0)
12296             remote_hostio_close (fd, &remote_errno);
12297
12298           ps = packet_support (PACKET_vFile_open);
12299         }
12300
12301       if (ps == PACKET_DISABLE)
12302         {
12303           static int warning_issued = 0;
12304
12305           if (!warning_issued)
12306             {
12307               warning (_("remote target does not support file"
12308                          " transfer, attempting to access files"
12309                          " from local filesystem."));
12310               warning_issued = 1;
12311             }
12312
12313           return true;
12314         }
12315     }
12316
12317   return false;
12318 }
12319
12320 static int
12321 remote_fileio_errno_to_host (int errnum)
12322 {
12323   switch (errnum)
12324     {
12325       case FILEIO_EPERM:
12326         return EPERM;
12327       case FILEIO_ENOENT:
12328         return ENOENT;
12329       case FILEIO_EINTR:
12330         return EINTR;
12331       case FILEIO_EIO:
12332         return EIO;
12333       case FILEIO_EBADF:
12334         return EBADF;
12335       case FILEIO_EACCES:
12336         return EACCES;
12337       case FILEIO_EFAULT:
12338         return EFAULT;
12339       case FILEIO_EBUSY:
12340         return EBUSY;
12341       case FILEIO_EEXIST:
12342         return EEXIST;
12343       case FILEIO_ENODEV:
12344         return ENODEV;
12345       case FILEIO_ENOTDIR:
12346         return ENOTDIR;
12347       case FILEIO_EISDIR:
12348         return EISDIR;
12349       case FILEIO_EINVAL:
12350         return EINVAL;
12351       case FILEIO_ENFILE:
12352         return ENFILE;
12353       case FILEIO_EMFILE:
12354         return EMFILE;
12355       case FILEIO_EFBIG:
12356         return EFBIG;
12357       case FILEIO_ENOSPC:
12358         return ENOSPC;
12359       case FILEIO_ESPIPE:
12360         return ESPIPE;
12361       case FILEIO_EROFS:
12362         return EROFS;
12363       case FILEIO_ENOSYS:
12364         return ENOSYS;
12365       case FILEIO_ENAMETOOLONG:
12366         return ENAMETOOLONG;
12367     }
12368   return -1;
12369 }
12370
12371 static char *
12372 remote_hostio_error (int errnum)
12373 {
12374   int host_error = remote_fileio_errno_to_host (errnum);
12375
12376   if (host_error == -1)
12377     error (_("Unknown remote I/O error %d"), errnum);
12378   else
12379     error (_("Remote I/O error: %s"), safe_strerror (host_error));
12380 }
12381
12382 /* A RAII wrapper around a remote file descriptor.  */
12383
12384 class scoped_remote_fd
12385 {
12386 public:
12387   scoped_remote_fd (remote_target *remote, int fd)
12388     : m_remote (remote), m_fd (fd)
12389   {
12390   }
12391
12392   ~scoped_remote_fd ()
12393   {
12394     if (m_fd != -1)
12395       {
12396         try
12397           {
12398             int remote_errno;
12399             m_remote->remote_hostio_close (m_fd, &remote_errno);
12400           }
12401         catch (...)
12402           {
12403             /* Swallow exception before it escapes the dtor.  If
12404                something goes wrong, likely the connection is gone,
12405                and there's nothing else that can be done.  */
12406           }
12407       }
12408   }
12409
12410   DISABLE_COPY_AND_ASSIGN (scoped_remote_fd);
12411
12412   /* Release ownership of the file descriptor, and return it.  */
12413   int release () noexcept
12414   {
12415     int fd = m_fd;
12416     m_fd = -1;
12417     return fd;
12418   }
12419
12420   /* Return the owned file descriptor.  */
12421   int get () const noexcept
12422   {
12423     return m_fd;
12424   }
12425
12426 private:
12427   /* The remote target.  */
12428   remote_target *m_remote;
12429
12430   /* The owned remote I/O file descriptor.  */
12431   int m_fd;
12432 };
12433
12434 void
12435 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
12436 {
12437   remote_target *remote = get_current_remote_target ();
12438
12439   if (remote == nullptr)
12440     error (_("command can only be used with remote target"));
12441
12442   remote->remote_file_put (local_file, remote_file, from_tty);
12443 }
12444
12445 void
12446 remote_target::remote_file_put (const char *local_file, const char *remote_file,
12447                                 int from_tty)
12448 {
12449   int retcode, remote_errno, bytes, io_size;
12450   int bytes_in_buffer;
12451   int saw_eof;
12452   ULONGEST offset;
12453
12454   gdb_file_up file = gdb_fopen_cloexec (local_file, "rb");
12455   if (file == NULL)
12456     perror_with_name (local_file);
12457
12458   scoped_remote_fd fd
12459     (this, remote_hostio_open (NULL,
12460                                remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
12461                                              | FILEIO_O_TRUNC),
12462                                0700, 0, &remote_errno));
12463   if (fd.get () == -1)
12464     remote_hostio_error (remote_errno);
12465
12466   /* Send up to this many bytes at once.  They won't all fit in the
12467      remote packet limit, so we'll transfer slightly fewer.  */
12468   io_size = get_remote_packet_size ();
12469   gdb::byte_vector buffer (io_size);
12470
12471   bytes_in_buffer = 0;
12472   saw_eof = 0;
12473   offset = 0;
12474   while (bytes_in_buffer || !saw_eof)
12475     {
12476       if (!saw_eof)
12477         {
12478           bytes = fread (buffer.data () + bytes_in_buffer, 1,
12479                          io_size - bytes_in_buffer,
12480                          file.get ());
12481           if (bytes == 0)
12482             {
12483               if (ferror (file.get ()))
12484                 error (_("Error reading %s."), local_file);
12485               else
12486                 {
12487                   /* EOF.  Unless there is something still in the
12488                      buffer from the last iteration, we are done.  */
12489                   saw_eof = 1;
12490                   if (bytes_in_buffer == 0)
12491                     break;
12492                 }
12493             }
12494         }
12495       else
12496         bytes = 0;
12497
12498       bytes += bytes_in_buffer;
12499       bytes_in_buffer = 0;
12500
12501       retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes,
12502                                       offset, &remote_errno);
12503
12504       if (retcode < 0)
12505         remote_hostio_error (remote_errno);
12506       else if (retcode == 0)
12507         error (_("Remote write of %d bytes returned 0!"), bytes);
12508       else if (retcode < bytes)
12509         {
12510           /* Short write.  Save the rest of the read data for the next
12511              write.  */
12512           bytes_in_buffer = bytes - retcode;
12513           memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer);
12514         }
12515
12516       offset += retcode;
12517     }
12518
12519   if (remote_hostio_close (fd.release (), &remote_errno))
12520     remote_hostio_error (remote_errno);
12521
12522   if (from_tty)
12523     printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
12524 }
12525
12526 void
12527 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
12528 {
12529   remote_target *remote = get_current_remote_target ();
12530
12531   if (remote == nullptr)
12532     error (_("command can only be used with remote target"));
12533
12534   remote->remote_file_get (remote_file, local_file, from_tty);
12535 }
12536
12537 void
12538 remote_target::remote_file_get (const char *remote_file, const char *local_file,
12539                                 int from_tty)
12540 {
12541   int remote_errno, bytes, io_size;
12542   ULONGEST offset;
12543
12544   scoped_remote_fd fd
12545     (this, remote_hostio_open (NULL,
12546                                remote_file, FILEIO_O_RDONLY, 0, 0,
12547                                &remote_errno));
12548   if (fd.get () == -1)
12549     remote_hostio_error (remote_errno);
12550
12551   gdb_file_up file = gdb_fopen_cloexec (local_file, "wb");
12552   if (file == NULL)
12553     perror_with_name (local_file);
12554
12555   /* Send up to this many bytes at once.  They won't all fit in the
12556      remote packet limit, so we'll transfer slightly fewer.  */
12557   io_size = get_remote_packet_size ();
12558   gdb::byte_vector buffer (io_size);
12559
12560   offset = 0;
12561   while (1)
12562     {
12563       bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset,
12564                                    &remote_errno);
12565       if (bytes == 0)
12566         /* Success, but no bytes, means end-of-file.  */
12567         break;
12568       if (bytes == -1)
12569         remote_hostio_error (remote_errno);
12570
12571       offset += bytes;
12572
12573       bytes = fwrite (buffer.data (), 1, bytes, file.get ());
12574       if (bytes == 0)
12575         perror_with_name (local_file);
12576     }
12577
12578   if (remote_hostio_close (fd.release (), &remote_errno))
12579     remote_hostio_error (remote_errno);
12580
12581   if (from_tty)
12582     printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
12583 }
12584
12585 void
12586 remote_file_delete (const char *remote_file, int from_tty)
12587 {
12588   remote_target *remote = get_current_remote_target ();
12589
12590   if (remote == nullptr)
12591     error (_("command can only be used with remote target"));
12592
12593   remote->remote_file_delete (remote_file, from_tty);
12594 }
12595
12596 void
12597 remote_target::remote_file_delete (const char *remote_file, int from_tty)
12598 {
12599   int retcode, remote_errno;
12600
12601   retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno);
12602   if (retcode == -1)
12603     remote_hostio_error (remote_errno);
12604
12605   if (from_tty)
12606     printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
12607 }
12608
12609 static void
12610 remote_put_command (const char *args, int from_tty)
12611 {
12612   if (args == NULL)
12613     error_no_arg (_("file to put"));
12614
12615   gdb_argv argv (args);
12616   if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12617     error (_("Invalid parameters to remote put"));
12618
12619   remote_file_put (argv[0], argv[1], from_tty);
12620 }
12621
12622 static void
12623 remote_get_command (const char *args, int from_tty)
12624 {
12625   if (args == NULL)
12626     error_no_arg (_("file to get"));
12627
12628   gdb_argv argv (args);
12629   if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12630     error (_("Invalid parameters to remote get"));
12631
12632   remote_file_get (argv[0], argv[1], from_tty);
12633 }
12634
12635 static void
12636 remote_delete_command (const char *args, int from_tty)
12637 {
12638   if (args == NULL)
12639     error_no_arg (_("file to delete"));
12640
12641   gdb_argv argv (args);
12642   if (argv[0] == NULL || argv[1] != NULL)
12643     error (_("Invalid parameters to remote delete"));
12644
12645   remote_file_delete (argv[0], from_tty);
12646 }
12647
12648 static void
12649 remote_command (const char *args, int from_tty)
12650 {
12651   help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
12652 }
12653
12654 bool
12655 remote_target::can_execute_reverse ()
12656 {
12657   if (packet_support (PACKET_bs) == PACKET_ENABLE
12658       || packet_support (PACKET_bc) == PACKET_ENABLE)
12659     return true;
12660   else
12661     return false;
12662 }
12663
12664 bool
12665 remote_target::supports_non_stop ()
12666 {
12667   return true;
12668 }
12669
12670 bool
12671 remote_target::supports_disable_randomization ()
12672 {
12673   /* Only supported in extended mode.  */
12674   return false;
12675 }
12676
12677 bool
12678 remote_target::supports_multi_process ()
12679 {
12680   struct remote_state *rs = get_remote_state ();
12681
12682   return remote_multi_process_p (rs);
12683 }
12684
12685 static int
12686 remote_supports_cond_tracepoints ()
12687 {
12688   return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
12689 }
12690
12691 bool
12692 remote_target::supports_evaluation_of_breakpoint_conditions ()
12693 {
12694   return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
12695 }
12696
12697 static int
12698 remote_supports_fast_tracepoints ()
12699 {
12700   return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
12701 }
12702
12703 static int
12704 remote_supports_static_tracepoints ()
12705 {
12706   return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
12707 }
12708
12709 static int
12710 remote_supports_install_in_trace ()
12711 {
12712   return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
12713 }
12714
12715 bool
12716 remote_target::supports_enable_disable_tracepoint ()
12717 {
12718   return (packet_support (PACKET_EnableDisableTracepoints_feature)
12719           == PACKET_ENABLE);
12720 }
12721
12722 bool
12723 remote_target::supports_string_tracing ()
12724 {
12725   return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
12726 }
12727
12728 bool
12729 remote_target::can_run_breakpoint_commands ()
12730 {
12731   return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
12732 }
12733
12734 void
12735 remote_target::trace_init ()
12736 {
12737   struct remote_state *rs = get_remote_state ();
12738
12739   putpkt ("QTinit");
12740   remote_get_noisy_reply ();
12741   if (strcmp (rs->buf.data (), "OK") != 0)
12742     error (_("Target does not support this command."));
12743 }
12744
12745 /* Recursive routine to walk through command list including loops, and
12746    download packets for each command.  */
12747
12748 void
12749 remote_target::remote_download_command_source (int num, ULONGEST addr,
12750                                                struct command_line *cmds)
12751 {
12752   struct remote_state *rs = get_remote_state ();
12753   struct command_line *cmd;
12754
12755   for (cmd = cmds; cmd; cmd = cmd->next)
12756     {
12757       QUIT;     /* Allow user to bail out with ^C.  */
12758       strcpy (rs->buf.data (), "QTDPsrc:");
12759       encode_source_string (num, addr, "cmd", cmd->line,
12760                             rs->buf.data () + strlen (rs->buf.data ()),
12761                             rs->buf.size () - strlen (rs->buf.data ()));
12762       putpkt (rs->buf);
12763       remote_get_noisy_reply ();
12764       if (strcmp (rs->buf.data (), "OK"))
12765         warning (_("Target does not support source download."));
12766
12767       if (cmd->control_type == while_control
12768           || cmd->control_type == while_stepping_control)
12769         {
12770           remote_download_command_source (num, addr, cmd->body_list_0.get ());
12771
12772           QUIT; /* Allow user to bail out with ^C.  */
12773           strcpy (rs->buf.data (), "QTDPsrc:");
12774           encode_source_string (num, addr, "cmd", "end",
12775                                 rs->buf.data () + strlen (rs->buf.data ()),
12776                                 rs->buf.size () - strlen (rs->buf.data ()));
12777           putpkt (rs->buf);
12778           remote_get_noisy_reply ();
12779           if (strcmp (rs->buf.data (), "OK"))
12780             warning (_("Target does not support source download."));
12781         }
12782     }
12783 }
12784
12785 void
12786 remote_target::download_tracepoint (struct bp_location *loc)
12787 {
12788   CORE_ADDR tpaddr;
12789   char addrbuf[40];
12790   std::vector<std::string> tdp_actions;
12791   std::vector<std::string> stepping_actions;
12792   char *pkt;
12793   struct breakpoint *b = loc->owner;
12794   struct tracepoint *t = (struct tracepoint *) b;
12795   struct remote_state *rs = get_remote_state ();
12796   int ret;
12797   const char *err_msg = _("Tracepoint packet too large for target.");
12798   size_t size_left;
12799
12800   /* We use a buffer other than rs->buf because we'll build strings
12801      across multiple statements, and other statements in between could
12802      modify rs->buf.  */
12803   gdb::char_vector buf (get_remote_packet_size ());
12804
12805   encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
12806
12807   tpaddr = loc->address;
12808   sprintf_vma (addrbuf, tpaddr);
12809   ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x",
12810                   b->number, addrbuf, /* address */
12811                   (b->enable_state == bp_enabled ? 'E' : 'D'),
12812                   t->step_count, t->pass_count);
12813
12814   if (ret < 0 || ret >= buf.size ())
12815     error ("%s", err_msg);
12816
12817   /* Fast tracepoints are mostly handled by the target, but we can
12818      tell the target how big of an instruction block should be moved
12819      around.  */
12820   if (b->type == bp_fast_tracepoint)
12821     {
12822       /* Only test for support at download time; we may not know
12823          target capabilities at definition time.  */
12824       if (remote_supports_fast_tracepoints ())
12825         {
12826           if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr,
12827                                                 NULL))
12828             {
12829               size_left = buf.size () - strlen (buf.data ());
12830               ret = snprintf (buf.data () + strlen (buf.data ()),
12831                               size_left, ":F%x",
12832                               gdb_insn_length (loc->gdbarch, tpaddr));
12833
12834               if (ret < 0 || ret >= size_left)
12835                 error ("%s", err_msg);
12836             }
12837           else
12838             /* If it passed validation at definition but fails now,
12839                something is very wrong.  */
12840             internal_error (__FILE__, __LINE__,
12841                             _("Fast tracepoint not "
12842                               "valid during download"));
12843         }
12844       else
12845         /* Fast tracepoints are functionally identical to regular
12846            tracepoints, so don't take lack of support as a reason to
12847            give up on the trace run.  */
12848         warning (_("Target does not support fast tracepoints, "
12849                    "downloading %d as regular tracepoint"), b->number);
12850     }
12851   else if (b->type == bp_static_tracepoint)
12852     {
12853       /* Only test for support at download time; we may not know
12854          target capabilities at definition time.  */
12855       if (remote_supports_static_tracepoints ())
12856         {
12857           struct static_tracepoint_marker marker;
12858
12859           if (target_static_tracepoint_marker_at (tpaddr, &marker))
12860             {
12861               size_left = buf.size () - strlen (buf.data ());
12862               ret = snprintf (buf.data () + strlen (buf.data ()),
12863                               size_left, ":S");
12864
12865               if (ret < 0 || ret >= size_left)
12866                 error ("%s", err_msg);
12867             }
12868           else
12869             error (_("Static tracepoint not valid during download"));
12870         }
12871       else
12872         /* Fast tracepoints are functionally identical to regular
12873            tracepoints, so don't take lack of support as a reason
12874            to give up on the trace run.  */
12875         error (_("Target does not support static tracepoints"));
12876     }
12877   /* If the tracepoint has a conditional, make it into an agent
12878      expression and append to the definition.  */
12879   if (loc->cond)
12880     {
12881       /* Only test support at download time, we may not know target
12882          capabilities at definition time.  */
12883       if (remote_supports_cond_tracepoints ())
12884         {
12885           agent_expr_up aexpr = gen_eval_for_expr (tpaddr,
12886                                                    loc->cond.get ());
12887
12888           size_left = buf.size () - strlen (buf.data ());
12889
12890           ret = snprintf (buf.data () + strlen (buf.data ()),
12891                           size_left, ":X%x,", aexpr->len);
12892
12893           if (ret < 0 || ret >= size_left)
12894             error ("%s", err_msg);
12895
12896           size_left = buf.size () - strlen (buf.data ());
12897
12898           /* Two bytes to encode each aexpr byte, plus the terminating
12899              null byte.  */
12900           if (aexpr->len * 2 + 1 > size_left)
12901             error ("%s", err_msg);
12902
12903           pkt = buf.data () + strlen (buf.data ());
12904
12905           for (int ndx = 0; ndx < aexpr->len; ++ndx)
12906             pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
12907           *pkt = '\0';
12908         }
12909       else
12910         warning (_("Target does not support conditional tracepoints, "
12911                    "ignoring tp %d cond"), b->number);
12912     }
12913
12914   if (b->commands || *default_collect)
12915     {
12916       size_left = buf.size () - strlen (buf.data ());
12917
12918       ret = snprintf (buf.data () + strlen (buf.data ()),
12919                       size_left, "-");
12920
12921       if (ret < 0 || ret >= size_left)
12922         error ("%s", err_msg);
12923     }
12924
12925   putpkt (buf.data ());
12926   remote_get_noisy_reply ();
12927   if (strcmp (rs->buf.data (), "OK"))
12928     error (_("Target does not support tracepoints."));
12929
12930   /* do_single_steps (t); */
12931   for (auto action_it = tdp_actions.begin ();
12932        action_it != tdp_actions.end (); action_it++)
12933     {
12934       QUIT;     /* Allow user to bail out with ^C.  */
12935
12936       bool has_more = ((action_it + 1) != tdp_actions.end ()
12937                        || !stepping_actions.empty ());
12938
12939       ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%c",
12940                       b->number, addrbuf, /* address */
12941                       action_it->c_str (),
12942                       has_more ? '-' : 0);
12943
12944       if (ret < 0 || ret >= buf.size ())
12945         error ("%s", err_msg);
12946
12947       putpkt (buf.data ());
12948       remote_get_noisy_reply ();
12949       if (strcmp (rs->buf.data (), "OK"))
12950         error (_("Error on target while setting tracepoints."));
12951     }
12952
12953   for (auto action_it = stepping_actions.begin ();
12954        action_it != stepping_actions.end (); action_it++)
12955     {
12956       QUIT;     /* Allow user to bail out with ^C.  */
12957
12958       bool is_first = action_it == stepping_actions.begin ();
12959       bool has_more = (action_it + 1) != stepping_actions.end ();
12960
12961       ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%s%s",
12962                       b->number, addrbuf, /* address */
12963                       is_first ? "S" : "",
12964                       action_it->c_str (),
12965                       has_more ? "-" : "");
12966
12967       if (ret < 0 || ret >= buf.size ())
12968         error ("%s", err_msg);
12969
12970       putpkt (buf.data ());
12971       remote_get_noisy_reply ();
12972       if (strcmp (rs->buf.data (), "OK"))
12973         error (_("Error on target while setting tracepoints."));
12974     }
12975
12976   if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
12977     {
12978       if (b->location != NULL)
12979         {
12980           ret = snprintf (buf.data (), buf.size (), "QTDPsrc:");
12981
12982           if (ret < 0 || ret >= buf.size ())
12983             error ("%s", err_msg);
12984
12985           encode_source_string (b->number, loc->address, "at",
12986                                 event_location_to_string (b->location.get ()),
12987                                 buf.data () + strlen (buf.data ()),
12988                                 buf.size () - strlen (buf.data ()));
12989           putpkt (buf.data ());
12990           remote_get_noisy_reply ();
12991           if (strcmp (rs->buf.data (), "OK"))
12992             warning (_("Target does not support source download."));
12993         }
12994       if (b->cond_string)
12995         {
12996           ret = snprintf (buf.data (), buf.size (), "QTDPsrc:");
12997
12998           if (ret < 0 || ret >= buf.size ())
12999             error ("%s", err_msg);
13000
13001           encode_source_string (b->number, loc->address,
13002                                 "cond", b->cond_string,
13003                                 buf.data () + strlen (buf.data ()),
13004                                 buf.size () - strlen (buf.data ()));
13005           putpkt (buf.data ());
13006           remote_get_noisy_reply ();
13007           if (strcmp (rs->buf.data (), "OK"))
13008             warning (_("Target does not support source download."));
13009         }
13010       remote_download_command_source (b->number, loc->address,
13011                                       breakpoint_commands (b));
13012     }
13013 }
13014
13015 bool
13016 remote_target::can_download_tracepoint ()
13017 {
13018   struct remote_state *rs = get_remote_state ();
13019   struct trace_status *ts;
13020   int status;
13021
13022   /* Don't try to install tracepoints until we've relocated our
13023      symbols, and fetched and merged the target's tracepoint list with
13024      ours.  */
13025   if (rs->starting_up)
13026     return false;
13027
13028   ts = current_trace_status ();
13029   status = get_trace_status (ts);
13030
13031   if (status == -1 || !ts->running_known || !ts->running)
13032     return false;
13033
13034   /* If we are in a tracing experiment, but remote stub doesn't support
13035      installing tracepoint in trace, we have to return.  */
13036   if (!remote_supports_install_in_trace ())
13037     return false;
13038
13039   return true;
13040 }
13041
13042
13043 void
13044 remote_target::download_trace_state_variable (const trace_state_variable &tsv)
13045 {
13046   struct remote_state *rs = get_remote_state ();
13047   char *p;
13048
13049   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13050              tsv.number, phex ((ULONGEST) tsv.initial_value, 8),
13051              tsv.builtin);
13052   p = rs->buf.data () + strlen (rs->buf.data ());
13053   if ((p - rs->buf.data ()) + tsv.name.length () * 2
13054       >= get_remote_packet_size ())
13055     error (_("Trace state variable name too long for tsv definition packet"));
13056   p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ());
13057   *p++ = '\0';
13058   putpkt (rs->buf);
13059   remote_get_noisy_reply ();
13060   if (rs->buf[0] == '\0')
13061     error (_("Target does not support this command."));
13062   if (strcmp (rs->buf.data (), "OK") != 0)
13063     error (_("Error on target while downloading trace state variable."));
13064 }
13065
13066 void
13067 remote_target::enable_tracepoint (struct bp_location *location)
13068 {
13069   struct remote_state *rs = get_remote_state ();
13070   char addr_buf[40];
13071
13072   sprintf_vma (addr_buf, location->address);
13073   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13074              location->owner->number, addr_buf);
13075   putpkt (rs->buf);
13076   remote_get_noisy_reply ();
13077   if (rs->buf[0] == '\0')
13078     error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13079   if (strcmp (rs->buf.data (), "OK") != 0)
13080     error (_("Error on target while enabling tracepoint."));
13081 }
13082
13083 void
13084 remote_target::disable_tracepoint (struct bp_location *location)
13085 {
13086   struct remote_state *rs = get_remote_state ();
13087   char addr_buf[40];
13088
13089   sprintf_vma (addr_buf, location->address);
13090   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13091              location->owner->number, addr_buf);
13092   putpkt (rs->buf);
13093   remote_get_noisy_reply ();
13094   if (rs->buf[0] == '\0')
13095     error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13096   if (strcmp (rs->buf.data (), "OK") != 0)
13097     error (_("Error on target while disabling tracepoint."));
13098 }
13099
13100 void
13101 remote_target::trace_set_readonly_regions ()
13102 {
13103   asection *s;
13104   bfd *abfd = NULL;
13105   bfd_size_type size;
13106   bfd_vma vma;
13107   int anysecs = 0;
13108   int offset = 0;
13109
13110   if (!exec_bfd)
13111     return;                     /* No information to give.  */
13112
13113   struct remote_state *rs = get_remote_state ();
13114
13115   strcpy (rs->buf.data (), "QTro");
13116   offset = strlen (rs->buf.data ());
13117   for (s = exec_bfd->sections; s; s = s->next)
13118     {
13119       char tmp1[40], tmp2[40];
13120       int sec_length;
13121
13122       if ((s->flags & SEC_LOAD) == 0 ||
13123       /*  (s->flags & SEC_CODE) == 0 || */
13124           (s->flags & SEC_READONLY) == 0)
13125         continue;
13126
13127       anysecs = 1;
13128       vma = bfd_get_section_vma (abfd, s);
13129       size = bfd_get_section_size (s);
13130       sprintf_vma (tmp1, vma);
13131       sprintf_vma (tmp2, vma + size);
13132       sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
13133       if (offset + sec_length + 1 > rs->buf.size ())
13134         {
13135           if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
13136             warning (_("\
13137 Too many sections for read-only sections definition packet."));
13138           break;
13139         }
13140       xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s",
13141                  tmp1, tmp2);
13142       offset += sec_length;
13143     }
13144   if (anysecs)
13145     {
13146       putpkt (rs->buf);
13147       getpkt (&rs->buf, 0);
13148     }
13149 }
13150
13151 void
13152 remote_target::trace_start ()
13153 {
13154   struct remote_state *rs = get_remote_state ();
13155
13156   putpkt ("QTStart");
13157   remote_get_noisy_reply ();
13158   if (rs->buf[0] == '\0')
13159     error (_("Target does not support this command."));
13160   if (strcmp (rs->buf.data (), "OK") != 0)
13161     error (_("Bogus reply from target: %s"), rs->buf.data ());
13162 }
13163
13164 int
13165 remote_target::get_trace_status (struct trace_status *ts)
13166 {
13167   /* Initialize it just to avoid a GCC false warning.  */
13168   char *p = NULL;
13169   /* FIXME we need to get register block size some other way.  */
13170   extern int trace_regblock_size;
13171   enum packet_result result;
13172   struct remote_state *rs = get_remote_state ();
13173
13174   if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
13175     return -1;
13176
13177   trace_regblock_size
13178     = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
13179
13180   putpkt ("qTStatus");
13181
13182   TRY
13183     {
13184       p = remote_get_noisy_reply ();
13185     }
13186   CATCH (ex, RETURN_MASK_ERROR)
13187     {
13188       if (ex.error != TARGET_CLOSE_ERROR)
13189         {
13190           exception_fprintf (gdb_stderr, ex, "qTStatus: ");
13191           return -1;
13192         }
13193       throw_exception (ex);
13194     }
13195   END_CATCH
13196
13197   result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
13198
13199   /* If the remote target doesn't do tracing, flag it.  */
13200   if (result == PACKET_UNKNOWN)
13201     return -1;
13202
13203   /* We're working with a live target.  */
13204   ts->filename = NULL;
13205
13206   if (*p++ != 'T')
13207     error (_("Bogus trace status reply from target: %s"), rs->buf.data ());
13208
13209   /* Function 'parse_trace_status' sets default value of each field of
13210      'ts' at first, so we don't have to do it here.  */
13211   parse_trace_status (p, ts);
13212
13213   return ts->running;
13214 }
13215
13216 void
13217 remote_target::get_tracepoint_status (struct breakpoint *bp,
13218                                       struct uploaded_tp *utp)
13219 {
13220   struct remote_state *rs = get_remote_state ();
13221   char *reply;
13222   struct bp_location *loc;
13223   struct tracepoint *tp = (struct tracepoint *) bp;
13224   size_t size = get_remote_packet_size ();
13225
13226   if (tp)
13227     {
13228       tp->hit_count = 0;
13229       tp->traceframe_usage = 0;
13230       for (loc = tp->loc; loc; loc = loc->next)
13231         {
13232           /* If the tracepoint was never downloaded, don't go asking for
13233              any status.  */
13234           if (tp->number_on_target == 0)
13235             continue;
13236           xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target,
13237                      phex_nz (loc->address, 0));
13238           putpkt (rs->buf);
13239           reply = remote_get_noisy_reply ();
13240           if (reply && *reply)
13241             {
13242               if (*reply == 'V')
13243                 parse_tracepoint_status (reply + 1, bp, utp);
13244             }
13245         }
13246     }
13247   else if (utp)
13248     {
13249       utp->hit_count = 0;
13250       utp->traceframe_usage = 0;
13251       xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number,
13252                  phex_nz (utp->addr, 0));
13253       putpkt (rs->buf);
13254       reply = remote_get_noisy_reply ();
13255       if (reply && *reply)
13256         {
13257           if (*reply == 'V')
13258             parse_tracepoint_status (reply + 1, bp, utp);
13259         }
13260     }
13261 }
13262
13263 void
13264 remote_target::trace_stop ()
13265 {
13266   struct remote_state *rs = get_remote_state ();
13267
13268   putpkt ("QTStop");
13269   remote_get_noisy_reply ();
13270   if (rs->buf[0] == '\0')
13271     error (_("Target does not support this command."));
13272   if (strcmp (rs->buf.data (), "OK") != 0)
13273     error (_("Bogus reply from target: %s"), rs->buf.data ());
13274 }
13275
13276 int
13277 remote_target::trace_find (enum trace_find_type type, int num,
13278                            CORE_ADDR addr1, CORE_ADDR addr2,
13279                            int *tpp)
13280 {
13281   struct remote_state *rs = get_remote_state ();
13282   char *endbuf = rs->buf.data () + get_remote_packet_size ();
13283   char *p, *reply;
13284   int target_frameno = -1, target_tracept = -1;
13285
13286   /* Lookups other than by absolute frame number depend on the current
13287      trace selected, so make sure it is correct on the remote end
13288      first.  */
13289   if (type != tfind_number)
13290     set_remote_traceframe ();
13291
13292   p = rs->buf.data ();
13293   strcpy (p, "QTFrame:");
13294   p = strchr (p, '\0');
13295   switch (type)
13296     {
13297     case tfind_number:
13298       xsnprintf (p, endbuf - p, "%x", num);
13299       break;
13300     case tfind_pc:
13301       xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
13302       break;
13303     case tfind_tp:
13304       xsnprintf (p, endbuf - p, "tdp:%x", num);
13305       break;
13306     case tfind_range:
13307       xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
13308                  phex_nz (addr2, 0));
13309       break;
13310     case tfind_outside:
13311       xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
13312                  phex_nz (addr2, 0));
13313       break;
13314     default:
13315       error (_("Unknown trace find type %d"), type);
13316     }
13317
13318   putpkt (rs->buf);
13319   reply = remote_get_noisy_reply ();
13320   if (*reply == '\0')
13321     error (_("Target does not support this command."));
13322
13323   while (reply && *reply)
13324     switch (*reply)
13325       {
13326       case 'F':
13327         p = ++reply;
13328         target_frameno = (int) strtol (p, &reply, 16);
13329         if (reply == p)
13330           error (_("Unable to parse trace frame number"));
13331         /* Don't update our remote traceframe number cache on failure
13332            to select a remote traceframe.  */
13333         if (target_frameno == -1)
13334           return -1;
13335         break;
13336       case 'T':
13337         p = ++reply;
13338         target_tracept = (int) strtol (p, &reply, 16);
13339         if (reply == p)
13340           error (_("Unable to parse tracepoint number"));
13341         break;
13342       case 'O':         /* "OK"? */
13343         if (reply[1] == 'K' && reply[2] == '\0')
13344           reply += 2;
13345         else
13346           error (_("Bogus reply from target: %s"), reply);
13347         break;
13348       default:
13349         error (_("Bogus reply from target: %s"), reply);
13350       }
13351   if (tpp)
13352     *tpp = target_tracept;
13353
13354   rs->remote_traceframe_number = target_frameno;
13355   return target_frameno;
13356 }
13357
13358 bool
13359 remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
13360 {
13361   struct remote_state *rs = get_remote_state ();
13362   char *reply;
13363   ULONGEST uval;
13364
13365   set_remote_traceframe ();
13366
13367   xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum);
13368   putpkt (rs->buf);
13369   reply = remote_get_noisy_reply ();
13370   if (reply && *reply)
13371     {
13372       if (*reply == 'V')
13373         {
13374           unpack_varlen_hex (reply + 1, &uval);
13375           *val = (LONGEST) uval;
13376           return true;
13377         }
13378     }
13379   return false;
13380 }
13381
13382 int
13383 remote_target::save_trace_data (const char *filename)
13384 {
13385   struct remote_state *rs = get_remote_state ();
13386   char *p, *reply;
13387
13388   p = rs->buf.data ();
13389   strcpy (p, "QTSave:");
13390   p += strlen (p);
13391   if ((p - rs->buf.data ()) + strlen (filename) * 2
13392       >= get_remote_packet_size ())
13393     error (_("Remote file name too long for trace save packet"));
13394   p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
13395   *p++ = '\0';
13396   putpkt (rs->buf);
13397   reply = remote_get_noisy_reply ();
13398   if (*reply == '\0')
13399     error (_("Target does not support this command."));
13400   if (strcmp (reply, "OK") != 0)
13401     error (_("Bogus reply from target: %s"), reply);
13402   return 0;
13403 }
13404
13405 /* This is basically a memory transfer, but needs to be its own packet
13406    because we don't know how the target actually organizes its trace
13407    memory, plus we want to be able to ask for as much as possible, but
13408    not be unhappy if we don't get as much as we ask for.  */
13409
13410 LONGEST
13411 remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
13412 {
13413   struct remote_state *rs = get_remote_state ();
13414   char *reply;
13415   char *p;
13416   int rslt;
13417
13418   p = rs->buf.data ();
13419   strcpy (p, "qTBuffer:");
13420   p += strlen (p);
13421   p += hexnumstr (p, offset);
13422   *p++ = ',';
13423   p += hexnumstr (p, len);
13424   *p++ = '\0';
13425
13426   putpkt (rs->buf);
13427   reply = remote_get_noisy_reply ();
13428   if (reply && *reply)
13429     {
13430       /* 'l' by itself means we're at the end of the buffer and
13431          there is nothing more to get.  */
13432       if (*reply == 'l')
13433         return 0;
13434
13435       /* Convert the reply into binary.  Limit the number of bytes to
13436          convert according to our passed-in buffer size, rather than
13437          what was returned in the packet; if the target is
13438          unexpectedly generous and gives us a bigger reply than we
13439          asked for, we don't want to crash.  */
13440       rslt = hex2bin (reply, buf, len);
13441       return rslt;
13442     }
13443
13444   /* Something went wrong, flag as an error.  */
13445   return -1;
13446 }
13447
13448 void
13449 remote_target::set_disconnected_tracing (int val)
13450 {
13451   struct remote_state *rs = get_remote_state ();
13452
13453   if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
13454     {
13455       char *reply;
13456
13457       xsnprintf (rs->buf.data (), get_remote_packet_size (),
13458                  "QTDisconnected:%x", val);
13459       putpkt (rs->buf);
13460       reply = remote_get_noisy_reply ();
13461       if (*reply == '\0')
13462         error (_("Target does not support this command."));
13463       if (strcmp (reply, "OK") != 0)
13464         error (_("Bogus reply from target: %s"), reply);
13465     }
13466   else if (val)
13467     warning (_("Target does not support disconnected tracing."));
13468 }
13469
13470 int
13471 remote_target::core_of_thread (ptid_t ptid)
13472 {
13473   struct thread_info *info = find_thread_ptid (ptid);
13474
13475   if (info != NULL && info->priv != NULL)
13476     return get_remote_thread_info (info)->core;
13477
13478   return -1;
13479 }
13480
13481 void
13482 remote_target::set_circular_trace_buffer (int val)
13483 {
13484   struct remote_state *rs = get_remote_state ();
13485   char *reply;
13486
13487   xsnprintf (rs->buf.data (), get_remote_packet_size (),
13488              "QTBuffer:circular:%x", val);
13489   putpkt (rs->buf);
13490   reply = remote_get_noisy_reply ();
13491   if (*reply == '\0')
13492     error (_("Target does not support this command."));
13493   if (strcmp (reply, "OK") != 0)
13494     error (_("Bogus reply from target: %s"), reply);
13495 }
13496
13497 traceframe_info_up
13498 remote_target::traceframe_info ()
13499 {
13500   gdb::optional<gdb::char_vector> text
13501     = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO,
13502                             NULL);
13503   if (text)
13504     return parse_traceframe_info (text->data ());
13505
13506   return NULL;
13507 }
13508
13509 /* Handle the qTMinFTPILen packet.  Returns the minimum length of
13510    instruction on which a fast tracepoint may be placed.  Returns -1
13511    if the packet is not supported, and 0 if the minimum instruction
13512    length is unknown.  */
13513
13514 int
13515 remote_target::get_min_fast_tracepoint_insn_len ()
13516 {
13517   struct remote_state *rs = get_remote_state ();
13518   char *reply;
13519
13520   /* If we're not debugging a process yet, the IPA can't be
13521      loaded.  */
13522   if (!target_has_execution)
13523     return 0;
13524
13525   /* Make sure the remote is pointing at the right process.  */
13526   set_general_process ();
13527
13528   xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen");
13529   putpkt (rs->buf);
13530   reply = remote_get_noisy_reply ();
13531   if (*reply == '\0')
13532     return -1;
13533   else
13534     {
13535       ULONGEST min_insn_len;
13536
13537       unpack_varlen_hex (reply, &min_insn_len);
13538
13539       return (int) min_insn_len;
13540     }
13541 }
13542
13543 void
13544 remote_target::set_trace_buffer_size (LONGEST val)
13545 {
13546   if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
13547     {
13548       struct remote_state *rs = get_remote_state ();
13549       char *buf = rs->buf.data ();
13550       char *endbuf = buf + get_remote_packet_size ();
13551       enum packet_result result;
13552
13553       gdb_assert (val >= 0 || val == -1);
13554       buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
13555       /* Send -1 as literal "-1" to avoid host size dependency.  */
13556       if (val < 0)
13557         {
13558           *buf++ = '-';
13559           buf += hexnumstr (buf, (ULONGEST) -val);
13560         }
13561       else
13562         buf += hexnumstr (buf, (ULONGEST) val);
13563
13564       putpkt (rs->buf);
13565       remote_get_noisy_reply ();
13566       result = packet_ok (rs->buf,
13567                   &remote_protocol_packets[PACKET_QTBuffer_size]);
13568
13569       if (result != PACKET_OK)
13570         warning (_("Bogus reply from target: %s"), rs->buf.data ());
13571     }
13572 }
13573
13574 bool
13575 remote_target::set_trace_notes (const char *user, const char *notes,
13576                                 const char *stop_notes)
13577 {
13578   struct remote_state *rs = get_remote_state ();
13579   char *reply;
13580   char *buf = rs->buf.data ();
13581   char *endbuf = buf + get_remote_packet_size ();
13582   int nbytes;
13583
13584   buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
13585   if (user)
13586     {
13587       buf += xsnprintf (buf, endbuf - buf, "user:");
13588       nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));
13589       buf += 2 * nbytes;
13590       *buf++ = ';';
13591     }
13592   if (notes)
13593     {
13594       buf += xsnprintf (buf, endbuf - buf, "notes:");
13595       nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));
13596       buf += 2 * nbytes;
13597       *buf++ = ';';
13598     }
13599   if (stop_notes)
13600     {
13601       buf += xsnprintf (buf, endbuf - buf, "tstop:");
13602       nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));
13603       buf += 2 * nbytes;
13604       *buf++ = ';';
13605     }
13606   /* Ensure the buffer is terminated.  */
13607   *buf = '\0';
13608
13609   putpkt (rs->buf);
13610   reply = remote_get_noisy_reply ();
13611   if (*reply == '\0')
13612     return false;
13613
13614   if (strcmp (reply, "OK") != 0)
13615     error (_("Bogus reply from target: %s"), reply);
13616
13617   return true;
13618 }
13619
13620 bool
13621 remote_target::use_agent (bool use)
13622 {
13623   if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
13624     {
13625       struct remote_state *rs = get_remote_state ();
13626
13627       /* If the stub supports QAgent.  */
13628       xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use);
13629       putpkt (rs->buf);
13630       getpkt (&rs->buf, 0);
13631
13632       if (strcmp (rs->buf.data (), "OK") == 0)
13633         {
13634           ::use_agent = use;
13635           return true;
13636         }
13637     }
13638
13639   return false;
13640 }
13641
13642 bool
13643 remote_target::can_use_agent ()
13644 {
13645   return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
13646 }
13647
13648 struct btrace_target_info
13649 {
13650   /* The ptid of the traced thread.  */
13651   ptid_t ptid;
13652
13653   /* The obtained branch trace configuration.  */
13654   struct btrace_config conf;
13655 };
13656
13657 /* Reset our idea of our target's btrace configuration.  */
13658
13659 static void
13660 remote_btrace_reset (remote_state *rs)
13661 {
13662   memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
13663 }
13664
13665 /* Synchronize the configuration with the target.  */
13666
13667 void
13668 remote_target::btrace_sync_conf (const btrace_config *conf)
13669 {
13670   struct packet_config *packet;
13671   struct remote_state *rs;
13672   char *buf, *pos, *endbuf;
13673
13674   rs = get_remote_state ();
13675   buf = rs->buf.data ();
13676   endbuf = buf + get_remote_packet_size ();
13677
13678   packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
13679   if (packet_config_support (packet) == PACKET_ENABLE
13680       && conf->bts.size != rs->btrace_config.bts.size)
13681     {
13682       pos = buf;
13683       pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13684                         conf->bts.size);
13685
13686       putpkt (buf);
13687       getpkt (&rs->buf, 0);
13688
13689       if (packet_ok (buf, packet) == PACKET_ERROR)
13690         {
13691           if (buf[0] == 'E' && buf[1] == '.')
13692             error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
13693           else
13694             error (_("Failed to configure the BTS buffer size."));
13695         }
13696
13697       rs->btrace_config.bts.size = conf->bts.size;
13698     }
13699
13700   packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
13701   if (packet_config_support (packet) == PACKET_ENABLE
13702       && conf->pt.size != rs->btrace_config.pt.size)
13703     {
13704       pos = buf;
13705       pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13706                         conf->pt.size);
13707
13708       putpkt (buf);
13709       getpkt (&rs->buf, 0);
13710
13711       if (packet_ok (buf, packet) == PACKET_ERROR)
13712         {
13713           if (buf[0] == 'E' && buf[1] == '.')
13714             error (_("Failed to configure the trace buffer size: %s"), buf + 2);
13715           else
13716             error (_("Failed to configure the trace buffer size."));
13717         }
13718
13719       rs->btrace_config.pt.size = conf->pt.size;
13720     }
13721 }
13722
13723 /* Read the current thread's btrace configuration from the target and
13724    store it into CONF.  */
13725
13726 static void
13727 btrace_read_config (struct btrace_config *conf)
13728 {
13729   gdb::optional<gdb::char_vector> xml
13730     = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, "");
13731   if (xml)
13732     parse_xml_btrace_conf (conf, xml->data ());
13733 }
13734
13735 /* Maybe reopen target btrace.  */
13736
13737 void
13738 remote_target::remote_btrace_maybe_reopen ()
13739 {
13740   struct remote_state *rs = get_remote_state ();
13741   int btrace_target_pushed = 0;
13742 #if !defined (HAVE_LIBIPT)
13743   int warned = 0;
13744 #endif
13745
13746   scoped_restore_current_thread restore_thread;
13747
13748   for (thread_info *tp : all_non_exited_threads ())
13749     {
13750       set_general_thread (tp->ptid);
13751
13752       memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
13753       btrace_read_config (&rs->btrace_config);
13754
13755       if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
13756         continue;
13757
13758 #if !defined (HAVE_LIBIPT)
13759       if (rs->btrace_config.format == BTRACE_FORMAT_PT)
13760         {
13761           if (!warned)
13762             {
13763               warned = 1;
13764               warning (_("Target is recording using Intel Processor Trace "
13765                          "but support was disabled at compile time."));
13766             }
13767
13768           continue;
13769         }
13770 #endif /* !defined (HAVE_LIBIPT) */
13771
13772       /* Push target, once, but before anything else happens.  This way our
13773          changes to the threads will be cleaned up by unpushing the target
13774          in case btrace_read_config () throws.  */
13775       if (!btrace_target_pushed)
13776         {
13777           btrace_target_pushed = 1;
13778           record_btrace_push_target ();
13779           printf_filtered (_("Target is recording using %s.\n"),
13780                            btrace_format_string (rs->btrace_config.format));
13781         }
13782
13783       tp->btrace.target = XCNEW (struct btrace_target_info);
13784       tp->btrace.target->ptid = tp->ptid;
13785       tp->btrace.target->conf = rs->btrace_config;
13786     }
13787 }
13788
13789 /* Enable branch tracing.  */
13790
13791 struct btrace_target_info *
13792 remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
13793 {
13794   struct btrace_target_info *tinfo = NULL;
13795   struct packet_config *packet = NULL;
13796   struct remote_state *rs = get_remote_state ();
13797   char *buf = rs->buf.data ();
13798   char *endbuf = buf + get_remote_packet_size ();
13799
13800   switch (conf->format)
13801     {
13802       case BTRACE_FORMAT_BTS:
13803         packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
13804         break;
13805
13806       case BTRACE_FORMAT_PT:
13807         packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
13808         break;
13809     }
13810
13811   if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
13812     error (_("Target does not support branch tracing."));
13813
13814   btrace_sync_conf (conf);
13815
13816   set_general_thread (ptid);
13817
13818   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13819   putpkt (rs->buf);
13820   getpkt (&rs->buf, 0);
13821
13822   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13823     {
13824       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13825         error (_("Could not enable branch tracing for %s: %s"),
13826                target_pid_to_str (ptid), &rs->buf[2]);
13827       else
13828         error (_("Could not enable branch tracing for %s."),
13829                target_pid_to_str (ptid));
13830     }
13831
13832   tinfo = XCNEW (struct btrace_target_info);
13833   tinfo->ptid = ptid;
13834
13835   /* If we fail to read the configuration, we lose some information, but the
13836      tracing itself is not impacted.  */
13837   TRY
13838     {
13839       btrace_read_config (&tinfo->conf);
13840     }
13841   CATCH (err, RETURN_MASK_ERROR)
13842     {
13843       if (err.message != NULL)
13844         warning ("%s", err.message);
13845     }
13846   END_CATCH
13847
13848   return tinfo;
13849 }
13850
13851 /* Disable branch tracing.  */
13852
13853 void
13854 remote_target::disable_btrace (struct btrace_target_info *tinfo)
13855 {
13856   struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
13857   struct remote_state *rs = get_remote_state ();
13858   char *buf = rs->buf.data ();
13859   char *endbuf = buf + get_remote_packet_size ();
13860
13861   if (packet_config_support (packet) != PACKET_ENABLE)
13862     error (_("Target does not support branch tracing."));
13863
13864   set_general_thread (tinfo->ptid);
13865
13866   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13867   putpkt (rs->buf);
13868   getpkt (&rs->buf, 0);
13869
13870   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13871     {
13872       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13873         error (_("Could not disable branch tracing for %s: %s"),
13874                target_pid_to_str (tinfo->ptid), &rs->buf[2]);
13875       else
13876         error (_("Could not disable branch tracing for %s."),
13877                target_pid_to_str (tinfo->ptid));
13878     }
13879
13880   xfree (tinfo);
13881 }
13882
13883 /* Teardown branch tracing.  */
13884
13885 void
13886 remote_target::teardown_btrace (struct btrace_target_info *tinfo)
13887 {
13888   /* We must not talk to the target during teardown.  */
13889   xfree (tinfo);
13890 }
13891
13892 /* Read the branch trace.  */
13893
13894 enum btrace_error
13895 remote_target::read_btrace (struct btrace_data *btrace,
13896                             struct btrace_target_info *tinfo,
13897                             enum btrace_read_type type)
13898 {
13899   struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
13900   const char *annex;
13901
13902   if (packet_config_support (packet) != PACKET_ENABLE)
13903     error (_("Target does not support branch tracing."));
13904
13905 #if !defined(HAVE_LIBEXPAT)
13906   error (_("Cannot process branch tracing result. XML parsing not supported."));
13907 #endif
13908
13909   switch (type)
13910     {
13911     case BTRACE_READ_ALL:
13912       annex = "all";
13913       break;
13914     case BTRACE_READ_NEW:
13915       annex = "new";
13916       break;
13917     case BTRACE_READ_DELTA:
13918       annex = "delta";
13919       break;
13920     default:
13921       internal_error (__FILE__, __LINE__,
13922                       _("Bad branch tracing read type: %u."),
13923                       (unsigned int) type);
13924     }
13925
13926   gdb::optional<gdb::char_vector> xml
13927     = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex);
13928   if (!xml)
13929     return BTRACE_ERR_UNKNOWN;
13930
13931   parse_xml_btrace (btrace, xml->data ());
13932
13933   return BTRACE_ERR_NONE;
13934 }
13935
13936 const struct btrace_config *
13937 remote_target::btrace_conf (const struct btrace_target_info *tinfo)
13938 {
13939   return &tinfo->conf;
13940 }
13941
13942 bool
13943 remote_target::augmented_libraries_svr4_read ()
13944 {
13945   return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
13946           == PACKET_ENABLE);
13947 }
13948
13949 /* Implementation of to_load.  */
13950
13951 void
13952 remote_target::load (const char *name, int from_tty)
13953 {
13954   generic_load (name, from_tty);
13955 }
13956
13957 /* Accepts an integer PID; returns a string representing a file that
13958    can be opened on the remote side to get the symbols for the child
13959    process.  Returns NULL if the operation is not supported.  */
13960
13961 char *
13962 remote_target::pid_to_exec_file (int pid)
13963 {
13964   static gdb::optional<gdb::char_vector> filename;
13965   struct inferior *inf;
13966   char *annex = NULL;
13967
13968   if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
13969     return NULL;
13970
13971   inf = find_inferior_pid (pid);
13972   if (inf == NULL)
13973     internal_error (__FILE__, __LINE__,
13974                     _("not currently attached to process %d"), pid);
13975
13976   if (!inf->fake_pid_p)
13977     {
13978       const int annex_size = 9;
13979
13980       annex = (char *) alloca (annex_size);
13981       xsnprintf (annex, annex_size, "%x", pid);
13982     }
13983
13984   filename = target_read_stralloc (current_top_target (),
13985                                    TARGET_OBJECT_EXEC_FILE, annex);
13986
13987   return filename ? filename->data () : nullptr;
13988 }
13989
13990 /* Implement the to_can_do_single_step target_ops method.  */
13991
13992 int
13993 remote_target::can_do_single_step ()
13994 {
13995   /* We can only tell whether target supports single step or not by
13996      supported s and S vCont actions if the stub supports vContSupported
13997      feature.  If the stub doesn't support vContSupported feature,
13998      we have conservatively to think target doesn't supports single
13999      step.  */
14000   if (packet_support (PACKET_vContSupported) == PACKET_ENABLE)
14001     {
14002       struct remote_state *rs = get_remote_state ();
14003
14004       if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
14005         remote_vcont_probe ();
14006
14007       return rs->supports_vCont.s && rs->supports_vCont.S;
14008     }
14009   else
14010     return 0;
14011 }
14012
14013 /* Implementation of the to_execution_direction method for the remote
14014    target.  */
14015
14016 enum exec_direction_kind
14017 remote_target::execution_direction ()
14018 {
14019   struct remote_state *rs = get_remote_state ();
14020
14021   return rs->last_resume_exec_dir;
14022 }
14023
14024 /* Return pointer to the thread_info struct which corresponds to
14025    THREAD_HANDLE (having length HANDLE_LEN).  */
14026
14027 thread_info *
14028 remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
14029                                              int handle_len,
14030                                              inferior *inf)
14031 {
14032   for (thread_info *tp : all_non_exited_threads ())
14033     {
14034       remote_thread_info *priv = get_remote_thread_info (tp);
14035
14036       if (tp->inf == inf && priv != NULL)
14037         {
14038           if (handle_len != priv->thread_handle.size ())
14039             error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
14040                    handle_len, priv->thread_handle.size ());
14041           if (memcmp (thread_handle, priv->thread_handle.data (),
14042                       handle_len) == 0)
14043             return tp;
14044         }
14045     }
14046
14047   return NULL;
14048 }
14049
14050 bool
14051 remote_target::can_async_p ()
14052 {
14053   struct remote_state *rs = get_remote_state ();
14054
14055   /* We don't go async if the user has explicitly prevented it with the
14056      "maint set target-async" command.  */
14057   if (!target_async_permitted)
14058     return false;
14059
14060   /* We're async whenever the serial device is.  */
14061   return serial_can_async_p (rs->remote_desc);
14062 }
14063
14064 bool
14065 remote_target::is_async_p ()
14066 {
14067   struct remote_state *rs = get_remote_state ();
14068
14069   if (!target_async_permitted)
14070     /* We only enable async when the user specifically asks for it.  */
14071     return false;
14072
14073   /* We're async whenever the serial device is.  */
14074   return serial_is_async_p (rs->remote_desc);
14075 }
14076
14077 /* Pass the SERIAL event on and up to the client.  One day this code
14078    will be able to delay notifying the client of an event until the
14079    point where an entire packet has been received.  */
14080
14081 static serial_event_ftype remote_async_serial_handler;
14082
14083 static void
14084 remote_async_serial_handler (struct serial *scb, void *context)
14085 {
14086   /* Don't propogate error information up to the client.  Instead let
14087      the client find out about the error by querying the target.  */
14088   inferior_event_handler (INF_REG_EVENT, NULL);
14089 }
14090
14091 static void
14092 remote_async_inferior_event_handler (gdb_client_data data)
14093 {
14094   inferior_event_handler (INF_REG_EVENT, data);
14095 }
14096
14097 void
14098 remote_target::async (int enable)
14099 {
14100   struct remote_state *rs = get_remote_state ();
14101
14102   if (enable)
14103     {
14104       serial_async (rs->remote_desc, remote_async_serial_handler, rs);
14105
14106       /* If there are pending events in the stop reply queue tell the
14107          event loop to process them.  */
14108       if (!rs->stop_reply_queue.empty ())
14109         mark_async_event_handler (rs->remote_async_inferior_event_token);
14110       /* For simplicity, below we clear the pending events token
14111          without remembering whether it is marked, so here we always
14112          mark it.  If there's actually no pending notification to
14113          process, this ends up being a no-op (other than a spurious
14114          event-loop wakeup).  */
14115       if (target_is_non_stop_p ())
14116         mark_async_event_handler (rs->notif_state->get_pending_events_token);
14117     }
14118   else
14119     {
14120       serial_async (rs->remote_desc, NULL, NULL);
14121       /* If the core is disabling async, it doesn't want to be
14122          disturbed with target events.  Clear all async event sources
14123          too.  */
14124       clear_async_event_handler (rs->remote_async_inferior_event_token);
14125       if (target_is_non_stop_p ())
14126         clear_async_event_handler (rs->notif_state->get_pending_events_token);
14127     }
14128 }
14129
14130 /* Implementation of the to_thread_events method.  */
14131
14132 void
14133 remote_target::thread_events (int enable)
14134 {
14135   struct remote_state *rs = get_remote_state ();
14136   size_t size = get_remote_packet_size ();
14137
14138   if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
14139     return;
14140
14141   xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0);
14142   putpkt (rs->buf);
14143   getpkt (&rs->buf, 0);
14144
14145   switch (packet_ok (rs->buf,
14146                      &remote_protocol_packets[PACKET_QThreadEvents]))
14147     {
14148     case PACKET_OK:
14149       if (strcmp (rs->buf.data (), "OK") != 0)
14150         error (_("Remote refused setting thread events: %s"), rs->buf.data ());
14151       break;
14152     case PACKET_ERROR:
14153       warning (_("Remote failure reply: %s"), rs->buf.data ());
14154       break;
14155     case PACKET_UNKNOWN:
14156       break;
14157     }
14158 }
14159
14160 static void
14161 set_remote_cmd (const char *args, int from_tty)
14162 {
14163   help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
14164 }
14165
14166 static void
14167 show_remote_cmd (const char *args, int from_tty)
14168 {
14169   /* We can't just use cmd_show_list here, because we want to skip
14170      the redundant "show remote Z-packet" and the legacy aliases.  */
14171   struct cmd_list_element *list = remote_show_cmdlist;
14172   struct ui_out *uiout = current_uiout;
14173
14174   ui_out_emit_tuple tuple_emitter (uiout, "showlist");
14175   for (; list != NULL; list = list->next)
14176     if (strcmp (list->name, "Z-packet") == 0)
14177       continue;
14178     else if (list->type == not_set_cmd)
14179       /* Alias commands are exactly like the original, except they
14180          don't have the normal type.  */
14181       continue;
14182     else
14183       {
14184         ui_out_emit_tuple option_emitter (uiout, "option");
14185
14186         uiout->field_string ("name", list->name);
14187         uiout->text (":  ");
14188         if (list->type == show_cmd)
14189           do_show_command (NULL, from_tty, list);
14190         else
14191           cmd_func (list, NULL, from_tty);
14192       }
14193 }
14194
14195
14196 /* Function to be called whenever a new objfile (shlib) is detected.  */
14197 static void
14198 remote_new_objfile (struct objfile *objfile)
14199 {
14200   remote_target *remote = get_current_remote_target ();
14201
14202   if (remote != NULL)                   /* Have a remote connection.  */
14203     remote->remote_check_symbols ();
14204 }
14205
14206 /* Pull all the tracepoints defined on the target and create local
14207    data structures representing them.  We don't want to create real
14208    tracepoints yet, we don't want to mess up the user's existing
14209    collection.  */
14210   
14211 int
14212 remote_target::upload_tracepoints (struct uploaded_tp **utpp)
14213 {
14214   struct remote_state *rs = get_remote_state ();
14215   char *p;
14216
14217   /* Ask for a first packet of tracepoint definition.  */
14218   putpkt ("qTfP");
14219   getpkt (&rs->buf, 0);
14220   p = rs->buf.data ();
14221   while (*p && *p != 'l')
14222     {
14223       parse_tracepoint_definition (p, utpp);
14224       /* Ask for another packet of tracepoint definition.  */
14225       putpkt ("qTsP");
14226       getpkt (&rs->buf, 0);
14227       p = rs->buf.data ();
14228     }
14229   return 0;
14230 }
14231
14232 int
14233 remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp)
14234 {
14235   struct remote_state *rs = get_remote_state ();
14236   char *p;
14237
14238   /* Ask for a first packet of variable definition.  */
14239   putpkt ("qTfV");
14240   getpkt (&rs->buf, 0);
14241   p = rs->buf.data ();
14242   while (*p && *p != 'l')
14243     {
14244       parse_tsv_definition (p, utsvp);
14245       /* Ask for another packet of variable definition.  */
14246       putpkt ("qTsV");
14247       getpkt (&rs->buf, 0);
14248       p = rs->buf.data ();
14249     }
14250   return 0;
14251 }
14252
14253 /* The "set/show range-stepping" show hook.  */
14254
14255 static void
14256 show_range_stepping (struct ui_file *file, int from_tty,
14257                      struct cmd_list_element *c,
14258                      const char *value)
14259 {
14260   fprintf_filtered (file,
14261                     _("Debugger's willingness to use range stepping "
14262                       "is %s.\n"), value);
14263 }
14264
14265 /* Return true if the vCont;r action is supported by the remote
14266    stub.  */
14267
14268 bool
14269 remote_target::vcont_r_supported ()
14270 {
14271   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
14272     remote_vcont_probe ();
14273
14274   return (packet_support (PACKET_vCont) == PACKET_ENABLE
14275           && get_remote_state ()->supports_vCont.r);
14276 }
14277
14278 /* The "set/show range-stepping" set hook.  */
14279
14280 static void
14281 set_range_stepping (const char *ignore_args, int from_tty,
14282                     struct cmd_list_element *c)
14283 {
14284   /* When enabling, check whether range stepping is actually supported
14285      by the target, and warn if not.  */
14286   if (use_range_stepping)
14287     {
14288       remote_target *remote = get_current_remote_target ();
14289       if (remote == NULL
14290           || !remote->vcont_r_supported ())
14291         warning (_("Range stepping is not supported by the current target"));
14292     }
14293 }
14294
14295 void
14296 _initialize_remote (void)
14297 {
14298   struct cmd_list_element *cmd;
14299   const char *cmd_name;
14300
14301   /* architecture specific data */
14302   remote_g_packet_data_handle =
14303     gdbarch_data_register_pre_init (remote_g_packet_data_init);
14304
14305   remote_pspace_data
14306     = register_program_space_data_with_cleanup (NULL,
14307                                                 remote_pspace_data_cleanup);
14308
14309   add_target (remote_target_info, remote_target::open);
14310   add_target (extended_remote_target_info, extended_remote_target::open);
14311
14312   /* Hook into new objfile notification.  */
14313   gdb::observers::new_objfile.attach (remote_new_objfile);
14314
14315 #if 0
14316   init_remote_threadtests ();
14317 #endif
14318
14319   /* set/show remote ...  */
14320
14321   add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
14322 Remote protocol specific variables\n\
14323 Configure various remote-protocol specific variables such as\n\
14324 the packets being used"),
14325                   &remote_set_cmdlist, "set remote ",
14326                   0 /* allow-unknown */, &setlist);
14327   add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
14328 Remote protocol specific variables\n\
14329 Configure various remote-protocol specific variables such as\n\
14330 the packets being used"),
14331                   &remote_show_cmdlist, "show remote ",
14332                   0 /* allow-unknown */, &showlist);
14333
14334   add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
14335 Compare section data on target to the exec file.\n\
14336 Argument is a single section name (default: all loaded sections).\n\
14337 To compare only read-only loaded sections, specify the -r option."),
14338            &cmdlist);
14339
14340   add_cmd ("packet", class_maintenance, packet_command, _("\
14341 Send an arbitrary packet to a remote target.\n\
14342    maintenance packet TEXT\n\
14343 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14344 this command sends the string TEXT to the inferior, and displays the\n\
14345 response packet.  GDB supplies the initial `$' character, and the\n\
14346 terminating `#' character and checksum."),
14347            &maintenancelist);
14348
14349   add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
14350 Set whether to send break if interrupted."), _("\
14351 Show whether to send break if interrupted."), _("\
14352 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14353                            set_remotebreak, show_remotebreak,
14354                            &setlist, &showlist);
14355   cmd_name = "remotebreak";
14356   cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
14357   deprecate_cmd (cmd, "set remote interrupt-sequence");
14358   cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
14359   cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
14360   deprecate_cmd (cmd, "show remote interrupt-sequence");
14361
14362   add_setshow_enum_cmd ("interrupt-sequence", class_support,
14363                         interrupt_sequence_modes, &interrupt_sequence_mode,
14364                         _("\
14365 Set interrupt sequence to remote target."), _("\
14366 Show interrupt sequence to remote target."), _("\
14367 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14368                         NULL, show_interrupt_sequence,
14369                         &remote_set_cmdlist,
14370                         &remote_show_cmdlist);
14371
14372   add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
14373                            &interrupt_on_connect, _("\
14374 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("            \
14375 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("           \
14376 If set, interrupt sequence is sent to remote target."),
14377                            NULL, NULL,
14378                            &remote_set_cmdlist, &remote_show_cmdlist);
14379
14380   /* Install commands for configuring memory read/write packets.  */
14381
14382   add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
14383 Set the maximum number of bytes per memory write packet (deprecated)."),
14384            &setlist);
14385   add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
14386 Show the maximum number of bytes per memory write packet (deprecated)."),
14387            &showlist);
14388   add_cmd ("memory-write-packet-size", no_class,
14389            set_memory_write_packet_size, _("\
14390 Set the maximum number of bytes per memory-write packet.\n\
14391 Specify the number of bytes in a packet or 0 (zero) for the\n\
14392 default packet size.  The actual limit is further reduced\n\
14393 dependent on the target.  Specify ``fixed'' to disable the\n\
14394 further restriction and ``limit'' to enable that restriction."),
14395            &remote_set_cmdlist);
14396   add_cmd ("memory-read-packet-size", no_class,
14397            set_memory_read_packet_size, _("\
14398 Set the maximum number of bytes per memory-read packet.\n\
14399 Specify the number of bytes in a packet or 0 (zero) for the\n\
14400 default packet size.  The actual limit is further reduced\n\
14401 dependent on the target.  Specify ``fixed'' to disable the\n\
14402 further restriction and ``limit'' to enable that restriction."),
14403            &remote_set_cmdlist);
14404   add_cmd ("memory-write-packet-size", no_class,
14405            show_memory_write_packet_size,
14406            _("Show the maximum number of bytes per memory-write packet."),
14407            &remote_show_cmdlist);
14408   add_cmd ("memory-read-packet-size", no_class,
14409            show_memory_read_packet_size,
14410            _("Show the maximum number of bytes per memory-read packet."),
14411            &remote_show_cmdlist);
14412
14413   add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class,
14414                             &remote_hw_watchpoint_limit, _("\
14415 Set the maximum number of target hardware watchpoints."), _("\
14416 Show the maximum number of target hardware watchpoints."), _("\
14417 Specify \"unlimited\" for unlimited hardware watchpoints."),
14418                             NULL, show_hardware_watchpoint_limit,
14419                             &remote_set_cmdlist,
14420                             &remote_show_cmdlist);
14421   add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14422                             no_class,
14423                             &remote_hw_watchpoint_length_limit, _("\
14424 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14425 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14426 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14427                             NULL, show_hardware_watchpoint_length_limit,
14428                             &remote_set_cmdlist, &remote_show_cmdlist);
14429   add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class,
14430                             &remote_hw_breakpoint_limit, _("\
14431 Set the maximum number of target hardware breakpoints."), _("\
14432 Show the maximum number of target hardware breakpoints."), _("\
14433 Specify \"unlimited\" for unlimited hardware breakpoints."),
14434                             NULL, show_hardware_breakpoint_limit,
14435                             &remote_set_cmdlist, &remote_show_cmdlist);
14436
14437   add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure,
14438                              &remote_address_size, _("\
14439 Set the maximum size of the address (in bits) in a memory packet."), _("\
14440 Show the maximum size of the address (in bits) in a memory packet."), NULL,
14441                              NULL,
14442                              NULL, /* FIXME: i18n: */
14443                              &setlist, &showlist);
14444
14445   init_all_packet_configs ();
14446
14447   add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
14448                          "X", "binary-download", 1);
14449
14450   add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
14451                          "vCont", "verbose-resume", 0);
14452
14453   add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
14454                          "QPassSignals", "pass-signals", 0);
14455
14456   add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls],
14457                          "QCatchSyscalls", "catch-syscalls", 0);
14458
14459   add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
14460                          "QProgramSignals", "program-signals", 0);
14461
14462   add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir],
14463                          "QSetWorkingDir", "set-working-dir", 0);
14464
14465   add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell],
14466                          "QStartupWithShell", "startup-with-shell", 0);
14467
14468   add_packet_config_cmd (&remote_protocol_packets
14469                          [PACKET_QEnvironmentHexEncoded],
14470                          "QEnvironmentHexEncoded", "environment-hex-encoded",
14471                          0);
14472
14473   add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset],
14474                          "QEnvironmentReset", "environment-reset",
14475                          0);
14476
14477   add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset],
14478                          "QEnvironmentUnset", "environment-unset",
14479                          0);
14480
14481   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
14482                          "qSymbol", "symbol-lookup", 0);
14483
14484   add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
14485                          "P", "set-register", 1);
14486
14487   add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
14488                          "p", "fetch-register", 1);
14489
14490   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
14491                          "Z0", "software-breakpoint", 0);
14492
14493   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
14494                          "Z1", "hardware-breakpoint", 0);
14495
14496   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
14497                          "Z2", "write-watchpoint", 0);
14498
14499   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
14500                          "Z3", "read-watchpoint", 0);
14501
14502   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
14503                          "Z4", "access-watchpoint", 0);
14504
14505   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
14506                          "qXfer:auxv:read", "read-aux-vector", 0);
14507
14508   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
14509                          "qXfer:exec-file:read", "pid-to-exec-file", 0);
14510
14511   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
14512                          "qXfer:features:read", "target-features", 0);
14513
14514   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
14515                          "qXfer:libraries:read", "library-info", 0);
14516
14517   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
14518                          "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14519
14520   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
14521                          "qXfer:memory-map:read", "memory-map", 0);
14522
14523   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
14524                          "qXfer:spu:read", "read-spu-object", 0);
14525
14526   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
14527                          "qXfer:spu:write", "write-spu-object", 0);
14528
14529   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
14530                         "qXfer:osdata:read", "osdata", 0);
14531
14532   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
14533                          "qXfer:threads:read", "threads", 0);
14534
14535   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
14536                          "qXfer:siginfo:read", "read-siginfo-object", 0);
14537
14538   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
14539                          "qXfer:siginfo:write", "write-siginfo-object", 0);
14540
14541   add_packet_config_cmd
14542     (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
14543      "qXfer:traceframe-info:read", "traceframe-info", 0);
14544
14545   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
14546                          "qXfer:uib:read", "unwind-info-block", 0);
14547
14548   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
14549                          "qGetTLSAddr", "get-thread-local-storage-address",
14550                          0);
14551
14552   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
14553                          "qGetTIBAddr", "get-thread-information-block-address",
14554                          0);
14555
14556   add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
14557                          "bc", "reverse-continue", 0);
14558
14559   add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
14560                          "bs", "reverse-step", 0);
14561
14562   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
14563                          "qSupported", "supported-packets", 0);
14564
14565   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
14566                          "qSearch:memory", "search-memory", 0);
14567
14568   add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
14569                          "qTStatus", "trace-status", 0);
14570
14571   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
14572                          "vFile:setfs", "hostio-setfs", 0);
14573
14574   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
14575                          "vFile:open", "hostio-open", 0);
14576
14577   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
14578                          "vFile:pread", "hostio-pread", 0);
14579
14580   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
14581                          "vFile:pwrite", "hostio-pwrite", 0);
14582
14583   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
14584                          "vFile:close", "hostio-close", 0);
14585
14586   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
14587                          "vFile:unlink", "hostio-unlink", 0);
14588
14589   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
14590                          "vFile:readlink", "hostio-readlink", 0);
14591
14592   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
14593                          "vFile:fstat", "hostio-fstat", 0);
14594
14595   add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
14596                          "vAttach", "attach", 0);
14597
14598   add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
14599                          "vRun", "run", 0);
14600
14601   add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
14602                          "QStartNoAckMode", "noack", 0);
14603
14604   add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
14605                          "vKill", "kill", 0);
14606
14607   add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
14608                          "qAttached", "query-attached", 0);
14609
14610   add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
14611                          "ConditionalTracepoints",
14612                          "conditional-tracepoints", 0);
14613
14614   add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
14615                          "ConditionalBreakpoints",
14616                          "conditional-breakpoints", 0);
14617
14618   add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
14619                          "BreakpointCommands",
14620                          "breakpoint-commands", 0);
14621
14622   add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
14623                          "FastTracepoints", "fast-tracepoints", 0);
14624
14625   add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
14626                          "TracepointSource", "TracepointSource", 0);
14627
14628   add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
14629                          "QAllow", "allow", 0);
14630
14631   add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
14632                          "StaticTracepoints", "static-tracepoints", 0);
14633
14634   add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
14635                          "InstallInTrace", "install-in-trace", 0);
14636
14637   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
14638                          "qXfer:statictrace:read", "read-sdata-object", 0);
14639
14640   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
14641                          "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14642
14643   add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
14644                          "QDisableRandomization", "disable-randomization", 0);
14645
14646   add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
14647                          "QAgent", "agent", 0);
14648
14649   add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
14650                          "QTBuffer:size", "trace-buffer-size", 0);
14651
14652   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
14653        "Qbtrace:off", "disable-btrace", 0);
14654
14655   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
14656        "Qbtrace:bts", "enable-btrace-bts", 0);
14657
14658   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
14659        "Qbtrace:pt", "enable-btrace-pt", 0);
14660
14661   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
14662        "qXfer:btrace", "read-btrace", 0);
14663
14664   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
14665        "qXfer:btrace-conf", "read-btrace-conf", 0);
14666
14667   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
14668        "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14669
14670   add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature],
14671        "multiprocess-feature", "multiprocess-feature", 0);
14672
14673   add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
14674                          "swbreak-feature", "swbreak-feature", 0);
14675
14676   add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
14677                          "hwbreak-feature", "hwbreak-feature", 0);
14678
14679   add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
14680                          "fork-event-feature", "fork-event-feature", 0);
14681
14682   add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
14683                          "vfork-event-feature", "vfork-event-feature", 0);
14684
14685   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
14686        "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14687
14688   add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported],
14689                          "vContSupported", "verbose-resume-supported", 0);
14690
14691   add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature],
14692                          "exec-event-feature", "exec-event-feature", 0);
14693
14694   add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC],
14695                          "vCtrlC", "ctrl-c", 0);
14696
14697   add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents],
14698                          "QThreadEvents", "thread-events", 0);
14699
14700   add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
14701                          "N stop reply", "no-resumed-stop-reply", 0);
14702
14703   /* Assert that we've registered "set remote foo-packet" commands
14704      for all packet configs.  */
14705   {
14706     int i;
14707
14708     for (i = 0; i < PACKET_MAX; i++)
14709       {
14710         /* Ideally all configs would have a command associated.  Some
14711            still don't though.  */
14712         int excepted;
14713
14714         switch (i)
14715           {
14716           case PACKET_QNonStop:
14717           case PACKET_EnableDisableTracepoints_feature:
14718           case PACKET_tracenz_feature:
14719           case PACKET_DisconnectedTracing_feature:
14720           case PACKET_augmented_libraries_svr4_read_feature:
14721           case PACKET_qCRC:
14722             /* Additions to this list need to be well justified:
14723                pre-existing packets are OK; new packets are not.  */
14724             excepted = 1;
14725             break;
14726           default:
14727             excepted = 0;
14728             break;
14729           }
14730
14731         /* This catches both forgetting to add a config command, and
14732            forgetting to remove a packet from the exception list.  */
14733         gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
14734       }
14735   }
14736
14737   /* Keep the old ``set remote Z-packet ...'' working.  Each individual
14738      Z sub-packet has its own set and show commands, but users may
14739      have sets to this variable in their .gdbinit files (or in their
14740      documentation).  */
14741   add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
14742                                 &remote_Z_packet_detect, _("\
14743 Set use of remote protocol `Z' packets"), _("\
14744 Show use of remote protocol `Z' packets "), _("\
14745 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14746 packets."),
14747                                 set_remote_protocol_Z_packet_cmd,
14748                                 show_remote_protocol_Z_packet_cmd,
14749                                 /* FIXME: i18n: Use of remote protocol
14750                                    `Z' packets is %s.  */
14751                                 &remote_set_cmdlist, &remote_show_cmdlist);
14752
14753   add_prefix_cmd ("remote", class_files, remote_command, _("\
14754 Manipulate files on the remote system\n\
14755 Transfer files to and from the remote target system."),
14756                   &remote_cmdlist, "remote ",
14757                   0 /* allow-unknown */, &cmdlist);
14758
14759   add_cmd ("put", class_files, remote_put_command,
14760            _("Copy a local file to the remote system."),
14761            &remote_cmdlist);
14762
14763   add_cmd ("get", class_files, remote_get_command,
14764            _("Copy a remote file to the local system."),
14765            &remote_cmdlist);
14766
14767   add_cmd ("delete", class_files, remote_delete_command,
14768            _("Delete a remote file."),
14769            &remote_cmdlist);
14770
14771   add_setshow_string_noescape_cmd ("exec-file", class_files,
14772                                    &remote_exec_file_var, _("\
14773 Set the remote pathname for \"run\""), _("\
14774 Show the remote pathname for \"run\""), NULL,
14775                                    set_remote_exec_file,
14776                                    show_remote_exec_file,
14777                                    &remote_set_cmdlist,
14778                                    &remote_show_cmdlist);
14779
14780   add_setshow_boolean_cmd ("range-stepping", class_run,
14781                            &use_range_stepping, _("\
14782 Enable or disable range stepping."), _("\
14783 Show whether target-assisted range stepping is enabled."), _("\
14784 If on, and the target supports it, when stepping a source line, GDB\n\
14785 tells the target to step the corresponding range of addresses itself instead\n\
14786 of issuing multiple single-steps.  This speeds up source level\n\
14787 stepping.  If off, GDB always issues single-steps, even if range\n\
14788 stepping is supported by the target.  The default is on."),
14789                            set_range_stepping,
14790                            show_range_stepping,
14791                            &setlist,
14792                            &showlist);
14793
14794   /* Eventually initialize fileio.  See fileio.c */
14795   initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
14796
14797   /* Take advantage of the fact that the TID field is not used, to tag
14798      special ptids with it set to != 0.  */
14799   magic_null_ptid = ptid_t (42000, -1, 1);
14800   not_sent_ptid = ptid_t (42000, -2, 1);
14801   any_thread_ptid = ptid_t (42000, 0, 1);
14802 }