Turn tui_erase_source_content into a method
[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 "gdbsupport/filestuff.h"
46 #include "gdbsupport/rsp-low.h"
47 #include "disasm.h"
48 #include "location.h"
49
50 #include "gdbsupport/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 "gdbsupport/agent.h"
72 #include "btrace.h"
73 #include "record-btrace.h"
74 #include <algorithm>
75 #include "gdbsupport/scoped_restore.h"
76 #include "gdbsupport/environ.h"
77 #include "gdbsupport/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 typedef std::unique_ptr<stop_reply> stop_reply_up;
100
101 /* Generic configuration support for packets the stub optionally
102    supports.  Allows the user to specify the use of the packet as well
103    as allowing GDB to auto-detect support in the remote stub.  */
104
105 enum packet_support
106   {
107     PACKET_SUPPORT_UNKNOWN = 0,
108     PACKET_ENABLE,
109     PACKET_DISABLE
110   };
111
112 /* Analyze a packet's return value and update the packet config
113    accordingly.  */
114
115 enum packet_result
116 {
117   PACKET_ERROR,
118   PACKET_OK,
119   PACKET_UNKNOWN
120 };
121
122 struct threads_listing_context;
123
124 /* Stub vCont actions support.
125
126    Each field is a boolean flag indicating whether the stub reports
127    support for the corresponding action.  */
128
129 struct vCont_action_support
130 {
131   /* vCont;t */
132   bool t = false;
133
134   /* vCont;r */
135   bool r = false;
136
137   /* vCont;s */
138   bool s = false;
139
140   /* vCont;S */
141   bool S = false;
142 };
143
144 /* About this many threadisds fit in a packet.  */
145
146 #define MAXTHREADLISTRESULTS 32
147
148 /* Data for the vFile:pread readahead cache.  */
149
150 struct readahead_cache
151 {
152   /* Invalidate the readahead cache.  */
153   void invalidate ();
154
155   /* Invalidate the readahead cache if it is holding data for FD.  */
156   void invalidate_fd (int fd);
157
158   /* Serve pread from the readahead cache.  Returns number of bytes
159      read, or 0 if the request can't be served from the cache.  */
160   int pread (int fd, gdb_byte *read_buf, size_t len, ULONGEST offset);
161
162   /* The file descriptor for the file that is being cached.  -1 if the
163      cache is invalid.  */
164   int fd = -1;
165
166   /* The offset into the file that the cache buffer corresponds
167      to.  */
168   ULONGEST offset = 0;
169
170   /* The buffer holding the cache contents.  */
171   gdb_byte *buf = nullptr;
172   /* The buffer's size.  We try to read as much as fits into a packet
173      at a time.  */
174   size_t bufsize = 0;
175
176   /* Cache hit and miss counters.  */
177   ULONGEST hit_count = 0;
178   ULONGEST miss_count = 0;
179 };
180
181 /* Description of the remote protocol for a given architecture.  */
182
183 struct packet_reg
184 {
185   long offset; /* Offset into G packet.  */
186   long regnum; /* GDB's internal register number.  */
187   LONGEST pnum; /* Remote protocol register number.  */
188   int in_g_packet; /* Always part of G packet.  */
189   /* long size in bytes;  == register_size (target_gdbarch (), regnum);
190      at present.  */
191   /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
192      at present.  */
193 };
194
195 struct remote_arch_state
196 {
197   explicit remote_arch_state (struct gdbarch *gdbarch);
198
199   /* Description of the remote protocol registers.  */
200   long sizeof_g_packet;
201
202   /* Description of the remote protocol registers indexed by REGNUM
203      (making an array gdbarch_num_regs in size).  */
204   std::unique_ptr<packet_reg[]> regs;
205
206   /* This is the size (in chars) of the first response to the ``g''
207      packet.  It is used as a heuristic when determining the maximum
208      size of memory-read and memory-write packets.  A target will
209      typically only reserve a buffer large enough to hold the ``g''
210      packet.  The size does not include packet overhead (headers and
211      trailers).  */
212   long actual_register_packet_size;
213
214   /* This is the maximum size (in chars) of a non read/write packet.
215      It is also used as a cap on the size of read/write packets.  */
216   long remote_packet_size;
217 };
218
219 /* Description of the remote protocol state for the currently
220    connected target.  This is per-target state, and independent of the
221    selected architecture.  */
222
223 class remote_state
224 {
225 public:
226
227   remote_state ();
228   ~remote_state ();
229
230   /* Get the remote arch state for GDBARCH.  */
231   struct remote_arch_state *get_remote_arch_state (struct gdbarch *gdbarch);
232
233 public: /* data */
234
235   /* A buffer to use for incoming packets, and its current size.  The
236      buffer is grown dynamically for larger incoming packets.
237      Outgoing packets may also be constructed in this buffer.
238      The size of the buffer is always at least REMOTE_PACKET_SIZE;
239      REMOTE_PACKET_SIZE should be used to limit the length of outgoing
240      packets.  */
241   gdb::char_vector buf;
242
243   /* True if we're going through initial connection setup (finding out
244      about the remote side's threads, relocating symbols, etc.).  */
245   bool starting_up = false;
246
247   /* If we negotiated packet size explicitly (and thus can bypass
248      heuristics for the largest packet size that will not overflow
249      a buffer in the stub), this will be set to that packet size.
250      Otherwise zero, meaning to use the guessed size.  */
251   long explicit_packet_size = 0;
252
253   /* remote_wait is normally called when the target is running and
254      waits for a stop reply packet.  But sometimes we need to call it
255      when the target is already stopped.  We can send a "?" packet
256      and have remote_wait read the response.  Or, if we already have
257      the response, we can stash it in BUF and tell remote_wait to
258      skip calling getpkt.  This flag is set when BUF contains a
259      stop reply packet and the target is not waiting.  */
260   int cached_wait_status = 0;
261
262   /* True, if in no ack mode.  That is, neither GDB nor the stub will
263      expect acks from each other.  The connection is assumed to be
264      reliable.  */
265   bool noack_mode = false;
266
267   /* True if we're connected in extended remote mode.  */
268   bool extended = false;
269
270   /* True if we resumed the target and we're waiting for the target to
271      stop.  In the mean time, we can't start another command/query.
272      The remote server wouldn't be ready to process it, so we'd
273      timeout waiting for a reply that would never come and eventually
274      we'd close the connection.  This can happen in asynchronous mode
275      because we allow GDB commands while the target is running.  */
276   bool waiting_for_stop_reply = false;
277
278   /* The status of the stub support for the various vCont actions.  */
279   vCont_action_support supports_vCont;
280
281   /* True if the user has pressed Ctrl-C, but the target hasn't
282      responded to that.  */
283   bool ctrlc_pending_p = false;
284
285   /* True if we saw a Ctrl-C while reading or writing from/to the
286      remote descriptor.  At that point it is not safe to send a remote
287      interrupt packet, so we instead remember we saw the Ctrl-C and
288      process it once we're done with sending/receiving the current
289      packet, which should be shortly.  If however that takes too long,
290      and the user presses Ctrl-C again, we offer to disconnect.  */
291   bool got_ctrlc_during_io = false;
292
293   /* Descriptor for I/O to remote machine.  Initialize it to NULL so that
294      remote_open knows that we don't have a file open when the program
295      starts.  */
296   struct serial *remote_desc = nullptr;
297
298   /* These are the threads which we last sent to the remote system.  The
299      TID member will be -1 for all or -2 for not sent yet.  */
300   ptid_t general_thread = null_ptid;
301   ptid_t continue_thread = null_ptid;
302
303   /* This is the traceframe which we last selected on the remote system.
304      It will be -1 if no traceframe is selected.  */
305   int remote_traceframe_number = -1;
306
307   char *last_pass_packet = nullptr;
308
309   /* The last QProgramSignals packet sent to the target.  We bypass
310      sending a new program signals list down to the target if the new
311      packet is exactly the same as the last we sent.  IOW, we only let
312      the target know about program signals list changes.  */
313   char *last_program_signals_packet = nullptr;
314
315   gdb_signal last_sent_signal = GDB_SIGNAL_0;
316
317   bool last_sent_step = false;
318
319   /* The execution direction of the last resume we got.  */
320   exec_direction_kind last_resume_exec_dir = EXEC_FORWARD;
321
322   char *finished_object = nullptr;
323   char *finished_annex = nullptr;
324   ULONGEST finished_offset = 0;
325
326   /* Should we try the 'ThreadInfo' query packet?
327
328      This variable (NOT available to the user: auto-detect only!)
329      determines whether GDB will use the new, simpler "ThreadInfo"
330      query or the older, more complex syntax for thread queries.
331      This is an auto-detect variable (set to true at each connect,
332      and set to false when the target fails to recognize it).  */
333   bool use_threadinfo_query = false;
334   bool use_threadextra_query = false;
335
336   threadref echo_nextthread {};
337   threadref nextthread {};
338   threadref resultthreadlist[MAXTHREADLISTRESULTS] {};
339
340   /* The state of remote notification.  */
341   struct remote_notif_state *notif_state = nullptr;
342
343   /* The branch trace configuration.  */
344   struct btrace_config btrace_config {};
345
346   /* The argument to the last "vFile:setfs:" packet we sent, used
347      to avoid sending repeated unnecessary "vFile:setfs:" packets.
348      Initialized to -1 to indicate that no "vFile:setfs:" packet
349      has yet been sent.  */
350   int fs_pid = -1;
351
352   /* A readahead cache for vFile:pread.  Often, reading a binary
353      involves a sequence of small reads.  E.g., when parsing an ELF
354      file.  A readahead cache helps mostly the case of remote
355      debugging on a connection with higher latency, due to the
356      request/reply nature of the RSP.  We only cache data for a single
357      file descriptor at a time.  */
358   struct readahead_cache readahead_cache;
359
360   /* The list of already fetched and acknowledged stop events.  This
361      queue is used for notification Stop, and other notifications
362      don't need queue for their events, because the notification
363      events of Stop can't be consumed immediately, so that events
364      should be queued first, and be consumed by remote_wait_{ns,as}
365      one per time.  Other notifications can consume their events
366      immediately, so queue is not needed for them.  */
367   std::vector<stop_reply_up> stop_reply_queue;
368
369   /* Asynchronous signal handle registered as event loop source for
370      when we have pending events ready to be passed to the core.  */
371   struct async_event_handler *remote_async_inferior_event_token = nullptr;
372
373   /* FIXME: cagney/1999-09-23: Even though getpkt was called with
374      ``forever'' still use the normal timeout mechanism.  This is
375      currently used by the ASYNC code to guarentee that target reads
376      during the initial connect always time-out.  Once getpkt has been
377      modified to return a timeout indication and, in turn
378      remote_wait()/wait_for_inferior() have gained a timeout parameter
379      this can go away.  */
380   int wait_forever_enabled_p = 1;
381
382 private:
383   /* Mapping of remote protocol data for each gdbarch.  Usually there
384      is only one entry here, though we may see more with stubs that
385      support multi-process.  */
386   std::unordered_map<struct gdbarch *, remote_arch_state>
387     m_arch_states;
388 };
389
390 static const target_info remote_target_info = {
391   "remote",
392   N_("Remote serial target in gdb-specific protocol"),
393   remote_doc
394 };
395
396 class remote_target : public process_stratum_target
397 {
398 public:
399   remote_target () = default;
400   ~remote_target () override;
401
402   const target_info &info () const override
403   { return remote_target_info; }
404
405   thread_control_capabilities get_thread_control_capabilities () override
406   { return tc_schedlock; }
407
408   /* Open a remote connection.  */
409   static void open (const char *, int);
410
411   void close () override;
412
413   void detach (inferior *, int) override;
414   void disconnect (const char *, int) override;
415
416   void commit_resume () override;
417   void resume (ptid_t, int, enum gdb_signal) override;
418   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
419
420   void fetch_registers (struct regcache *, int) override;
421   void store_registers (struct regcache *, int) override;
422   void prepare_to_store (struct regcache *) override;
423
424   void files_info () override;
425
426   int insert_breakpoint (struct gdbarch *, struct bp_target_info *) override;
427
428   int remove_breakpoint (struct gdbarch *, struct bp_target_info *,
429                          enum remove_bp_reason) override;
430
431
432   bool stopped_by_sw_breakpoint () override;
433   bool supports_stopped_by_sw_breakpoint () override;
434
435   bool stopped_by_hw_breakpoint () override;
436
437   bool supports_stopped_by_hw_breakpoint () override;
438
439   bool stopped_by_watchpoint () override;
440
441   bool stopped_data_address (CORE_ADDR *) override;
442
443   bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
444
445   int can_use_hw_breakpoint (enum bptype, int, int) override;
446
447   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
448
449   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
450
451   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
452
453   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
454                          struct expression *) override;
455
456   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
457                          struct expression *) override;
458
459   void kill () override;
460
461   void load (const char *, int) override;
462
463   void mourn_inferior () override;
464
465   void pass_signals (gdb::array_view<const unsigned char>) override;
466
467   int set_syscall_catchpoint (int, bool, int,
468                               gdb::array_view<const int>) override;
469
470   void program_signals (gdb::array_view<const unsigned char>) override;
471
472   bool thread_alive (ptid_t ptid) override;
473
474   const char *thread_name (struct thread_info *) override;
475
476   void update_thread_list () override;
477
478   std::string pid_to_str (ptid_t) override;
479
480   const char *extra_thread_info (struct thread_info *) override;
481
482   ptid_t get_ada_task_ptid (long lwp, long thread) override;
483
484   thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
485                                              int handle_len,
486                                              inferior *inf) override;
487
488   gdb::byte_vector thread_info_to_thread_handle (struct thread_info *tp)
489                                                  override;
490
491   void stop (ptid_t) override;
492
493   void interrupt () override;
494
495   void pass_ctrlc () override;
496
497   enum target_xfer_status xfer_partial (enum target_object object,
498                                         const char *annex,
499                                         gdb_byte *readbuf,
500                                         const gdb_byte *writebuf,
501                                         ULONGEST offset, ULONGEST len,
502                                         ULONGEST *xfered_len) override;
503
504   ULONGEST get_memory_xfer_limit () override;
505
506   void rcmd (const char *command, struct ui_file *output) override;
507
508   char *pid_to_exec_file (int pid) override;
509
510   void log_command (const char *cmd) override
511   {
512     serial_log_command (this, cmd);
513   }
514
515   CORE_ADDR get_thread_local_address (ptid_t ptid,
516                                       CORE_ADDR load_module_addr,
517                                       CORE_ADDR offset) override;
518
519   bool can_execute_reverse () override;
520
521   std::vector<mem_region> memory_map () override;
522
523   void flash_erase (ULONGEST address, LONGEST length) override;
524
525   void flash_done () override;
526
527   const struct target_desc *read_description () override;
528
529   int search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
530                      const gdb_byte *pattern, ULONGEST pattern_len,
531                      CORE_ADDR *found_addrp) override;
532
533   bool can_async_p () override;
534
535   bool is_async_p () override;
536
537   void async (int) override;
538
539   void thread_events (int) override;
540
541   int can_do_single_step () override;
542
543   void terminal_inferior () override;
544
545   void terminal_ours () override;
546
547   bool supports_non_stop () override;
548
549   bool supports_multi_process () override;
550
551   bool supports_disable_randomization () override;
552
553   bool filesystem_is_local () override;
554
555
556   int fileio_open (struct inferior *inf, const char *filename,
557                    int flags, int mode, int warn_if_slow,
558                    int *target_errno) override;
559
560   int fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
561                      ULONGEST offset, int *target_errno) override;
562
563   int fileio_pread (int fd, gdb_byte *read_buf, int len,
564                     ULONGEST offset, int *target_errno) override;
565
566   int fileio_fstat (int fd, struct stat *sb, int *target_errno) override;
567
568   int fileio_close (int fd, int *target_errno) override;
569
570   int fileio_unlink (struct inferior *inf,
571                      const char *filename,
572                      int *target_errno) override;
573
574   gdb::optional<std::string>
575     fileio_readlink (struct inferior *inf,
576                      const char *filename,
577                      int *target_errno) override;
578
579   bool supports_enable_disable_tracepoint () override;
580
581   bool supports_string_tracing () override;
582
583   bool supports_evaluation_of_breakpoint_conditions () override;
584
585   bool can_run_breakpoint_commands () override;
586
587   void trace_init () override;
588
589   void download_tracepoint (struct bp_location *location) override;
590
591   bool can_download_tracepoint () override;
592
593   void download_trace_state_variable (const trace_state_variable &tsv) override;
594
595   void enable_tracepoint (struct bp_location *location) override;
596
597   void disable_tracepoint (struct bp_location *location) override;
598
599   void trace_set_readonly_regions () override;
600
601   void trace_start () override;
602
603   int get_trace_status (struct trace_status *ts) override;
604
605   void get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
606     override;
607
608   void trace_stop () override;
609
610   int trace_find (enum trace_find_type type, int num,
611                   CORE_ADDR addr1, CORE_ADDR addr2, int *tpp) override;
612
613   bool get_trace_state_variable_value (int tsv, LONGEST *val) override;
614
615   int save_trace_data (const char *filename) override;
616
617   int upload_tracepoints (struct uploaded_tp **utpp) override;
618
619   int upload_trace_state_variables (struct uploaded_tsv **utsvp) override;
620
621   LONGEST get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len) override;
622
623   int get_min_fast_tracepoint_insn_len () override;
624
625   void set_disconnected_tracing (int val) override;
626
627   void set_circular_trace_buffer (int val) override;
628
629   void set_trace_buffer_size (LONGEST val) override;
630
631   bool set_trace_notes (const char *user, const char *notes,
632                         const char *stopnotes) override;
633
634   int core_of_thread (ptid_t ptid) override;
635
636   int verify_memory (const gdb_byte *data,
637                      CORE_ADDR memaddr, ULONGEST size) override;
638
639
640   bool get_tib_address (ptid_t ptid, CORE_ADDR *addr) override;
641
642   void set_permissions () override;
643
644   bool static_tracepoint_marker_at (CORE_ADDR,
645                                     struct static_tracepoint_marker *marker)
646     override;
647
648   std::vector<static_tracepoint_marker>
649     static_tracepoint_markers_by_strid (const char *id) override;
650
651   traceframe_info_up traceframe_info () override;
652
653   bool use_agent (bool use) override;
654   bool can_use_agent () override;
655
656   struct btrace_target_info *enable_btrace (ptid_t ptid,
657                                             const struct btrace_config *conf) override;
658
659   void disable_btrace (struct btrace_target_info *tinfo) override;
660
661   void teardown_btrace (struct btrace_target_info *tinfo) override;
662
663   enum btrace_error read_btrace (struct btrace_data *data,
664                                  struct btrace_target_info *btinfo,
665                                  enum btrace_read_type type) override;
666
667   const struct btrace_config *btrace_conf (const struct btrace_target_info *) override;
668   bool augmented_libraries_svr4_read () override;
669   int follow_fork (int, int) override;
670   void follow_exec (struct inferior *, const char *) override;
671   int insert_fork_catchpoint (int) override;
672   int remove_fork_catchpoint (int) override;
673   int insert_vfork_catchpoint (int) override;
674   int remove_vfork_catchpoint (int) override;
675   int insert_exec_catchpoint (int) override;
676   int remove_exec_catchpoint (int) override;
677   enum exec_direction_kind execution_direction () override;
678
679 public: /* Remote specific methods.  */
680
681   void remote_download_command_source (int num, ULONGEST addr,
682                                        struct command_line *cmds);
683
684   void remote_file_put (const char *local_file, const char *remote_file,
685                         int from_tty);
686   void remote_file_get (const char *remote_file, const char *local_file,
687                         int from_tty);
688   void remote_file_delete (const char *remote_file, int from_tty);
689
690   int remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
691                            ULONGEST offset, int *remote_errno);
692   int remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
693                             ULONGEST offset, int *remote_errno);
694   int remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
695                                  ULONGEST offset, int *remote_errno);
696
697   int remote_hostio_send_command (int command_bytes, int which_packet,
698                                   int *remote_errno, char **attachment,
699                                   int *attachment_len);
700   int remote_hostio_set_filesystem (struct inferior *inf,
701                                     int *remote_errno);
702   /* We should get rid of this and use fileio_open directly.  */
703   int remote_hostio_open (struct inferior *inf, const char *filename,
704                           int flags, int mode, int warn_if_slow,
705                           int *remote_errno);
706   int remote_hostio_close (int fd, int *remote_errno);
707
708   int remote_hostio_unlink (inferior *inf, const char *filename,
709                             int *remote_errno);
710
711   struct remote_state *get_remote_state ();
712
713   long get_remote_packet_size (void);
714   long get_memory_packet_size (struct memory_packet_config *config);
715
716   long get_memory_write_packet_size ();
717   long get_memory_read_packet_size ();
718
719   char *append_pending_thread_resumptions (char *p, char *endp,
720                                            ptid_t ptid);
721   static void open_1 (const char *name, int from_tty, int extended_p);
722   void start_remote (int from_tty, int extended_p);
723   void remote_detach_1 (struct inferior *inf, int from_tty);
724
725   char *append_resumption (char *p, char *endp,
726                            ptid_t ptid, int step, gdb_signal siggnal);
727   int remote_resume_with_vcont (ptid_t ptid, int step,
728                                 gdb_signal siggnal);
729
730   void add_current_inferior_and_thread (char *wait_status);
731
732   ptid_t wait_ns (ptid_t ptid, struct target_waitstatus *status,
733                   int options);
734   ptid_t wait_as (ptid_t ptid, target_waitstatus *status,
735                   int options);
736
737   ptid_t process_stop_reply (struct stop_reply *stop_reply,
738                              target_waitstatus *status);
739
740   void remote_notice_new_inferior (ptid_t currthread, int executing);
741
742   void process_initial_stop_replies (int from_tty);
743
744   thread_info *remote_add_thread (ptid_t ptid, bool running, bool executing);
745
746   void btrace_sync_conf (const btrace_config *conf);
747
748   void remote_btrace_maybe_reopen ();
749
750   void remove_new_fork_children (threads_listing_context *context);
751   void kill_new_fork_children (int pid);
752   void discard_pending_stop_replies (struct inferior *inf);
753   int stop_reply_queue_length ();
754
755   void check_pending_events_prevent_wildcard_vcont
756     (int *may_global_wildcard_vcont);
757
758   void discard_pending_stop_replies_in_queue ();
759   struct stop_reply *remote_notif_remove_queued_reply (ptid_t ptid);
760   struct stop_reply *queued_stop_reply (ptid_t ptid);
761   int peek_stop_reply (ptid_t ptid);
762   void remote_parse_stop_reply (const char *buf, stop_reply *event);
763
764   void remote_stop_ns (ptid_t ptid);
765   void remote_interrupt_as ();
766   void remote_interrupt_ns ();
767
768   char *remote_get_noisy_reply ();
769   int remote_query_attached (int pid);
770   inferior *remote_add_inferior (bool fake_pid_p, int pid, int attached,
771                                  int try_open_exec);
772
773   ptid_t remote_current_thread (ptid_t oldpid);
774   ptid_t get_current_thread (char *wait_status);
775
776   void set_thread (ptid_t ptid, int gen);
777   void set_general_thread (ptid_t ptid);
778   void set_continue_thread (ptid_t ptid);
779   void set_general_process ();
780
781   char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
782
783   int remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
784                                           gdb_ext_thread_info *info);
785   int remote_get_threadinfo (threadref *threadid, int fieldset,
786                              gdb_ext_thread_info *info);
787
788   int parse_threadlist_response (char *pkt, int result_limit,
789                                  threadref *original_echo,
790                                  threadref *resultlist,
791                                  int *doneflag);
792   int remote_get_threadlist (int startflag, threadref *nextthread,
793                              int result_limit, int *done, int *result_count,
794                              threadref *threadlist);
795
796   int remote_threadlist_iterator (rmt_thread_action stepfunction,
797                                   void *context, int looplimit);
798
799   int remote_get_threads_with_ql (threads_listing_context *context);
800   int remote_get_threads_with_qxfer (threads_listing_context *context);
801   int remote_get_threads_with_qthreadinfo (threads_listing_context *context);
802
803   void extended_remote_restart ();
804
805   void get_offsets ();
806
807   void remote_check_symbols ();
808
809   void remote_supported_packet (const struct protocol_feature *feature,
810                                 enum packet_support support,
811                                 const char *argument);
812
813   void remote_query_supported ();
814
815   void remote_packet_size (const protocol_feature *feature,
816                            packet_support support, const char *value);
817
818   void remote_serial_quit_handler ();
819
820   void remote_detach_pid (int pid);
821
822   void remote_vcont_probe ();
823
824   void remote_resume_with_hc (ptid_t ptid, int step,
825                               gdb_signal siggnal);
826
827   void send_interrupt_sequence ();
828   void interrupt_query ();
829
830   void remote_notif_get_pending_events (notif_client *nc);
831
832   int fetch_register_using_p (struct regcache *regcache,
833                               packet_reg *reg);
834   int send_g_packet ();
835   void process_g_packet (struct regcache *regcache);
836   void fetch_registers_using_g (struct regcache *regcache);
837   int store_register_using_P (const struct regcache *regcache,
838                               packet_reg *reg);
839   void store_registers_using_G (const struct regcache *regcache);
840
841   void set_remote_traceframe ();
842
843   void check_binary_download (CORE_ADDR addr);
844
845   target_xfer_status remote_write_bytes_aux (const char *header,
846                                              CORE_ADDR memaddr,
847                                              const gdb_byte *myaddr,
848                                              ULONGEST len_units,
849                                              int unit_size,
850                                              ULONGEST *xfered_len_units,
851                                              char packet_format,
852                                              int use_length);
853
854   target_xfer_status remote_write_bytes (CORE_ADDR memaddr,
855                                          const gdb_byte *myaddr, ULONGEST len,
856                                          int unit_size, ULONGEST *xfered_len);
857
858   target_xfer_status remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
859                                           ULONGEST len_units,
860                                           int unit_size, ULONGEST *xfered_len_units);
861
862   target_xfer_status remote_xfer_live_readonly_partial (gdb_byte *readbuf,
863                                                         ULONGEST memaddr,
864                                                         ULONGEST len,
865                                                         int unit_size,
866                                                         ULONGEST *xfered_len);
867
868   target_xfer_status remote_read_bytes (CORE_ADDR memaddr,
869                                         gdb_byte *myaddr, ULONGEST len,
870                                         int unit_size,
871                                         ULONGEST *xfered_len);
872
873   packet_result remote_send_printf (const char *format, ...)
874     ATTRIBUTE_PRINTF (2, 3);
875
876   target_xfer_status remote_flash_write (ULONGEST address,
877                                          ULONGEST length, ULONGEST *xfered_len,
878                                          const gdb_byte *data);
879
880   int readchar (int timeout);
881
882   void remote_serial_write (const char *str, int len);
883
884   int putpkt (const char *buf);
885   int putpkt_binary (const char *buf, int cnt);
886
887   int putpkt (const gdb::char_vector &buf)
888   {
889     return putpkt (buf.data ());
890   }
891
892   void skip_frame ();
893   long read_frame (gdb::char_vector *buf_p);
894   void getpkt (gdb::char_vector *buf, int forever);
895   int getpkt_or_notif_sane_1 (gdb::char_vector *buf, int forever,
896                               int expecting_notif, int *is_notif);
897   int getpkt_sane (gdb::char_vector *buf, int forever);
898   int getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
899                             int *is_notif);
900   int remote_vkill (int pid);
901   void remote_kill_k ();
902
903   void extended_remote_disable_randomization (int val);
904   int extended_remote_run (const std::string &args);
905
906   void send_environment_packet (const char *action,
907                                 const char *packet,
908                                 const char *value);
909
910   void extended_remote_environment_support ();
911   void extended_remote_set_inferior_cwd ();
912
913   target_xfer_status remote_write_qxfer (const char *object_name,
914                                          const char *annex,
915                                          const gdb_byte *writebuf,
916                                          ULONGEST offset, LONGEST len,
917                                          ULONGEST *xfered_len,
918                                          struct packet_config *packet);
919
920   target_xfer_status remote_read_qxfer (const char *object_name,
921                                         const char *annex,
922                                         gdb_byte *readbuf, ULONGEST offset,
923                                         LONGEST len,
924                                         ULONGEST *xfered_len,
925                                         struct packet_config *packet);
926
927   void push_stop_reply (struct stop_reply *new_event);
928
929   bool vcont_r_supported ();
930
931   void packet_command (const char *args, int from_tty);
932
933 private: /* data fields */
934
935   /* The remote state.  Don't reference this directly.  Use the
936      get_remote_state method instead.  */
937   remote_state m_remote_state;
938 };
939
940 static const target_info extended_remote_target_info = {
941   "extended-remote",
942   N_("Extended remote serial target in gdb-specific protocol"),
943   remote_doc
944 };
945
946 /* Set up the extended remote target by extending the standard remote
947    target and adding to it.  */
948
949 class extended_remote_target final : public remote_target
950 {
951 public:
952   const target_info &info () const override
953   { return extended_remote_target_info; }
954
955   /* Open an extended-remote connection.  */
956   static void open (const char *, int);
957
958   bool can_create_inferior () override { return true; }
959   void create_inferior (const char *, const std::string &,
960                         char **, int) override;
961
962   void detach (inferior *, int) override;
963
964   bool can_attach () override { return true; }
965   void attach (const char *, int) override;
966
967   void post_attach (int) override;
968   bool supports_disable_randomization () override;
969 };
970
971 /* Per-program-space data key.  */
972 static const struct program_space_key<char, gdb::xfree_deleter<char>>
973   remote_pspace_data;
974
975 /* The variable registered as the control variable used by the
976    remote exec-file commands.  While the remote exec-file setting is
977    per-program-space, the set/show machinery uses this as the 
978    location of the remote exec-file value.  */
979 static char *remote_exec_file_var;
980
981 /* The size to align memory write packets, when practical.  The protocol
982    does not guarantee any alignment, and gdb will generate short
983    writes and unaligned writes, but even as a best-effort attempt this
984    can improve bulk transfers.  For instance, if a write is misaligned
985    relative to the target's data bus, the stub may need to make an extra
986    round trip fetching data from the target.  This doesn't make a
987    huge difference, but it's easy to do, so we try to be helpful.
988
989    The alignment chosen is arbitrary; usually data bus width is
990    important here, not the possibly larger cache line size.  */
991 enum { REMOTE_ALIGN_WRITES = 16 };
992
993 /* Prototypes for local functions.  */
994
995 static int hexnumlen (ULONGEST num);
996
997 static int stubhex (int ch);
998
999 static int hexnumstr (char *, ULONGEST);
1000
1001 static int hexnumnstr (char *, ULONGEST, int);
1002
1003 static CORE_ADDR remote_address_masked (CORE_ADDR);
1004
1005 static void print_packet (const char *);
1006
1007 static int stub_unpack_int (char *buff, int fieldlength);
1008
1009 struct packet_config;
1010
1011 static void show_packet_config_cmd (struct packet_config *config);
1012
1013 static void show_remote_protocol_packet_cmd (struct ui_file *file,
1014                                              int from_tty,
1015                                              struct cmd_list_element *c,
1016                                              const char *value);
1017
1018 static ptid_t read_ptid (const char *buf, const char **obuf);
1019
1020 static void remote_async_inferior_event_handler (gdb_client_data);
1021
1022 static bool remote_read_description_p (struct target_ops *target);
1023
1024 static void remote_console_output (const char *msg);
1025
1026 static void remote_btrace_reset (remote_state *rs);
1027
1028 static void remote_unpush_and_throw (void);
1029
1030 /* For "remote".  */
1031
1032 static struct cmd_list_element *remote_cmdlist;
1033
1034 /* For "set remote" and "show remote".  */
1035
1036 static struct cmd_list_element *remote_set_cmdlist;
1037 static struct cmd_list_element *remote_show_cmdlist;
1038
1039 /* Controls whether GDB is willing to use range stepping.  */
1040
1041 static int use_range_stepping = 1;
1042
1043 /* The max number of chars in debug output.  The rest of chars are
1044    omitted.  */
1045
1046 #define REMOTE_DEBUG_MAX_CHAR 512
1047
1048 /* Private data that we'll store in (struct thread_info)->priv.  */
1049 struct remote_thread_info : public private_thread_info
1050 {
1051   std::string extra;
1052   std::string name;
1053   int core = -1;
1054
1055   /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
1056      sequence of bytes.  */
1057   gdb::byte_vector thread_handle;
1058
1059   /* Whether the target stopped for a breakpoint/watchpoint.  */
1060   enum target_stop_reason stop_reason = TARGET_STOPPED_BY_NO_REASON;
1061
1062   /* This is set to the data address of the access causing the target
1063      to stop for a watchpoint.  */
1064   CORE_ADDR watch_data_address = 0;
1065
1066   /* Fields used by the vCont action coalescing implemented in
1067      remote_resume / remote_commit_resume.  remote_resume stores each
1068      thread's last resume request in these fields, so that a later
1069      remote_commit_resume knows which is the proper action for this
1070      thread to include in the vCont packet.  */
1071
1072   /* True if the last target_resume call for this thread was a step
1073      request, false if a continue request.  */
1074   int last_resume_step = 0;
1075
1076   /* The signal specified in the last target_resume call for this
1077      thread.  */
1078   gdb_signal last_resume_sig = GDB_SIGNAL_0;
1079
1080   /* Whether this thread was already vCont-resumed on the remote
1081      side.  */
1082   int vcont_resumed = 0;
1083 };
1084
1085 remote_state::remote_state ()
1086   : buf (400)
1087 {
1088 }
1089
1090 remote_state::~remote_state ()
1091 {
1092   xfree (this->last_pass_packet);
1093   xfree (this->last_program_signals_packet);
1094   xfree (this->finished_object);
1095   xfree (this->finished_annex);
1096 }
1097
1098 /* Utility: generate error from an incoming stub packet.  */
1099 static void
1100 trace_error (char *buf)
1101 {
1102   if (*buf++ != 'E')
1103     return;                     /* not an error msg */
1104   switch (*buf)
1105     {
1106     case '1':                   /* malformed packet error */
1107       if (*++buf == '0')        /*   general case: */
1108         error (_("remote.c: error in outgoing packet."));
1109       else
1110         error (_("remote.c: error in outgoing packet at field #%ld."),
1111                strtol (buf, NULL, 16));
1112     default:
1113       error (_("Target returns error code '%s'."), buf);
1114     }
1115 }
1116
1117 /* Utility: wait for reply from stub, while accepting "O" packets.  */
1118
1119 char *
1120 remote_target::remote_get_noisy_reply ()
1121 {
1122   struct remote_state *rs = get_remote_state ();
1123
1124   do                            /* Loop on reply from remote stub.  */
1125     {
1126       char *buf;
1127
1128       QUIT;                     /* Allow user to bail out with ^C.  */
1129       getpkt (&rs->buf, 0);
1130       buf = rs->buf.data ();
1131       if (buf[0] == 'E')
1132         trace_error (buf);
1133       else if (startswith (buf, "qRelocInsn:"))
1134         {
1135           ULONGEST ul;
1136           CORE_ADDR from, to, org_to;
1137           const char *p, *pp;
1138           int adjusted_size = 0;
1139           int relocated = 0;
1140
1141           p = buf + strlen ("qRelocInsn:");
1142           pp = unpack_varlen_hex (p, &ul);
1143           if (*pp != ';')
1144             error (_("invalid qRelocInsn packet: %s"), buf);
1145           from = ul;
1146
1147           p = pp + 1;
1148           unpack_varlen_hex (p, &ul);
1149           to = ul;
1150
1151           org_to = to;
1152
1153           try
1154             {
1155               gdbarch_relocate_instruction (target_gdbarch (), &to, from);
1156               relocated = 1;
1157             }
1158           catch (const gdb_exception &ex)
1159             {
1160               if (ex.error == MEMORY_ERROR)
1161                 {
1162                   /* Propagate memory errors silently back to the
1163                      target.  The stub may have limited the range of
1164                      addresses we can write to, for example.  */
1165                 }
1166               else
1167                 {
1168                   /* Something unexpectedly bad happened.  Be verbose
1169                      so we can tell what, and propagate the error back
1170                      to the stub, so it doesn't get stuck waiting for
1171                      a response.  */
1172                   exception_fprintf (gdb_stderr, ex,
1173                                      _("warning: relocating instruction: "));
1174                 }
1175               putpkt ("E01");
1176             }
1177
1178           if (relocated)
1179             {
1180               adjusted_size = to - org_to;
1181
1182               xsnprintf (buf, rs->buf.size (), "qRelocInsn:%x", adjusted_size);
1183               putpkt (buf);
1184             }
1185         }
1186       else if (buf[0] == 'O' && buf[1] != 'K')
1187         remote_console_output (buf + 1);        /* 'O' message from stub */
1188       else
1189         return buf;             /* Here's the actual reply.  */
1190     }
1191   while (1);
1192 }
1193
1194 struct remote_arch_state *
1195 remote_state::get_remote_arch_state (struct gdbarch *gdbarch)
1196 {
1197   remote_arch_state *rsa;
1198
1199   auto it = this->m_arch_states.find (gdbarch);
1200   if (it == this->m_arch_states.end ())
1201     {
1202       auto p = this->m_arch_states.emplace (std::piecewise_construct,
1203                                             std::forward_as_tuple (gdbarch),
1204                                             std::forward_as_tuple (gdbarch));
1205       rsa = &p.first->second;
1206
1207       /* Make sure that the packet buffer is plenty big enough for
1208          this architecture.  */
1209       if (this->buf.size () < rsa->remote_packet_size)
1210         this->buf.resize (2 * rsa->remote_packet_size);
1211     }
1212   else
1213     rsa = &it->second;
1214
1215   return rsa;
1216 }
1217
1218 /* Fetch the global remote target state.  */
1219
1220 remote_state *
1221 remote_target::get_remote_state ()
1222 {
1223   /* Make sure that the remote architecture state has been
1224      initialized, because doing so might reallocate rs->buf.  Any
1225      function which calls getpkt also needs to be mindful of changes
1226      to rs->buf, but this call limits the number of places which run
1227      into trouble.  */
1228   m_remote_state.get_remote_arch_state (target_gdbarch ());
1229
1230   return &m_remote_state;
1231 }
1232
1233 /* Fetch the remote exec-file from the current program space.  */
1234
1235 static const char *
1236 get_remote_exec_file (void)
1237 {
1238   char *remote_exec_file;
1239
1240   remote_exec_file = remote_pspace_data.get (current_program_space);
1241   if (remote_exec_file == NULL)
1242     return "";
1243
1244   return remote_exec_file;
1245 }
1246
1247 /* Set the remote exec file for PSPACE.  */
1248
1249 static void
1250 set_pspace_remote_exec_file (struct program_space *pspace,
1251                              const char *remote_exec_file)
1252 {
1253   char *old_file = remote_pspace_data.get (pspace);
1254
1255   xfree (old_file);
1256   remote_pspace_data.set (pspace, xstrdup (remote_exec_file));
1257 }
1258
1259 /* The "set/show remote exec-file" set command hook.  */
1260
1261 static void
1262 set_remote_exec_file (const char *ignored, int from_tty,
1263                       struct cmd_list_element *c)
1264 {
1265   gdb_assert (remote_exec_file_var != NULL);
1266   set_pspace_remote_exec_file (current_program_space, remote_exec_file_var);
1267 }
1268
1269 /* The "set/show remote exec-file" show command hook.  */
1270
1271 static void
1272 show_remote_exec_file (struct ui_file *file, int from_tty,
1273                        struct cmd_list_element *cmd, const char *value)
1274 {
1275   fprintf_filtered (file, "%s\n", remote_exec_file_var);
1276 }
1277
1278 static int
1279 compare_pnums (const void *lhs_, const void *rhs_)
1280 {
1281   const struct packet_reg * const *lhs
1282     = (const struct packet_reg * const *) lhs_;
1283   const struct packet_reg * const *rhs
1284     = (const struct packet_reg * const *) rhs_;
1285
1286   if ((*lhs)->pnum < (*rhs)->pnum)
1287     return -1;
1288   else if ((*lhs)->pnum == (*rhs)->pnum)
1289     return 0;
1290   else
1291     return 1;
1292 }
1293
1294 static int
1295 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
1296 {
1297   int regnum, num_remote_regs, offset;
1298   struct packet_reg **remote_regs;
1299
1300   for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
1301     {
1302       struct packet_reg *r = &regs[regnum];
1303
1304       if (register_size (gdbarch, regnum) == 0)
1305         /* Do not try to fetch zero-sized (placeholder) registers.  */
1306         r->pnum = -1;
1307       else
1308         r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
1309
1310       r->regnum = regnum;
1311     }
1312
1313   /* Define the g/G packet format as the contents of each register
1314      with a remote protocol number, in order of ascending protocol
1315      number.  */
1316
1317   remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch));
1318   for (num_remote_regs = 0, regnum = 0;
1319        regnum < gdbarch_num_regs (gdbarch);
1320        regnum++)
1321     if (regs[regnum].pnum != -1)
1322       remote_regs[num_remote_regs++] = &regs[regnum];
1323
1324   qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
1325          compare_pnums);
1326
1327   for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
1328     {
1329       remote_regs[regnum]->in_g_packet = 1;
1330       remote_regs[regnum]->offset = offset;
1331       offset += register_size (gdbarch, remote_regs[regnum]->regnum);
1332     }
1333
1334   return offset;
1335 }
1336
1337 /* Given the architecture described by GDBARCH, return the remote
1338    protocol register's number and the register's offset in the g/G
1339    packets of GDB register REGNUM, in PNUM and POFFSET respectively.
1340    If the target does not have a mapping for REGNUM, return false,
1341    otherwise, return true.  */
1342
1343 int
1344 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
1345                                    int *pnum, int *poffset)
1346 {
1347   gdb_assert (regnum < gdbarch_num_regs (gdbarch));
1348
1349   std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch));
1350
1351   map_regcache_remote_table (gdbarch, regs.data ());
1352
1353   *pnum = regs[regnum].pnum;
1354   *poffset = regs[regnum].offset;
1355
1356   return *pnum != -1;
1357 }
1358
1359 remote_arch_state::remote_arch_state (struct gdbarch *gdbarch)
1360 {
1361   /* Use the architecture to build a regnum<->pnum table, which will be
1362      1:1 unless a feature set specifies otherwise.  */
1363   this->regs.reset (new packet_reg [gdbarch_num_regs (gdbarch)] ());
1364
1365   /* Record the maximum possible size of the g packet - it may turn out
1366      to be smaller.  */
1367   this->sizeof_g_packet
1368     = map_regcache_remote_table (gdbarch, this->regs.get ());
1369
1370   /* Default maximum number of characters in a packet body.  Many
1371      remote stubs have a hardwired buffer size of 400 bytes
1372      (c.f. BUFMAX in m68k-stub.c and i386-stub.c).  BUFMAX-1 is used
1373      as the maximum packet-size to ensure that the packet and an extra
1374      NUL character can always fit in the buffer.  This stops GDB
1375      trashing stubs that try to squeeze an extra NUL into what is
1376      already a full buffer (As of 1999-12-04 that was most stubs).  */
1377   this->remote_packet_size = 400 - 1;
1378
1379   /* This one is filled in when a ``g'' packet is received.  */
1380   this->actual_register_packet_size = 0;
1381
1382   /* Should rsa->sizeof_g_packet needs more space than the
1383      default, adjust the size accordingly.  Remember that each byte is
1384      encoded as two characters.  32 is the overhead for the packet
1385      header / footer.  NOTE: cagney/1999-10-26: I suspect that 8
1386      (``$NN:G...#NN'') is a better guess, the below has been padded a
1387      little.  */
1388   if (this->sizeof_g_packet > ((this->remote_packet_size - 32) / 2))
1389     this->remote_packet_size = (this->sizeof_g_packet * 2 + 32);
1390 }
1391
1392 /* Get a pointer to the current remote target.  If not connected to a
1393    remote target, return NULL.  */
1394
1395 static remote_target *
1396 get_current_remote_target ()
1397 {
1398   target_ops *proc_target = find_target_at (process_stratum);
1399   return dynamic_cast<remote_target *> (proc_target);
1400 }
1401
1402 /* Return the current allowed size of a remote packet.  This is
1403    inferred from the current architecture, and should be used to
1404    limit the length of outgoing packets.  */
1405 long
1406 remote_target::get_remote_packet_size ()
1407 {
1408   struct remote_state *rs = get_remote_state ();
1409   remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1410
1411   if (rs->explicit_packet_size)
1412     return rs->explicit_packet_size;
1413
1414   return rsa->remote_packet_size;
1415 }
1416
1417 static struct packet_reg *
1418 packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1419                         long regnum)
1420 {
1421   if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch))
1422     return NULL;
1423   else
1424     {
1425       struct packet_reg *r = &rsa->regs[regnum];
1426
1427       gdb_assert (r->regnum == regnum);
1428       return r;
1429     }
1430 }
1431
1432 static struct packet_reg *
1433 packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
1434                       LONGEST pnum)
1435 {
1436   int i;
1437
1438   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
1439     {
1440       struct packet_reg *r = &rsa->regs[i];
1441
1442       if (r->pnum == pnum)
1443         return r;
1444     }
1445   return NULL;
1446 }
1447
1448 /* Allow the user to specify what sequence to send to the remote
1449    when he requests a program interruption: Although ^C is usually
1450    what remote systems expect (this is the default, here), it is
1451    sometimes preferable to send a break.  On other systems such
1452    as the Linux kernel, a break followed by g, which is Magic SysRq g
1453    is required in order to interrupt the execution.  */
1454 const char interrupt_sequence_control_c[] = "Ctrl-C";
1455 const char interrupt_sequence_break[] = "BREAK";
1456 const char interrupt_sequence_break_g[] = "BREAK-g";
1457 static const char *const interrupt_sequence_modes[] =
1458   {
1459     interrupt_sequence_control_c,
1460     interrupt_sequence_break,
1461     interrupt_sequence_break_g,
1462     NULL
1463   };
1464 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
1465
1466 static void
1467 show_interrupt_sequence (struct ui_file *file, int from_tty,
1468                          struct cmd_list_element *c,
1469                          const char *value)
1470 {
1471   if (interrupt_sequence_mode == interrupt_sequence_control_c)
1472     fprintf_filtered (file,
1473                       _("Send the ASCII ETX character (Ctrl-c) "
1474                         "to the remote target to interrupt the "
1475                         "execution of the program.\n"));
1476   else if (interrupt_sequence_mode == interrupt_sequence_break)
1477     fprintf_filtered (file,
1478                       _("send a break signal to the remote target "
1479                         "to interrupt the execution of the program.\n"));
1480   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
1481     fprintf_filtered (file,
1482                       _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
1483                         "the remote target to interrupt the execution "
1484                         "of Linux kernel.\n"));
1485   else
1486     internal_error (__FILE__, __LINE__,
1487                     _("Invalid value for interrupt_sequence_mode: %s."),
1488                     interrupt_sequence_mode);
1489 }
1490
1491 /* This boolean variable specifies whether interrupt_sequence is sent
1492    to the remote target when gdb connects to it.
1493    This is mostly needed when you debug the Linux kernel: The Linux kernel
1494    expects BREAK g which is Magic SysRq g for connecting gdb.  */
1495 static int interrupt_on_connect = 0;
1496
1497 /* This variable is used to implement the "set/show remotebreak" commands.
1498    Since these commands are now deprecated in favor of "set/show remote
1499    interrupt-sequence", it no longer has any effect on the code.  */
1500 static int remote_break;
1501
1502 static void
1503 set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
1504 {
1505   if (remote_break)
1506     interrupt_sequence_mode = interrupt_sequence_break;
1507   else
1508     interrupt_sequence_mode = interrupt_sequence_control_c;
1509 }
1510
1511 static void
1512 show_remotebreak (struct ui_file *file, int from_tty,
1513                   struct cmd_list_element *c,
1514                   const char *value)
1515 {
1516 }
1517
1518 /* This variable sets the number of bits in an address that are to be
1519    sent in a memory ("M" or "m") packet.  Normally, after stripping
1520    leading zeros, the entire address would be sent.  This variable
1521    restricts the address to REMOTE_ADDRESS_SIZE bits.  HISTORY: The
1522    initial implementation of remote.c restricted the address sent in
1523    memory packets to ``host::sizeof long'' bytes - (typically 32
1524    bits).  Consequently, for 64 bit targets, the upper 32 bits of an
1525    address was never sent.  Since fixing this bug may cause a break in
1526    some remote targets this variable is principly provided to
1527    facilitate backward compatibility.  */
1528
1529 static unsigned int remote_address_size;
1530
1531 \f
1532 /* User configurable variables for the number of characters in a
1533    memory read/write packet.  MIN (rsa->remote_packet_size,
1534    rsa->sizeof_g_packet) is the default.  Some targets need smaller
1535    values (fifo overruns, et.al.) and some users need larger values
1536    (speed up transfers).  The variables ``preferred_*'' (the user
1537    request), ``current_*'' (what was actually set) and ``forced_*''
1538    (Positive - a soft limit, negative - a hard limit).  */
1539
1540 struct memory_packet_config
1541 {
1542   const char *name;
1543   long size;
1544   int fixed_p;
1545 };
1546
1547 /* The default max memory-write-packet-size, when the setting is
1548    "fixed".  The 16k is historical.  (It came from older GDB's using
1549    alloca for buffers and the knowledge (folklore?) that some hosts
1550    don't cope very well with large alloca calls.)  */
1551 #define DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED 16384
1552
1553 /* The minimum remote packet size for memory transfers.  Ensures we
1554    can write at least one byte.  */
1555 #define MIN_MEMORY_PACKET_SIZE 20
1556
1557 /* Get the memory packet size, assuming it is fixed.  */
1558
1559 static long
1560 get_fixed_memory_packet_size (struct memory_packet_config *config)
1561 {
1562   gdb_assert (config->fixed_p);
1563
1564   if (config->size <= 0)
1565     return DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED;
1566   else
1567     return config->size;
1568 }
1569
1570 /* Compute the current size of a read/write packet.  Since this makes
1571    use of ``actual_register_packet_size'' the computation is dynamic.  */
1572
1573 long
1574 remote_target::get_memory_packet_size (struct memory_packet_config *config)
1575 {
1576   struct remote_state *rs = get_remote_state ();
1577   remote_arch_state *rsa = rs->get_remote_arch_state (target_gdbarch ());
1578
1579   long what_they_get;
1580   if (config->fixed_p)
1581     what_they_get = get_fixed_memory_packet_size (config);
1582   else
1583     {
1584       what_they_get = get_remote_packet_size ();
1585       /* Limit the packet to the size specified by the user.  */
1586       if (config->size > 0
1587           && what_they_get > config->size)
1588         what_they_get = config->size;
1589
1590       /* Limit it to the size of the targets ``g'' response unless we have
1591          permission from the stub to use a larger packet size.  */
1592       if (rs->explicit_packet_size == 0
1593           && rsa->actual_register_packet_size > 0
1594           && what_they_get > rsa->actual_register_packet_size)
1595         what_they_get = rsa->actual_register_packet_size;
1596     }
1597   if (what_they_get < MIN_MEMORY_PACKET_SIZE)
1598     what_they_get = MIN_MEMORY_PACKET_SIZE;
1599
1600   /* Make sure there is room in the global buffer for this packet
1601      (including its trailing NUL byte).  */
1602   if (rs->buf.size () < what_they_get + 1)
1603     rs->buf.resize (2 * what_they_get);
1604
1605   return what_they_get;
1606 }
1607
1608 /* Update the size of a read/write packet.  If they user wants
1609    something really big then do a sanity check.  */
1610
1611 static void
1612 set_memory_packet_size (const char *args, struct memory_packet_config *config)
1613 {
1614   int fixed_p = config->fixed_p;
1615   long size = config->size;
1616
1617   if (args == NULL)
1618     error (_("Argument required (integer, `fixed' or `limited')."));
1619   else if (strcmp (args, "hard") == 0
1620       || strcmp (args, "fixed") == 0)
1621     fixed_p = 1;
1622   else if (strcmp (args, "soft") == 0
1623            || strcmp (args, "limit") == 0)
1624     fixed_p = 0;
1625   else
1626     {
1627       char *end;
1628
1629       size = strtoul (args, &end, 0);
1630       if (args == end)
1631         error (_("Invalid %s (bad syntax)."), config->name);
1632
1633       /* Instead of explicitly capping the size of a packet to or
1634          disallowing it, the user is allowed to set the size to
1635          something arbitrarily large.  */
1636     }
1637
1638   /* Extra checks?  */
1639   if (fixed_p && !config->fixed_p)
1640     {
1641       /* So that the query shows the correct value.  */
1642       long query_size = (size <= 0
1643                          ? DEFAULT_MAX_MEMORY_PACKET_SIZE_FIXED
1644                          : size);
1645
1646       if (! query (_("The target may not be able to correctly handle a %s\n"
1647                    "of %ld bytes. Change the packet size? "),
1648                    config->name, query_size))
1649         error (_("Packet size not changed."));
1650     }
1651   /* Update the config.  */
1652   config->fixed_p = fixed_p;
1653   config->size = size;
1654 }
1655
1656 static void
1657 show_memory_packet_size (struct memory_packet_config *config)
1658 {
1659   if (config->size == 0)
1660     printf_filtered (_("The %s is 0 (default). "), config->name);
1661   else
1662     printf_filtered (_("The %s is %ld. "), config->name, config->size);
1663   if (config->fixed_p)
1664     printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1665                      get_fixed_memory_packet_size (config));
1666   else
1667     {
1668       remote_target *remote = get_current_remote_target ();
1669
1670       if (remote != NULL)
1671         printf_filtered (_("Packets are limited to %ld bytes.\n"),
1672                          remote->get_memory_packet_size (config));
1673       else
1674         puts_filtered ("The actual limit will be further reduced "
1675                        "dependent on the target.\n");
1676     }
1677 }
1678
1679 static struct memory_packet_config memory_write_packet_config =
1680 {
1681   "memory-write-packet-size",
1682 };
1683
1684 static void
1685 set_memory_write_packet_size (const char *args, int from_tty)
1686 {
1687   set_memory_packet_size (args, &memory_write_packet_config);
1688 }
1689
1690 static void
1691 show_memory_write_packet_size (const char *args, int from_tty)
1692 {
1693   show_memory_packet_size (&memory_write_packet_config);
1694 }
1695
1696 /* Show the number of hardware watchpoints that can be used.  */
1697
1698 static void
1699 show_hardware_watchpoint_limit (struct ui_file *file, int from_tty,
1700                                 struct cmd_list_element *c,
1701                                 const char *value)
1702 {
1703   fprintf_filtered (file, _("The maximum number of target hardware "
1704                             "watchpoints is %s.\n"), value);
1705 }
1706
1707 /* Show the length limit (in bytes) for hardware watchpoints.  */
1708
1709 static void
1710 show_hardware_watchpoint_length_limit (struct ui_file *file, int from_tty,
1711                                        struct cmd_list_element *c,
1712                                        const char *value)
1713 {
1714   fprintf_filtered (file, _("The maximum length (in bytes) of a target "
1715                             "hardware watchpoint is %s.\n"), value);
1716 }
1717
1718 /* Show the number of hardware breakpoints that can be used.  */
1719
1720 static void
1721 show_hardware_breakpoint_limit (struct ui_file *file, int from_tty,
1722                                 struct cmd_list_element *c,
1723                                 const char *value)
1724 {
1725   fprintf_filtered (file, _("The maximum number of target hardware "
1726                             "breakpoints is %s.\n"), value);
1727 }
1728
1729 long
1730 remote_target::get_memory_write_packet_size ()
1731 {
1732   return get_memory_packet_size (&memory_write_packet_config);
1733 }
1734
1735 static struct memory_packet_config memory_read_packet_config =
1736 {
1737   "memory-read-packet-size",
1738 };
1739
1740 static void
1741 set_memory_read_packet_size (const char *args, int from_tty)
1742 {
1743   set_memory_packet_size (args, &memory_read_packet_config);
1744 }
1745
1746 static void
1747 show_memory_read_packet_size (const char *args, int from_tty)
1748 {
1749   show_memory_packet_size (&memory_read_packet_config);
1750 }
1751
1752 long
1753 remote_target::get_memory_read_packet_size ()
1754 {
1755   long size = get_memory_packet_size (&memory_read_packet_config);
1756
1757   /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1758      extra buffer size argument before the memory read size can be
1759      increased beyond this.  */
1760   if (size > get_remote_packet_size ())
1761     size = get_remote_packet_size ();
1762   return size;
1763 }
1764
1765 \f
1766
1767 struct packet_config
1768   {
1769     const char *name;
1770     const char *title;
1771
1772     /* If auto, GDB auto-detects support for this packet or feature,
1773        either through qSupported, or by trying the packet and looking
1774        at the response.  If true, GDB assumes the target supports this
1775        packet.  If false, the packet is disabled.  Configs that don't
1776        have an associated command always have this set to auto.  */
1777     enum auto_boolean detect;
1778
1779     /* Does the target support this packet?  */
1780     enum packet_support support;
1781   };
1782
1783 static enum packet_support packet_config_support (struct packet_config *config);
1784 static enum packet_support packet_support (int packet);
1785
1786 static void
1787 show_packet_config_cmd (struct packet_config *config)
1788 {
1789   const char *support = "internal-error";
1790
1791   switch (packet_config_support (config))
1792     {
1793     case PACKET_ENABLE:
1794       support = "enabled";
1795       break;
1796     case PACKET_DISABLE:
1797       support = "disabled";
1798       break;
1799     case PACKET_SUPPORT_UNKNOWN:
1800       support = "unknown";
1801       break;
1802     }
1803   switch (config->detect)
1804     {
1805     case AUTO_BOOLEAN_AUTO:
1806       printf_filtered (_("Support for the `%s' packet "
1807                          "is auto-detected, currently %s.\n"),
1808                        config->name, support);
1809       break;
1810     case AUTO_BOOLEAN_TRUE:
1811     case AUTO_BOOLEAN_FALSE:
1812       printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1813                        config->name, support);
1814       break;
1815     }
1816 }
1817
1818 static void
1819 add_packet_config_cmd (struct packet_config *config, const char *name,
1820                        const char *title, int legacy)
1821 {
1822   char *set_doc;
1823   char *show_doc;
1824   char *cmd_name;
1825
1826   config->name = name;
1827   config->title = title;
1828   set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet.",
1829                         name, title);
1830   show_doc = xstrprintf ("Show current use of remote "
1831                          "protocol `%s' (%s) packet.",
1832                          name, title);
1833   /* set/show TITLE-packet {auto,on,off} */
1834   cmd_name = xstrprintf ("%s-packet", title);
1835   add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1836                                 &config->detect, set_doc,
1837                                 show_doc, NULL, /* help_doc */
1838                                 NULL,
1839                                 show_remote_protocol_packet_cmd,
1840                                 &remote_set_cmdlist, &remote_show_cmdlist);
1841   /* The command code copies the documentation strings.  */
1842   xfree (set_doc);
1843   xfree (show_doc);
1844   /* set/show remote NAME-packet {auto,on,off} -- legacy.  */
1845   if (legacy)
1846     {
1847       char *legacy_name;
1848
1849       legacy_name = xstrprintf ("%s-packet", name);
1850       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1851                      &remote_set_cmdlist);
1852       add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1853                      &remote_show_cmdlist);
1854     }
1855 }
1856
1857 static enum packet_result
1858 packet_check_result (const char *buf)
1859 {
1860   if (buf[0] != '\0')
1861     {
1862       /* The stub recognized the packet request.  Check that the
1863          operation succeeded.  */
1864       if (buf[0] == 'E'
1865           && isxdigit (buf[1]) && isxdigit (buf[2])
1866           && buf[3] == '\0')
1867         /* "Enn"  - definitly an error.  */
1868         return PACKET_ERROR;
1869
1870       /* Always treat "E." as an error.  This will be used for
1871          more verbose error messages, such as E.memtypes.  */
1872       if (buf[0] == 'E' && buf[1] == '.')
1873         return PACKET_ERROR;
1874
1875       /* The packet may or may not be OK.  Just assume it is.  */
1876       return PACKET_OK;
1877     }
1878   else
1879     /* The stub does not support the packet.  */
1880     return PACKET_UNKNOWN;
1881 }
1882
1883 static enum packet_result
1884 packet_check_result (const gdb::char_vector &buf)
1885 {
1886   return packet_check_result (buf.data ());
1887 }
1888
1889 static enum packet_result
1890 packet_ok (const char *buf, struct packet_config *config)
1891 {
1892   enum packet_result result;
1893
1894   if (config->detect != AUTO_BOOLEAN_TRUE
1895       && config->support == PACKET_DISABLE)
1896     internal_error (__FILE__, __LINE__,
1897                     _("packet_ok: attempt to use a disabled packet"));
1898
1899   result = packet_check_result (buf);
1900   switch (result)
1901     {
1902     case PACKET_OK:
1903     case PACKET_ERROR:
1904       /* The stub recognized the packet request.  */
1905       if (config->support == PACKET_SUPPORT_UNKNOWN)
1906         {
1907           if (remote_debug)
1908             fprintf_unfiltered (gdb_stdlog,
1909                                 "Packet %s (%s) is supported\n",
1910                                 config->name, config->title);
1911           config->support = PACKET_ENABLE;
1912         }
1913       break;
1914     case PACKET_UNKNOWN:
1915       /* The stub does not support the packet.  */
1916       if (config->detect == AUTO_BOOLEAN_AUTO
1917           && config->support == PACKET_ENABLE)
1918         {
1919           /* If the stub previously indicated that the packet was
1920              supported then there is a protocol error.  */
1921           error (_("Protocol error: %s (%s) conflicting enabled responses."),
1922                  config->name, config->title);
1923         }
1924       else if (config->detect == AUTO_BOOLEAN_TRUE)
1925         {
1926           /* The user set it wrong.  */
1927           error (_("Enabled packet %s (%s) not recognized by stub"),
1928                  config->name, config->title);
1929         }
1930
1931       if (remote_debug)
1932         fprintf_unfiltered (gdb_stdlog,
1933                             "Packet %s (%s) is NOT supported\n",
1934                             config->name, config->title);
1935       config->support = PACKET_DISABLE;
1936       break;
1937     }
1938
1939   return result;
1940 }
1941
1942 static enum packet_result
1943 packet_ok (const gdb::char_vector &buf, struct packet_config *config)
1944 {
1945   return packet_ok (buf.data (), config);
1946 }
1947
1948 enum {
1949   PACKET_vCont = 0,
1950   PACKET_X,
1951   PACKET_qSymbol,
1952   PACKET_P,
1953   PACKET_p,
1954   PACKET_Z0,
1955   PACKET_Z1,
1956   PACKET_Z2,
1957   PACKET_Z3,
1958   PACKET_Z4,
1959   PACKET_vFile_setfs,
1960   PACKET_vFile_open,
1961   PACKET_vFile_pread,
1962   PACKET_vFile_pwrite,
1963   PACKET_vFile_close,
1964   PACKET_vFile_unlink,
1965   PACKET_vFile_readlink,
1966   PACKET_vFile_fstat,
1967   PACKET_qXfer_auxv,
1968   PACKET_qXfer_features,
1969   PACKET_qXfer_exec_file,
1970   PACKET_qXfer_libraries,
1971   PACKET_qXfer_libraries_svr4,
1972   PACKET_qXfer_memory_map,
1973   PACKET_qXfer_spu_read,
1974   PACKET_qXfer_spu_write,
1975   PACKET_qXfer_osdata,
1976   PACKET_qXfer_threads,
1977   PACKET_qXfer_statictrace_read,
1978   PACKET_qXfer_traceframe_info,
1979   PACKET_qXfer_uib,
1980   PACKET_qGetTIBAddr,
1981   PACKET_qGetTLSAddr,
1982   PACKET_qSupported,
1983   PACKET_qTStatus,
1984   PACKET_QPassSignals,
1985   PACKET_QCatchSyscalls,
1986   PACKET_QProgramSignals,
1987   PACKET_QSetWorkingDir,
1988   PACKET_QStartupWithShell,
1989   PACKET_QEnvironmentHexEncoded,
1990   PACKET_QEnvironmentReset,
1991   PACKET_QEnvironmentUnset,
1992   PACKET_qCRC,
1993   PACKET_qSearch_memory,
1994   PACKET_vAttach,
1995   PACKET_vRun,
1996   PACKET_QStartNoAckMode,
1997   PACKET_vKill,
1998   PACKET_qXfer_siginfo_read,
1999   PACKET_qXfer_siginfo_write,
2000   PACKET_qAttached,
2001
2002   /* Support for conditional tracepoints.  */
2003   PACKET_ConditionalTracepoints,
2004
2005   /* Support for target-side breakpoint conditions.  */
2006   PACKET_ConditionalBreakpoints,
2007
2008   /* Support for target-side breakpoint commands.  */
2009   PACKET_BreakpointCommands,
2010
2011   /* Support for fast tracepoints.  */
2012   PACKET_FastTracepoints,
2013
2014   /* Support for static tracepoints.  */
2015   PACKET_StaticTracepoints,
2016
2017   /* Support for installing tracepoints while a trace experiment is
2018      running.  */
2019   PACKET_InstallInTrace,
2020
2021   PACKET_bc,
2022   PACKET_bs,
2023   PACKET_TracepointSource,
2024   PACKET_QAllow,
2025   PACKET_qXfer_fdpic,
2026   PACKET_QDisableRandomization,
2027   PACKET_QAgent,
2028   PACKET_QTBuffer_size,
2029   PACKET_Qbtrace_off,
2030   PACKET_Qbtrace_bts,
2031   PACKET_Qbtrace_pt,
2032   PACKET_qXfer_btrace,
2033
2034   /* Support for the QNonStop packet.  */
2035   PACKET_QNonStop,
2036
2037   /* Support for the QThreadEvents packet.  */
2038   PACKET_QThreadEvents,
2039
2040   /* Support for multi-process extensions.  */
2041   PACKET_multiprocess_feature,
2042
2043   /* Support for enabling and disabling tracepoints while a trace
2044      experiment is running.  */
2045   PACKET_EnableDisableTracepoints_feature,
2046
2047   /* Support for collecting strings using the tracenz bytecode.  */
2048   PACKET_tracenz_feature,
2049
2050   /* Support for continuing to run a trace experiment while GDB is
2051      disconnected.  */
2052   PACKET_DisconnectedTracing_feature,
2053
2054   /* Support for qXfer:libraries-svr4:read with a non-empty annex.  */
2055   PACKET_augmented_libraries_svr4_read_feature,
2056
2057   /* Support for the qXfer:btrace-conf:read packet.  */
2058   PACKET_qXfer_btrace_conf,
2059
2060   /* Support for the Qbtrace-conf:bts:size packet.  */
2061   PACKET_Qbtrace_conf_bts_size,
2062
2063   /* Support for swbreak+ feature.  */
2064   PACKET_swbreak_feature,
2065
2066   /* Support for hwbreak+ feature.  */
2067   PACKET_hwbreak_feature,
2068
2069   /* Support for fork events.  */
2070   PACKET_fork_event_feature,
2071
2072   /* Support for vfork events.  */
2073   PACKET_vfork_event_feature,
2074
2075   /* Support for the Qbtrace-conf:pt:size packet.  */
2076   PACKET_Qbtrace_conf_pt_size,
2077
2078   /* Support for exec events.  */
2079   PACKET_exec_event_feature,
2080
2081   /* Support for query supported vCont actions.  */
2082   PACKET_vContSupported,
2083
2084   /* Support remote CTRL-C.  */
2085   PACKET_vCtrlC,
2086
2087   /* Support TARGET_WAITKIND_NO_RESUMED.  */
2088   PACKET_no_resumed,
2089
2090   PACKET_MAX
2091 };
2092
2093 static struct packet_config remote_protocol_packets[PACKET_MAX];
2094
2095 /* Returns the packet's corresponding "set remote foo-packet" command
2096    state.  See struct packet_config for more details.  */
2097
2098 static enum auto_boolean
2099 packet_set_cmd_state (int packet)
2100 {
2101   return remote_protocol_packets[packet].detect;
2102 }
2103
2104 /* Returns whether a given packet or feature is supported.  This takes
2105    into account the state of the corresponding "set remote foo-packet"
2106    command, which may be used to bypass auto-detection.  */
2107
2108 static enum packet_support
2109 packet_config_support (struct packet_config *config)
2110 {
2111   switch (config->detect)
2112     {
2113     case AUTO_BOOLEAN_TRUE:
2114       return PACKET_ENABLE;
2115     case AUTO_BOOLEAN_FALSE:
2116       return PACKET_DISABLE;
2117     case AUTO_BOOLEAN_AUTO:
2118       return config->support;
2119     default:
2120       gdb_assert_not_reached (_("bad switch"));
2121     }
2122 }
2123
2124 /* Same as packet_config_support, but takes the packet's enum value as
2125    argument.  */
2126
2127 static enum packet_support
2128 packet_support (int packet)
2129 {
2130   struct packet_config *config = &remote_protocol_packets[packet];
2131
2132   return packet_config_support (config);
2133 }
2134
2135 static void
2136 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
2137                                  struct cmd_list_element *c,
2138                                  const char *value)
2139 {
2140   struct packet_config *packet;
2141
2142   for (packet = remote_protocol_packets;
2143        packet < &remote_protocol_packets[PACKET_MAX];
2144        packet++)
2145     {
2146       if (&packet->detect == c->var)
2147         {
2148           show_packet_config_cmd (packet);
2149           return;
2150         }
2151     }
2152   internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
2153                   c->name);
2154 }
2155
2156 /* Should we try one of the 'Z' requests?  */
2157
2158 enum Z_packet_type
2159 {
2160   Z_PACKET_SOFTWARE_BP,
2161   Z_PACKET_HARDWARE_BP,
2162   Z_PACKET_WRITE_WP,
2163   Z_PACKET_READ_WP,
2164   Z_PACKET_ACCESS_WP,
2165   NR_Z_PACKET_TYPES
2166 };
2167
2168 /* For compatibility with older distributions.  Provide a ``set remote
2169    Z-packet ...'' command that updates all the Z packet types.  */
2170
2171 static enum auto_boolean remote_Z_packet_detect;
2172
2173 static void
2174 set_remote_protocol_Z_packet_cmd (const char *args, int from_tty,
2175                                   struct cmd_list_element *c)
2176 {
2177   int i;
2178
2179   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2180     remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
2181 }
2182
2183 static void
2184 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
2185                                    struct cmd_list_element *c,
2186                                    const char *value)
2187 {
2188   int i;
2189
2190   for (i = 0; i < NR_Z_PACKET_TYPES; i++)
2191     {
2192       show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
2193     }
2194 }
2195
2196 /* Returns true if the multi-process extensions are in effect.  */
2197
2198 static int
2199 remote_multi_process_p (struct remote_state *rs)
2200 {
2201   return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
2202 }
2203
2204 /* Returns true if fork events are supported.  */
2205
2206 static int
2207 remote_fork_event_p (struct remote_state *rs)
2208 {
2209   return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
2210 }
2211
2212 /* Returns true if vfork events are supported.  */
2213
2214 static int
2215 remote_vfork_event_p (struct remote_state *rs)
2216 {
2217   return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
2218 }
2219
2220 /* Returns true if exec events are supported.  */
2221
2222 static int
2223 remote_exec_event_p (struct remote_state *rs)
2224 {
2225   return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
2226 }
2227
2228 /* Insert fork catchpoint target routine.  If fork events are enabled
2229    then return success, nothing more to do.  */
2230
2231 int
2232 remote_target::insert_fork_catchpoint (int pid)
2233 {
2234   struct remote_state *rs = get_remote_state ();
2235
2236   return !remote_fork_event_p (rs);
2237 }
2238
2239 /* Remove fork catchpoint target routine.  Nothing to do, just
2240    return success.  */
2241
2242 int
2243 remote_target::remove_fork_catchpoint (int pid)
2244 {
2245   return 0;
2246 }
2247
2248 /* Insert vfork catchpoint target routine.  If vfork events are enabled
2249    then return success, nothing more to do.  */
2250
2251 int
2252 remote_target::insert_vfork_catchpoint (int pid)
2253 {
2254   struct remote_state *rs = get_remote_state ();
2255
2256   return !remote_vfork_event_p (rs);
2257 }
2258
2259 /* Remove vfork catchpoint target routine.  Nothing to do, just
2260    return success.  */
2261
2262 int
2263 remote_target::remove_vfork_catchpoint (int pid)
2264 {
2265   return 0;
2266 }
2267
2268 /* Insert exec catchpoint target routine.  If exec events are
2269    enabled, just return success.  */
2270
2271 int
2272 remote_target::insert_exec_catchpoint (int pid)
2273 {
2274   struct remote_state *rs = get_remote_state ();
2275
2276   return !remote_exec_event_p (rs);
2277 }
2278
2279 /* Remove exec catchpoint target routine.  Nothing to do, just
2280    return success.  */
2281
2282 int
2283 remote_target::remove_exec_catchpoint (int pid)
2284 {
2285   return 0;
2286 }
2287
2288 \f
2289
2290 /* Take advantage of the fact that the TID field is not used, to tag
2291    special ptids with it set to != 0.  */
2292 static const ptid_t magic_null_ptid (42000, -1, 1);
2293 static const ptid_t not_sent_ptid (42000, -2, 1);
2294 static const ptid_t any_thread_ptid (42000, 0, 1);
2295
2296 /* Find out if the stub attached to PID (and hence GDB should offer to
2297    detach instead of killing it when bailing out).  */
2298
2299 int
2300 remote_target::remote_query_attached (int pid)
2301 {
2302   struct remote_state *rs = get_remote_state ();
2303   size_t size = get_remote_packet_size ();
2304
2305   if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
2306     return 0;
2307
2308   if (remote_multi_process_p (rs))
2309     xsnprintf (rs->buf.data (), size, "qAttached:%x", pid);
2310   else
2311     xsnprintf (rs->buf.data (), size, "qAttached");
2312
2313   putpkt (rs->buf);
2314   getpkt (&rs->buf, 0);
2315
2316   switch (packet_ok (rs->buf,
2317                      &remote_protocol_packets[PACKET_qAttached]))
2318     {
2319     case PACKET_OK:
2320       if (strcmp (rs->buf.data (), "1") == 0)
2321         return 1;
2322       break;
2323     case PACKET_ERROR:
2324       warning (_("Remote failure reply: %s"), rs->buf.data ());
2325       break;
2326     case PACKET_UNKNOWN:
2327       break;
2328     }
2329
2330   return 0;
2331 }
2332
2333 /* Add PID to GDB's inferior table.  If FAKE_PID_P is true, then PID
2334    has been invented by GDB, instead of reported by the target.  Since
2335    we can be connected to a remote system before before knowing about
2336    any inferior, mark the target with execution when we find the first
2337    inferior.  If ATTACHED is 1, then we had just attached to this
2338    inferior.  If it is 0, then we just created this inferior.  If it
2339    is -1, then try querying the remote stub to find out if it had
2340    attached to the inferior or not.  If TRY_OPEN_EXEC is true then
2341    attempt to open this inferior's executable as the main executable
2342    if no main executable is open already.  */
2343
2344 inferior *
2345 remote_target::remote_add_inferior (bool fake_pid_p, int pid, int attached,
2346                                     int try_open_exec)
2347 {
2348   struct inferior *inf;
2349
2350   /* Check whether this process we're learning about is to be
2351      considered attached, or if is to be considered to have been
2352      spawned by the stub.  */
2353   if (attached == -1)
2354     attached = remote_query_attached (pid);
2355
2356   if (gdbarch_has_global_solist (target_gdbarch ()))
2357     {
2358       /* If the target shares code across all inferiors, then every
2359          attach adds a new inferior.  */
2360       inf = add_inferior (pid);
2361
2362       /* ... and every inferior is bound to the same program space.
2363          However, each inferior may still have its own address
2364          space.  */
2365       inf->aspace = maybe_new_address_space ();
2366       inf->pspace = current_program_space;
2367     }
2368   else
2369     {
2370       /* In the traditional debugging scenario, there's a 1-1 match
2371          between program/address spaces.  We simply bind the inferior
2372          to the program space's address space.  */
2373       inf = current_inferior ();
2374       inferior_appeared (inf, pid);
2375     }
2376
2377   inf->attach_flag = attached;
2378   inf->fake_pid_p = fake_pid_p;
2379
2380   /* If no main executable is currently open then attempt to
2381      open the file that was executed to create this inferior.  */
2382   if (try_open_exec && get_exec_file (0) == NULL)
2383     exec_file_locate_attach (pid, 0, 1);
2384
2385   return inf;
2386 }
2387
2388 static remote_thread_info *get_remote_thread_info (thread_info *thread);
2389 static remote_thread_info *get_remote_thread_info (ptid_t ptid);
2390
2391 /* Add thread PTID to GDB's thread list.  Tag it as executing/running
2392    according to RUNNING.  */
2393
2394 thread_info *
2395 remote_target::remote_add_thread (ptid_t ptid, bool running, bool executing)
2396 {
2397   struct remote_state *rs = get_remote_state ();
2398   struct thread_info *thread;
2399
2400   /* GDB historically didn't pull threads in the initial connection
2401      setup.  If the remote target doesn't even have a concept of
2402      threads (e.g., a bare-metal target), even if internally we
2403      consider that a single-threaded target, mentioning a new thread
2404      might be confusing to the user.  Be silent then, preserving the
2405      age old behavior.  */
2406   if (rs->starting_up)
2407     thread = add_thread_silent (ptid);
2408   else
2409     thread = add_thread (ptid);
2410
2411   get_remote_thread_info (thread)->vcont_resumed = executing;
2412   set_executing (ptid, executing);
2413   set_running (ptid, running);
2414
2415   return thread;
2416 }
2417
2418 /* Come here when we learn about a thread id from the remote target.
2419    It may be the first time we hear about such thread, so take the
2420    opportunity to add it to GDB's thread list.  In case this is the
2421    first time we're noticing its corresponding inferior, add it to
2422    GDB's inferior list as well.  EXECUTING indicates whether the
2423    thread is (internally) executing or stopped.  */
2424
2425 void
2426 remote_target::remote_notice_new_inferior (ptid_t currthread, int executing)
2427 {
2428   /* In non-stop mode, we assume new found threads are (externally)
2429      running until proven otherwise with a stop reply.  In all-stop,
2430      we can only get here if all threads are stopped.  */
2431   int running = target_is_non_stop_p () ? 1 : 0;
2432
2433   /* If this is a new thread, add it to GDB's thread list.
2434      If we leave it up to WFI to do this, bad things will happen.  */
2435
2436   thread_info *tp = find_thread_ptid (currthread);
2437   if (tp != NULL && tp->state == THREAD_EXITED)
2438     {
2439       /* We're seeing an event on a thread id we knew had exited.
2440          This has to be a new thread reusing the old id.  Add it.  */
2441       remote_add_thread (currthread, running, executing);
2442       return;
2443     }
2444
2445   if (!in_thread_list (currthread))
2446     {
2447       struct inferior *inf = NULL;
2448       int pid = currthread.pid ();
2449
2450       if (inferior_ptid.is_pid ()
2451           && pid == inferior_ptid.pid ())
2452         {
2453           /* inferior_ptid has no thread member yet.  This can happen
2454              with the vAttach -> remote_wait,"TAAthread:" path if the
2455              stub doesn't support qC.  This is the first stop reported
2456              after an attach, so this is the main thread.  Update the
2457              ptid in the thread list.  */
2458           if (in_thread_list (ptid_t (pid)))
2459             thread_change_ptid (inferior_ptid, currthread);
2460           else
2461             {
2462               remote_add_thread (currthread, running, executing);
2463               inferior_ptid = currthread;
2464             }
2465           return;
2466         }
2467
2468       if (magic_null_ptid == inferior_ptid)
2469         {
2470           /* inferior_ptid is not set yet.  This can happen with the
2471              vRun -> remote_wait,"TAAthread:" path if the stub
2472              doesn't support qC.  This is the first stop reported
2473              after an attach, so this is the main thread.  Update the
2474              ptid in the thread list.  */
2475           thread_change_ptid (inferior_ptid, currthread);
2476           return;
2477         }
2478
2479       /* When connecting to a target remote, or to a target
2480          extended-remote which already was debugging an inferior, we
2481          may not know about it yet.  Add it before adding its child
2482          thread, so notifications are emitted in a sensible order.  */
2483       if (find_inferior_pid (currthread.pid ()) == NULL)
2484         {
2485           struct remote_state *rs = get_remote_state ();
2486           bool fake_pid_p = !remote_multi_process_p (rs);
2487
2488           inf = remote_add_inferior (fake_pid_p,
2489                                      currthread.pid (), -1, 1);
2490         }
2491
2492       /* This is really a new thread.  Add it.  */
2493       thread_info *new_thr
2494         = remote_add_thread (currthread, running, executing);
2495
2496       /* If we found a new inferior, let the common code do whatever
2497          it needs to with it (e.g., read shared libraries, insert
2498          breakpoints), unless we're just setting up an all-stop
2499          connection.  */
2500       if (inf != NULL)
2501         {
2502           struct remote_state *rs = get_remote_state ();
2503
2504           if (!rs->starting_up)
2505             notice_new_inferior (new_thr, executing, 0);
2506         }
2507     }
2508 }
2509
2510 /* Return THREAD's private thread data, creating it if necessary.  */
2511
2512 static remote_thread_info *
2513 get_remote_thread_info (thread_info *thread)
2514 {
2515   gdb_assert (thread != NULL);
2516
2517   if (thread->priv == NULL)
2518     thread->priv.reset (new remote_thread_info);
2519
2520   return static_cast<remote_thread_info *> (thread->priv.get ());
2521 }
2522
2523 static remote_thread_info *
2524 get_remote_thread_info (ptid_t ptid)
2525 {
2526   thread_info *thr = find_thread_ptid (ptid);
2527   return get_remote_thread_info (thr);
2528 }
2529
2530 /* Call this function as a result of
2531    1) A halt indication (T packet) containing a thread id
2532    2) A direct query of currthread
2533    3) Successful execution of set thread */
2534
2535 static void
2536 record_currthread (struct remote_state *rs, ptid_t currthread)
2537 {
2538   rs->general_thread = currthread;
2539 }
2540
2541 /* If 'QPassSignals' is supported, tell the remote stub what signals
2542    it can simply pass through to the inferior without reporting.  */
2543
2544 void
2545 remote_target::pass_signals (gdb::array_view<const unsigned char> pass_signals)
2546 {
2547   if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
2548     {
2549       char *pass_packet, *p;
2550       int count = 0;
2551       struct remote_state *rs = get_remote_state ();
2552
2553       gdb_assert (pass_signals.size () < 256);
2554       for (size_t i = 0; i < pass_signals.size (); i++)
2555         {
2556           if (pass_signals[i])
2557             count++;
2558         }
2559       pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
2560       strcpy (pass_packet, "QPassSignals:");
2561       p = pass_packet + strlen (pass_packet);
2562       for (size_t i = 0; i < pass_signals.size (); i++)
2563         {
2564           if (pass_signals[i])
2565             {
2566               if (i >= 16)
2567                 *p++ = tohex (i >> 4);
2568               *p++ = tohex (i & 15);
2569               if (count)
2570                 *p++ = ';';
2571               else
2572                 break;
2573               count--;
2574             }
2575         }
2576       *p = 0;
2577       if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
2578         {
2579           putpkt (pass_packet);
2580           getpkt (&rs->buf, 0);
2581           packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
2582           if (rs->last_pass_packet)
2583             xfree (rs->last_pass_packet);
2584           rs->last_pass_packet = pass_packet;
2585         }
2586       else
2587         xfree (pass_packet);
2588     }
2589 }
2590
2591 /* If 'QCatchSyscalls' is supported, tell the remote stub
2592    to report syscalls to GDB.  */
2593
2594 int
2595 remote_target::set_syscall_catchpoint (int pid, bool needed, int any_count,
2596                                        gdb::array_view<const int> syscall_counts)
2597 {
2598   const char *catch_packet;
2599   enum packet_result result;
2600   int n_sysno = 0;
2601
2602   if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
2603     {
2604       /* Not supported.  */
2605       return 1;
2606     }
2607
2608   if (needed && any_count == 0)
2609     {
2610       /* Count how many syscalls are to be caught.  */
2611       for (size_t i = 0; i < syscall_counts.size (); i++)
2612         {
2613           if (syscall_counts[i] != 0)
2614             n_sysno++;
2615         }
2616     }
2617
2618   if (remote_debug)
2619     {
2620       fprintf_unfiltered (gdb_stdlog,
2621                           "remote_set_syscall_catchpoint "
2622                           "pid %d needed %d any_count %d n_sysno %d\n",
2623                           pid, needed, any_count, n_sysno);
2624     }
2625
2626   std::string built_packet;
2627   if (needed)
2628     {
2629       /* Prepare a packet with the sysno list, assuming max 8+1
2630          characters for a sysno.  If the resulting packet size is too
2631          big, fallback on the non-selective packet.  */
2632       const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1;
2633       built_packet.reserve (maxpktsz);
2634       built_packet = "QCatchSyscalls:1";
2635       if (any_count == 0)
2636         {
2637           /* Add in each syscall to be caught.  */
2638           for (size_t i = 0; i < syscall_counts.size (); i++)
2639             {
2640               if (syscall_counts[i] != 0)
2641                 string_appendf (built_packet, ";%zx", i);
2642             }
2643         }
2644       if (built_packet.size () > get_remote_packet_size ())
2645         {
2646           /* catch_packet too big.  Fallback to less efficient
2647              non selective mode, with GDB doing the filtering.  */
2648           catch_packet = "QCatchSyscalls:1";
2649         }
2650       else
2651         catch_packet = built_packet.c_str ();
2652     }
2653   else
2654     catch_packet = "QCatchSyscalls:0";
2655
2656   struct remote_state *rs = get_remote_state ();
2657
2658   putpkt (catch_packet);
2659   getpkt (&rs->buf, 0);
2660   result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
2661   if (result == PACKET_OK)
2662     return 0;
2663   else
2664     return -1;
2665 }
2666
2667 /* If 'QProgramSignals' is supported, tell the remote stub what
2668    signals it should pass through to the inferior when detaching.  */
2669
2670 void
2671 remote_target::program_signals (gdb::array_view<const unsigned char> signals)
2672 {
2673   if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
2674     {
2675       char *packet, *p;
2676       int count = 0;
2677       struct remote_state *rs = get_remote_state ();
2678
2679       gdb_assert (signals.size () < 256);
2680       for (size_t i = 0; i < signals.size (); i++)
2681         {
2682           if (signals[i])
2683             count++;
2684         }
2685       packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
2686       strcpy (packet, "QProgramSignals:");
2687       p = packet + strlen (packet);
2688       for (size_t i = 0; i < signals.size (); i++)
2689         {
2690           if (signal_pass_state (i))
2691             {
2692               if (i >= 16)
2693                 *p++ = tohex (i >> 4);
2694               *p++ = tohex (i & 15);
2695               if (count)
2696                 *p++ = ';';
2697               else
2698                 break;
2699               count--;
2700             }
2701         }
2702       *p = 0;
2703       if (!rs->last_program_signals_packet
2704           || strcmp (rs->last_program_signals_packet, packet) != 0)
2705         {
2706           putpkt (packet);
2707           getpkt (&rs->buf, 0);
2708           packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
2709           xfree (rs->last_program_signals_packet);
2710           rs->last_program_signals_packet = packet;
2711         }
2712       else
2713         xfree (packet);
2714     }
2715 }
2716
2717 /* If PTID is MAGIC_NULL_PTID, don't set any thread.  If PTID is
2718    MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2719    thread.  If GEN is set, set the general thread, if not, then set
2720    the step/continue thread.  */
2721 void
2722 remote_target::set_thread (ptid_t ptid, int gen)
2723 {
2724   struct remote_state *rs = get_remote_state ();
2725   ptid_t state = gen ? rs->general_thread : rs->continue_thread;
2726   char *buf = rs->buf.data ();
2727   char *endbuf = buf + get_remote_packet_size ();
2728
2729   if (state == ptid)
2730     return;
2731
2732   *buf++ = 'H';
2733   *buf++ = gen ? 'g' : 'c';
2734   if (ptid == magic_null_ptid)
2735     xsnprintf (buf, endbuf - buf, "0");
2736   else if (ptid == any_thread_ptid)
2737     xsnprintf (buf, endbuf - buf, "0");
2738   else if (ptid == minus_one_ptid)
2739     xsnprintf (buf, endbuf - buf, "-1");
2740   else
2741     write_ptid (buf, endbuf, ptid);
2742   putpkt (rs->buf);
2743   getpkt (&rs->buf, 0);
2744   if (gen)
2745     rs->general_thread = ptid;
2746   else
2747     rs->continue_thread = ptid;
2748 }
2749
2750 void
2751 remote_target::set_general_thread (ptid_t ptid)
2752 {
2753   set_thread (ptid, 1);
2754 }
2755
2756 void
2757 remote_target::set_continue_thread (ptid_t ptid)
2758 {
2759   set_thread (ptid, 0);
2760 }
2761
2762 /* Change the remote current process.  Which thread within the process
2763    ends up selected isn't important, as long as it is the same process
2764    as what INFERIOR_PTID points to.
2765
2766    This comes from that fact that there is no explicit notion of
2767    "selected process" in the protocol.  The selected process for
2768    general operations is the process the selected general thread
2769    belongs to.  */
2770
2771 void
2772 remote_target::set_general_process ()
2773 {
2774   struct remote_state *rs = get_remote_state ();
2775
2776   /* If the remote can't handle multiple processes, don't bother.  */
2777   if (!remote_multi_process_p (rs))
2778     return;
2779
2780   /* We only need to change the remote current thread if it's pointing
2781      at some other process.  */
2782   if (rs->general_thread.pid () != inferior_ptid.pid ())
2783     set_general_thread (inferior_ptid);
2784 }
2785
2786 \f
2787 /* Return nonzero if this is the main thread that we made up ourselves
2788    to model non-threaded targets as single-threaded.  */
2789
2790 static int
2791 remote_thread_always_alive (ptid_t ptid)
2792 {
2793   if (ptid == magic_null_ptid)
2794     /* The main thread is always alive.  */
2795     return 1;
2796
2797   if (ptid.pid () != 0 && ptid.lwp () == 0)
2798     /* The main thread is always alive.  This can happen after a
2799        vAttach, if the remote side doesn't support
2800        multi-threading.  */
2801     return 1;
2802
2803   return 0;
2804 }
2805
2806 /* Return nonzero if the thread PTID is still alive on the remote
2807    system.  */
2808
2809 bool
2810 remote_target::thread_alive (ptid_t ptid)
2811 {
2812   struct remote_state *rs = get_remote_state ();
2813   char *p, *endp;
2814
2815   /* Check if this is a thread that we made up ourselves to model
2816      non-threaded targets as single-threaded.  */
2817   if (remote_thread_always_alive (ptid))
2818     return 1;
2819
2820   p = rs->buf.data ();
2821   endp = p + get_remote_packet_size ();
2822
2823   *p++ = 'T';
2824   write_ptid (p, endp, ptid);
2825
2826   putpkt (rs->buf);
2827   getpkt (&rs->buf, 0);
2828   return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
2829 }
2830
2831 /* Return a pointer to a thread name if we know it and NULL otherwise.
2832    The thread_info object owns the memory for the name.  */
2833
2834 const char *
2835 remote_target::thread_name (struct thread_info *info)
2836 {
2837   if (info->priv != NULL)
2838     {
2839       const std::string &name = get_remote_thread_info (info)->name;
2840       return !name.empty () ? name.c_str () : NULL;
2841     }
2842
2843   return NULL;
2844 }
2845
2846 /* About these extended threadlist and threadinfo packets.  They are
2847    variable length packets but, the fields within them are often fixed
2848    length.  They are redundent enough to send over UDP as is the
2849    remote protocol in general.  There is a matching unit test module
2850    in libstub.  */
2851
2852 /* WARNING: This threadref data structure comes from the remote O.S.,
2853    libstub protocol encoding, and remote.c.  It is not particularly
2854    changable.  */
2855
2856 /* Right now, the internal structure is int. We want it to be bigger.
2857    Plan to fix this.  */
2858
2859 typedef int gdb_threadref;      /* Internal GDB thread reference.  */
2860
2861 /* gdb_ext_thread_info is an internal GDB data structure which is
2862    equivalent to the reply of the remote threadinfo packet.  */
2863
2864 struct gdb_ext_thread_info
2865   {
2866     threadref threadid;         /* External form of thread reference.  */
2867     int active;                 /* Has state interesting to GDB?
2868                                    regs, stack.  */
2869     char display[256];          /* Brief state display, name,
2870                                    blocked/suspended.  */
2871     char shortname[32];         /* To be used to name threads.  */
2872     char more_display[256];     /* Long info, statistics, queue depth,
2873                                    whatever.  */
2874   };
2875
2876 /* The volume of remote transfers can be limited by submitting
2877    a mask containing bits specifying the desired information.
2878    Use a union of these values as the 'selection' parameter to
2879    get_thread_info.  FIXME: Make these TAG names more thread specific.  */
2880
2881 #define TAG_THREADID 1
2882 #define TAG_EXISTS 2
2883 #define TAG_DISPLAY 4
2884 #define TAG_THREADNAME 8
2885 #define TAG_MOREDISPLAY 16
2886
2887 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2888
2889 static char *unpack_nibble (char *buf, int *val);
2890
2891 static char *unpack_byte (char *buf, int *value);
2892
2893 static char *pack_int (char *buf, int value);
2894
2895 static char *unpack_int (char *buf, int *value);
2896
2897 static char *unpack_string (char *src, char *dest, int length);
2898
2899 static char *pack_threadid (char *pkt, threadref *id);
2900
2901 static char *unpack_threadid (char *inbuf, threadref *id);
2902
2903 void int_to_threadref (threadref *id, int value);
2904
2905 static int threadref_to_int (threadref *ref);
2906
2907 static void copy_threadref (threadref *dest, threadref *src);
2908
2909 static int threadmatch (threadref *dest, threadref *src);
2910
2911 static char *pack_threadinfo_request (char *pkt, int mode,
2912                                       threadref *id);
2913
2914 static char *pack_threadlist_request (char *pkt, int startflag,
2915                                       int threadcount,
2916                                       threadref *nextthread);
2917
2918 static int remote_newthread_step (threadref *ref, void *context);
2919
2920
2921 /* Write a PTID to BUF.  ENDBUF points to one-passed-the-end of the
2922    buffer we're allowed to write to.  Returns
2923    BUF+CHARACTERS_WRITTEN.  */
2924
2925 char *
2926 remote_target::write_ptid (char *buf, const char *endbuf, ptid_t ptid)
2927 {
2928   int pid, tid;
2929   struct remote_state *rs = get_remote_state ();
2930
2931   if (remote_multi_process_p (rs))
2932     {
2933       pid = ptid.pid ();
2934       if (pid < 0)
2935         buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2936       else
2937         buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2938     }
2939   tid = ptid.lwp ();
2940   if (tid < 0)
2941     buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2942   else
2943     buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2944
2945   return buf;
2946 }
2947
2948 /* Extract a PTID from BUF.  If non-null, OBUF is set to one past the
2949    last parsed char.  Returns null_ptid if no thread id is found, and
2950    throws an error if the thread id has an invalid format.  */
2951
2952 static ptid_t
2953 read_ptid (const char *buf, const char **obuf)
2954 {
2955   const char *p = buf;
2956   const char *pp;
2957   ULONGEST pid = 0, tid = 0;
2958
2959   if (*p == 'p')
2960     {
2961       /* Multi-process ptid.  */
2962       pp = unpack_varlen_hex (p + 1, &pid);
2963       if (*pp != '.')
2964         error (_("invalid remote ptid: %s"), p);
2965
2966       p = pp;
2967       pp = unpack_varlen_hex (p + 1, &tid);
2968       if (obuf)
2969         *obuf = pp;
2970       return ptid_t (pid, tid, 0);
2971     }
2972
2973   /* No multi-process.  Just a tid.  */
2974   pp = unpack_varlen_hex (p, &tid);
2975
2976   /* Return null_ptid when no thread id is found.  */
2977   if (p == pp)
2978     {
2979       if (obuf)
2980         *obuf = pp;
2981       return null_ptid;
2982     }
2983
2984   /* Since the stub is not sending a process id, then default to
2985      what's in inferior_ptid, unless it's null at this point.  If so,
2986      then since there's no way to know the pid of the reported
2987      threads, use the magic number.  */
2988   if (inferior_ptid == null_ptid)
2989     pid = magic_null_ptid.pid ();
2990   else
2991     pid = inferior_ptid.pid ();
2992
2993   if (obuf)
2994     *obuf = pp;
2995   return ptid_t (pid, tid, 0);
2996 }
2997
2998 static int
2999 stubhex (int ch)
3000 {
3001   if (ch >= 'a' && ch <= 'f')
3002     return ch - 'a' + 10;
3003   if (ch >= '0' && ch <= '9')
3004     return ch - '0';
3005   if (ch >= 'A' && ch <= 'F')
3006     return ch - 'A' + 10;
3007   return -1;
3008 }
3009
3010 static int
3011 stub_unpack_int (char *buff, int fieldlength)
3012 {
3013   int nibble;
3014   int retval = 0;
3015
3016   while (fieldlength)
3017     {
3018       nibble = stubhex (*buff++);
3019       retval |= nibble;
3020       fieldlength--;
3021       if (fieldlength)
3022         retval = retval << 4;
3023     }
3024   return retval;
3025 }
3026
3027 static char *
3028 unpack_nibble (char *buf, int *val)
3029 {
3030   *val = fromhex (*buf++);
3031   return buf;
3032 }
3033
3034 static char *
3035 unpack_byte (char *buf, int *value)
3036 {
3037   *value = stub_unpack_int (buf, 2);
3038   return buf + 2;
3039 }
3040
3041 static char *
3042 pack_int (char *buf, int value)
3043 {
3044   buf = pack_hex_byte (buf, (value >> 24) & 0xff);
3045   buf = pack_hex_byte (buf, (value >> 16) & 0xff);
3046   buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
3047   buf = pack_hex_byte (buf, (value & 0xff));
3048   return buf;
3049 }
3050
3051 static char *
3052 unpack_int (char *buf, int *value)
3053 {
3054   *value = stub_unpack_int (buf, 8);
3055   return buf + 8;
3056 }
3057
3058 #if 0                   /* Currently unused, uncomment when needed.  */
3059 static char *pack_string (char *pkt, char *string);
3060
3061 static char *
3062 pack_string (char *pkt, char *string)
3063 {
3064   char ch;
3065   int len;
3066
3067   len = strlen (string);
3068   if (len > 200)
3069     len = 200;          /* Bigger than most GDB packets, junk???  */
3070   pkt = pack_hex_byte (pkt, len);
3071   while (len-- > 0)
3072     {
3073       ch = *string++;
3074       if ((ch == '\0') || (ch == '#'))
3075         ch = '*';               /* Protect encapsulation.  */
3076       *pkt++ = ch;
3077     }
3078   return pkt;
3079 }
3080 #endif /* 0 (unused) */
3081
3082 static char *
3083 unpack_string (char *src, char *dest, int length)
3084 {
3085   while (length--)
3086     *dest++ = *src++;
3087   *dest = '\0';
3088   return src;
3089 }
3090
3091 static char *
3092 pack_threadid (char *pkt, threadref *id)
3093 {
3094   char *limit;
3095   unsigned char *altid;
3096
3097   altid = (unsigned char *) id;
3098   limit = pkt + BUF_THREAD_ID_SIZE;
3099   while (pkt < limit)
3100     pkt = pack_hex_byte (pkt, *altid++);
3101   return pkt;
3102 }
3103
3104
3105 static char *
3106 unpack_threadid (char *inbuf, threadref *id)
3107 {
3108   char *altref;
3109   char *limit = inbuf + BUF_THREAD_ID_SIZE;
3110   int x, y;
3111
3112   altref = (char *) id;
3113
3114   while (inbuf < limit)
3115     {
3116       x = stubhex (*inbuf++);
3117       y = stubhex (*inbuf++);
3118       *altref++ = (x << 4) | y;
3119     }
3120   return inbuf;
3121 }
3122
3123 /* Externally, threadrefs are 64 bits but internally, they are still
3124    ints.  This is due to a mismatch of specifications.  We would like
3125    to use 64bit thread references internally.  This is an adapter
3126    function.  */
3127
3128 void
3129 int_to_threadref (threadref *id, int value)
3130 {
3131   unsigned char *scan;
3132
3133   scan = (unsigned char *) id;
3134   {
3135     int i = 4;
3136     while (i--)
3137       *scan++ = 0;
3138   }
3139   *scan++ = (value >> 24) & 0xff;
3140   *scan++ = (value >> 16) & 0xff;
3141   *scan++ = (value >> 8) & 0xff;
3142   *scan++ = (value & 0xff);
3143 }
3144
3145 static int
3146 threadref_to_int (threadref *ref)
3147 {
3148   int i, value = 0;
3149   unsigned char *scan;
3150
3151   scan = *ref;
3152   scan += 4;
3153   i = 4;
3154   while (i-- > 0)
3155     value = (value << 8) | ((*scan++) & 0xff);
3156   return value;
3157 }
3158
3159 static void
3160 copy_threadref (threadref *dest, threadref *src)
3161 {
3162   int i;
3163   unsigned char *csrc, *cdest;
3164
3165   csrc = (unsigned char *) src;
3166   cdest = (unsigned char *) dest;
3167   i = 8;
3168   while (i--)
3169     *cdest++ = *csrc++;
3170 }
3171
3172 static int
3173 threadmatch (threadref *dest, threadref *src)
3174 {
3175   /* Things are broken right now, so just assume we got a match.  */
3176 #if 0
3177   unsigned char *srcp, *destp;
3178   int i, result;
3179   srcp = (char *) src;
3180   destp = (char *) dest;
3181
3182   result = 1;
3183   while (i-- > 0)
3184     result &= (*srcp++ == *destp++) ? 1 : 0;
3185   return result;
3186 #endif
3187   return 1;
3188 }
3189
3190 /*
3191    threadid:1,        # always request threadid
3192    context_exists:2,
3193    display:4,
3194    unique_name:8,
3195    more_display:16
3196  */
3197
3198 /* Encoding:  'Q':8,'P':8,mask:32,threadid:64 */
3199
3200 static char *
3201 pack_threadinfo_request (char *pkt, int mode, threadref *id)
3202 {
3203   *pkt++ = 'q';                         /* Info Query */
3204   *pkt++ = 'P';                         /* process or thread info */
3205   pkt = pack_int (pkt, mode);           /* mode */
3206   pkt = pack_threadid (pkt, id);        /* threadid */
3207   *pkt = '\0';                          /* terminate */
3208   return pkt;
3209 }
3210
3211 /* These values tag the fields in a thread info response packet.  */
3212 /* Tagging the fields allows us to request specific fields and to
3213    add more fields as time goes by.  */
3214
3215 #define TAG_THREADID 1          /* Echo the thread identifier.  */
3216 #define TAG_EXISTS 2            /* Is this process defined enough to
3217                                    fetch registers and its stack?  */
3218 #define TAG_DISPLAY 4           /* A short thing maybe to put on a window */
3219 #define TAG_THREADNAME 8        /* string, maps 1-to-1 with a thread is.  */
3220 #define TAG_MOREDISPLAY 16      /* Whatever the kernel wants to say about
3221                                    the process.  */
3222
3223 int
3224 remote_target::remote_unpack_thread_info_response (char *pkt,
3225                                                    threadref *expectedref,
3226                                                    gdb_ext_thread_info *info)
3227 {
3228   struct remote_state *rs = get_remote_state ();
3229   int mask, length;
3230   int tag;
3231   threadref ref;
3232   char *limit = pkt + rs->buf.size (); /* Plausible parsing limit.  */
3233   int retval = 1;
3234
3235   /* info->threadid = 0; FIXME: implement zero_threadref.  */
3236   info->active = 0;
3237   info->display[0] = '\0';
3238   info->shortname[0] = '\0';
3239   info->more_display[0] = '\0';
3240
3241   /* Assume the characters indicating the packet type have been
3242      stripped.  */
3243   pkt = unpack_int (pkt, &mask);        /* arg mask */
3244   pkt = unpack_threadid (pkt, &ref);
3245
3246   if (mask == 0)
3247     warning (_("Incomplete response to threadinfo request."));
3248   if (!threadmatch (&ref, expectedref))
3249     {                   /* This is an answer to a different request.  */
3250       warning (_("ERROR RMT Thread info mismatch."));
3251       return 0;
3252     }
3253   copy_threadref (&info->threadid, &ref);
3254
3255   /* Loop on tagged fields , try to bail if somthing goes wrong.  */
3256
3257   /* Packets are terminated with nulls.  */
3258   while ((pkt < limit) && mask && *pkt)
3259     {
3260       pkt = unpack_int (pkt, &tag);     /* tag */
3261       pkt = unpack_byte (pkt, &length); /* length */
3262       if (!(tag & mask))                /* Tags out of synch with mask.  */
3263         {
3264           warning (_("ERROR RMT: threadinfo tag mismatch."));
3265           retval = 0;
3266           break;
3267         }
3268       if (tag == TAG_THREADID)
3269         {
3270           if (length != 16)
3271             {
3272               warning (_("ERROR RMT: length of threadid is not 16."));
3273               retval = 0;
3274               break;
3275             }
3276           pkt = unpack_threadid (pkt, &ref);
3277           mask = mask & ~TAG_THREADID;
3278           continue;
3279         }
3280       if (tag == TAG_EXISTS)
3281         {
3282           info->active = stub_unpack_int (pkt, length);
3283           pkt += length;
3284           mask = mask & ~(TAG_EXISTS);
3285           if (length > 8)
3286             {
3287               warning (_("ERROR RMT: 'exists' length too long."));
3288               retval = 0;
3289               break;
3290             }
3291           continue;
3292         }
3293       if (tag == TAG_THREADNAME)
3294         {
3295           pkt = unpack_string (pkt, &info->shortname[0], length);
3296           mask = mask & ~TAG_THREADNAME;
3297           continue;
3298         }
3299       if (tag == TAG_DISPLAY)
3300         {
3301           pkt = unpack_string (pkt, &info->display[0], length);
3302           mask = mask & ~TAG_DISPLAY;
3303           continue;
3304         }
3305       if (tag == TAG_MOREDISPLAY)
3306         {
3307           pkt = unpack_string (pkt, &info->more_display[0], length);
3308           mask = mask & ~TAG_MOREDISPLAY;
3309           continue;
3310         }
3311       warning (_("ERROR RMT: unknown thread info tag."));
3312       break;                    /* Not a tag we know about.  */
3313     }
3314   return retval;
3315 }
3316
3317 int
3318 remote_target::remote_get_threadinfo (threadref *threadid,
3319                                       int fieldset,
3320                                       gdb_ext_thread_info *info)
3321 {
3322   struct remote_state *rs = get_remote_state ();
3323   int result;
3324
3325   pack_threadinfo_request (rs->buf.data (), fieldset, threadid);
3326   putpkt (rs->buf);
3327   getpkt (&rs->buf, 0);
3328
3329   if (rs->buf[0] == '\0')
3330     return 0;
3331
3332   result = remote_unpack_thread_info_response (&rs->buf[2],
3333                                                threadid, info);
3334   return result;
3335 }
3336
3337 /*    Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32   */
3338
3339 static char *
3340 pack_threadlist_request (char *pkt, int startflag, int threadcount,
3341                          threadref *nextthread)
3342 {
3343   *pkt++ = 'q';                 /* info query packet */
3344   *pkt++ = 'L';                 /* Process LIST or threadLIST request */
3345   pkt = pack_nibble (pkt, startflag);           /* initflag 1 bytes */
3346   pkt = pack_hex_byte (pkt, threadcount);       /* threadcount 2 bytes */
3347   pkt = pack_threadid (pkt, nextthread);        /* 64 bit thread identifier */
3348   *pkt = '\0';
3349   return pkt;
3350 }
3351
3352 /* Encoding:   'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
3353
3354 int
3355 remote_target::parse_threadlist_response (char *pkt, int result_limit,
3356                                           threadref *original_echo,
3357                                           threadref *resultlist,
3358                                           int *doneflag)
3359 {
3360   struct remote_state *rs = get_remote_state ();
3361   char *limit;
3362   int count, resultcount, done;
3363
3364   resultcount = 0;
3365   /* Assume the 'q' and 'M chars have been stripped.  */
3366   limit = pkt + (rs->buf.size () - BUF_THREAD_ID_SIZE);
3367   /* done parse past here */
3368   pkt = unpack_byte (pkt, &count);      /* count field */
3369   pkt = unpack_nibble (pkt, &done);
3370   /* The first threadid is the argument threadid.  */
3371   pkt = unpack_threadid (pkt, original_echo);   /* should match query packet */
3372   while ((count-- > 0) && (pkt < limit))
3373     {
3374       pkt = unpack_threadid (pkt, resultlist++);
3375       if (resultcount++ >= result_limit)
3376         break;
3377     }
3378   if (doneflag)
3379     *doneflag = done;
3380   return resultcount;
3381 }
3382
3383 /* Fetch the next batch of threads from the remote.  Returns -1 if the
3384    qL packet is not supported, 0 on error and 1 on success.  */
3385
3386 int
3387 remote_target::remote_get_threadlist (int startflag, threadref *nextthread,
3388                                       int result_limit, int *done, int *result_count,
3389                                       threadref *threadlist)
3390 {
3391   struct remote_state *rs = get_remote_state ();
3392   int result = 1;
3393
3394   /* Trancate result limit to be smaller than the packet size.  */
3395   if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
3396       >= get_remote_packet_size ())
3397     result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
3398
3399   pack_threadlist_request (rs->buf.data (), startflag, result_limit,
3400                            nextthread);
3401   putpkt (rs->buf);
3402   getpkt (&rs->buf, 0);
3403   if (rs->buf[0] == '\0')
3404     {
3405       /* Packet not supported.  */
3406       return -1;
3407     }
3408
3409   *result_count =
3410     parse_threadlist_response (&rs->buf[2], result_limit,
3411                                &rs->echo_nextthread, threadlist, done);
3412
3413   if (!threadmatch (&rs->echo_nextthread, nextthread))
3414     {
3415       /* FIXME: This is a good reason to drop the packet.  */
3416       /* Possably, there is a duplicate response.  */
3417       /* Possabilities :
3418          retransmit immediatly - race conditions
3419          retransmit after timeout - yes
3420          exit
3421          wait for packet, then exit
3422        */
3423       warning (_("HMM: threadlist did not echo arg thread, dropping it."));
3424       return 0;                 /* I choose simply exiting.  */
3425     }
3426   if (*result_count <= 0)
3427     {
3428       if (*done != 1)
3429         {
3430           warning (_("RMT ERROR : failed to get remote thread list."));
3431           result = 0;
3432         }
3433       return result;            /* break; */
3434     }
3435   if (*result_count > result_limit)
3436     {
3437       *result_count = 0;
3438       warning (_("RMT ERROR: threadlist response longer than requested."));
3439       return 0;
3440     }
3441   return result;
3442 }
3443
3444 /* Fetch the list of remote threads, with the qL packet, and call
3445    STEPFUNCTION for each thread found.  Stops iterating and returns 1
3446    if STEPFUNCTION returns true.  Stops iterating and returns 0 if the
3447    STEPFUNCTION returns false.  If the packet is not supported,
3448    returns -1.  */
3449
3450 int
3451 remote_target::remote_threadlist_iterator (rmt_thread_action stepfunction,
3452                                            void *context, int looplimit)
3453 {
3454   struct remote_state *rs = get_remote_state ();
3455   int done, i, result_count;
3456   int startflag = 1;
3457   int result = 1;
3458   int loopcount = 0;
3459
3460   done = 0;
3461   while (!done)
3462     {
3463       if (loopcount++ > looplimit)
3464         {
3465           result = 0;
3466           warning (_("Remote fetch threadlist -infinite loop-."));
3467           break;
3468         }
3469       result = remote_get_threadlist (startflag, &rs->nextthread,
3470                                       MAXTHREADLISTRESULTS,
3471                                       &done, &result_count,
3472                                       rs->resultthreadlist);
3473       if (result <= 0)
3474         break;
3475       /* Clear for later iterations.  */
3476       startflag = 0;
3477       /* Setup to resume next batch of thread references, set nextthread.  */
3478       if (result_count >= 1)
3479         copy_threadref (&rs->nextthread,
3480                         &rs->resultthreadlist[result_count - 1]);
3481       i = 0;
3482       while (result_count--)
3483         {
3484           if (!(*stepfunction) (&rs->resultthreadlist[i++], context))
3485             {
3486               result = 0;
3487               break;
3488             }
3489         }
3490     }
3491   return result;
3492 }
3493
3494 /* A thread found on the remote target.  */
3495
3496 struct thread_item
3497 {
3498   explicit thread_item (ptid_t ptid_)
3499   : ptid (ptid_)
3500   {}
3501
3502   thread_item (thread_item &&other) = default;
3503   thread_item &operator= (thread_item &&other) = default;
3504
3505   DISABLE_COPY_AND_ASSIGN (thread_item);
3506
3507   /* The thread's PTID.  */
3508   ptid_t ptid;
3509
3510   /* The thread's extra info.  */
3511   std::string extra;
3512
3513   /* The thread's name.  */
3514   std::string name;
3515
3516   /* The core the thread was running on.  -1 if not known.  */
3517   int core = -1;
3518
3519   /* The thread handle associated with the thread.  */
3520   gdb::byte_vector thread_handle;
3521 };
3522
3523 /* Context passed around to the various methods listing remote
3524    threads.  As new threads are found, they're added to the ITEMS
3525    vector.  */
3526
3527 struct threads_listing_context
3528 {
3529   /* Return true if this object contains an entry for a thread with ptid
3530      PTID.  */
3531
3532   bool contains_thread (ptid_t ptid) const
3533   {
3534     auto match_ptid = [&] (const thread_item &item)
3535       {
3536         return item.ptid == ptid;
3537       };
3538
3539     auto it = std::find_if (this->items.begin (),
3540                             this->items.end (),
3541                             match_ptid);
3542
3543     return it != this->items.end ();
3544   }
3545
3546   /* Remove the thread with ptid PTID.  */
3547
3548   void remove_thread (ptid_t ptid)
3549   {
3550     auto match_ptid = [&] (const thread_item &item)
3551       {
3552         return item.ptid == ptid;
3553       };
3554
3555     auto it = std::remove_if (this->items.begin (),
3556                               this->items.end (),
3557                               match_ptid);
3558
3559     if (it != this->items.end ())
3560       this->items.erase (it);
3561   }
3562
3563   /* The threads found on the remote target.  */
3564   std::vector<thread_item> items;
3565 };
3566
3567 static int
3568 remote_newthread_step (threadref *ref, void *data)
3569 {
3570   struct threads_listing_context *context
3571     = (struct threads_listing_context *) data;
3572   int pid = inferior_ptid.pid ();
3573   int lwp = threadref_to_int (ref);
3574   ptid_t ptid (pid, lwp);
3575
3576   context->items.emplace_back (ptid);
3577
3578   return 1;                     /* continue iterator */
3579 }
3580
3581 #define CRAZY_MAX_THREADS 1000
3582
3583 ptid_t
3584 remote_target::remote_current_thread (ptid_t oldpid)
3585 {
3586   struct remote_state *rs = get_remote_state ();
3587
3588   putpkt ("qC");
3589   getpkt (&rs->buf, 0);
3590   if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
3591     {
3592       const char *obuf;
3593       ptid_t result;
3594
3595       result = read_ptid (&rs->buf[2], &obuf);
3596       if (*obuf != '\0' && remote_debug)
3597         fprintf_unfiltered (gdb_stdlog,
3598                             "warning: garbage in qC reply\n");
3599
3600       return result;
3601     }
3602   else
3603     return oldpid;
3604 }
3605
3606 /* List remote threads using the deprecated qL packet.  */
3607
3608 int
3609 remote_target::remote_get_threads_with_ql (threads_listing_context *context)
3610 {
3611   if (remote_threadlist_iterator (remote_newthread_step, context,
3612                                   CRAZY_MAX_THREADS) >= 0)
3613     return 1;
3614
3615   return 0;
3616 }
3617
3618 #if defined(HAVE_LIBEXPAT)
3619
3620 static void
3621 start_thread (struct gdb_xml_parser *parser,
3622               const struct gdb_xml_element *element,
3623               void *user_data,
3624               std::vector<gdb_xml_value> &attributes)
3625 {
3626   struct threads_listing_context *data
3627     = (struct threads_listing_context *) user_data;
3628   struct gdb_xml_value *attr;
3629
3630   char *id = (char *) xml_find_attribute (attributes, "id")->value.get ();
3631   ptid_t ptid = read_ptid (id, NULL);
3632
3633   data->items.emplace_back (ptid);
3634   thread_item &item = data->items.back ();
3635
3636   attr = xml_find_attribute (attributes, "core");
3637   if (attr != NULL)
3638     item.core = *(ULONGEST *) attr->value.get ();
3639
3640   attr = xml_find_attribute (attributes, "name");
3641   if (attr != NULL)
3642     item.name = (const char *) attr->value.get ();
3643
3644   attr = xml_find_attribute (attributes, "handle");
3645   if (attr != NULL)
3646     item.thread_handle = hex2bin ((const char *) attr->value.get ());
3647 }
3648
3649 static void
3650 end_thread (struct gdb_xml_parser *parser,
3651             const struct gdb_xml_element *element,
3652             void *user_data, const char *body_text)
3653 {
3654   struct threads_listing_context *data
3655     = (struct threads_listing_context *) user_data;
3656
3657   if (body_text != NULL && *body_text != '\0')
3658     data->items.back ().extra = body_text;
3659 }
3660
3661 const struct gdb_xml_attribute thread_attributes[] = {
3662   { "id", GDB_XML_AF_NONE, NULL, NULL },
3663   { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
3664   { "name", GDB_XML_AF_OPTIONAL, NULL, NULL },
3665   { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL },
3666   { NULL, GDB_XML_AF_NONE, NULL, NULL }
3667 };
3668
3669 const struct gdb_xml_element thread_children[] = {
3670   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3671 };
3672
3673 const struct gdb_xml_element threads_children[] = {
3674   { "thread", thread_attributes, thread_children,
3675     GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3676     start_thread, end_thread },
3677   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3678 };
3679
3680 const struct gdb_xml_element threads_elements[] = {
3681   { "threads", NULL, threads_children,
3682     GDB_XML_EF_NONE, NULL, NULL },
3683   { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3684 };
3685
3686 #endif
3687
3688 /* List remote threads using qXfer:threads:read.  */
3689
3690 int
3691 remote_target::remote_get_threads_with_qxfer (threads_listing_context *context)
3692 {
3693 #if defined(HAVE_LIBEXPAT)
3694   if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3695     {
3696       gdb::optional<gdb::char_vector> xml
3697         = target_read_stralloc (this, TARGET_OBJECT_THREADS, NULL);
3698
3699       if (xml && (*xml)[0] != '\0')
3700         {
3701           gdb_xml_parse_quick (_("threads"), "threads.dtd",
3702                                threads_elements, xml->data (), context);
3703         }
3704
3705       return 1;
3706     }
3707 #endif
3708
3709   return 0;
3710 }
3711
3712 /* List remote threads using qfThreadInfo/qsThreadInfo.  */
3713
3714 int
3715 remote_target::remote_get_threads_with_qthreadinfo (threads_listing_context *context)
3716 {
3717   struct remote_state *rs = get_remote_state ();
3718
3719   if (rs->use_threadinfo_query)
3720     {
3721       const char *bufp;
3722
3723       putpkt ("qfThreadInfo");
3724       getpkt (&rs->buf, 0);
3725       bufp = rs->buf.data ();
3726       if (bufp[0] != '\0')              /* q packet recognized */
3727         {
3728           while (*bufp++ == 'm')        /* reply contains one or more TID */
3729             {
3730               do
3731                 {
3732                   ptid_t ptid = read_ptid (bufp, &bufp);
3733                   context->items.emplace_back (ptid);
3734                 }
3735               while (*bufp++ == ',');   /* comma-separated list */
3736               putpkt ("qsThreadInfo");
3737               getpkt (&rs->buf, 0);
3738               bufp = rs->buf.data ();
3739             }
3740           return 1;
3741         }
3742       else
3743         {
3744           /* Packet not recognized.  */
3745           rs->use_threadinfo_query = 0;
3746         }
3747     }
3748
3749   return 0;
3750 }
3751
3752 /* Implement the to_update_thread_list function for the remote
3753    targets.  */
3754
3755 void
3756 remote_target::update_thread_list ()
3757 {
3758   struct threads_listing_context context;
3759   int got_list = 0;
3760
3761   /* We have a few different mechanisms to fetch the thread list.  Try
3762      them all, starting with the most preferred one first, falling
3763      back to older methods.  */
3764   if (remote_get_threads_with_qxfer (&context)
3765       || remote_get_threads_with_qthreadinfo (&context)
3766       || remote_get_threads_with_ql (&context))
3767     {
3768       got_list = 1;
3769
3770       if (context.items.empty ()
3771           && remote_thread_always_alive (inferior_ptid))
3772         {
3773           /* Some targets don't really support threads, but still
3774              reply an (empty) thread list in response to the thread
3775              listing packets, instead of replying "packet not
3776              supported".  Exit early so we don't delete the main
3777              thread.  */
3778           return;
3779         }
3780
3781       /* CONTEXT now holds the current thread list on the remote
3782          target end.  Delete GDB-side threads no longer found on the
3783          target.  */
3784       for (thread_info *tp : all_threads_safe ())
3785         {
3786           if (!context.contains_thread (tp->ptid))
3787             {
3788               /* Not found.  */
3789               delete_thread (tp);
3790             }
3791         }
3792
3793       /* Remove any unreported fork child threads from CONTEXT so
3794          that we don't interfere with follow fork, which is where
3795          creation of such threads is handled.  */
3796       remove_new_fork_children (&context);
3797
3798       /* And now add threads we don't know about yet to our list.  */
3799       for (thread_item &item : context.items)
3800         {
3801           if (item.ptid != null_ptid)
3802             {
3803               /* In non-stop mode, we assume new found threads are
3804                  executing until proven otherwise with a stop reply.
3805                  In all-stop, we can only get here if all threads are
3806                  stopped.  */
3807               int executing = target_is_non_stop_p () ? 1 : 0;
3808
3809               remote_notice_new_inferior (item.ptid, executing);
3810
3811               thread_info *tp = find_thread_ptid (item.ptid);
3812               remote_thread_info *info = get_remote_thread_info (tp);
3813               info->core = item.core;
3814               info->extra = std::move (item.extra);
3815               info->name = std::move (item.name);
3816               info->thread_handle = std::move (item.thread_handle);
3817             }
3818         }
3819     }
3820
3821   if (!got_list)
3822     {
3823       /* If no thread listing method is supported, then query whether
3824          each known thread is alive, one by one, with the T packet.
3825          If the target doesn't support threads at all, then this is a
3826          no-op.  See remote_thread_alive.  */
3827       prune_threads ();
3828     }
3829 }
3830
3831 /*
3832  * Collect a descriptive string about the given thread.
3833  * The target may say anything it wants to about the thread
3834  * (typically info about its blocked / runnable state, name, etc.).
3835  * This string will appear in the info threads display.
3836  *
3837  * Optional: targets are not required to implement this function.
3838  */
3839
3840 const char *
3841 remote_target::extra_thread_info (thread_info *tp)
3842 {
3843   struct remote_state *rs = get_remote_state ();
3844   int set;
3845   threadref id;
3846   struct gdb_ext_thread_info threadinfo;
3847
3848   if (rs->remote_desc == 0)             /* paranoia */
3849     internal_error (__FILE__, __LINE__,
3850                     _("remote_threads_extra_info"));
3851
3852   if (tp->ptid == magic_null_ptid
3853       || (tp->ptid.pid () != 0 && tp->ptid.lwp () == 0))
3854     /* This is the main thread which was added by GDB.  The remote
3855        server doesn't know about it.  */
3856     return NULL;
3857
3858   std::string &extra = get_remote_thread_info (tp)->extra;
3859
3860   /* If already have cached info, use it.  */
3861   if (!extra.empty ())
3862     return extra.c_str ();
3863
3864   if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3865     {
3866       /* If we're using qXfer:threads:read, then the extra info is
3867          included in the XML.  So if we didn't have anything cached,
3868          it's because there's really no extra info.  */
3869       return NULL;
3870     }
3871
3872   if (rs->use_threadextra_query)
3873     {
3874       char *b = rs->buf.data ();
3875       char *endb = b + get_remote_packet_size ();
3876
3877       xsnprintf (b, endb - b, "qThreadExtraInfo,");
3878       b += strlen (b);
3879       write_ptid (b, endb, tp->ptid);
3880
3881       putpkt (rs->buf);
3882       getpkt (&rs->buf, 0);
3883       if (rs->buf[0] != 0)
3884         {
3885           extra.resize (strlen (rs->buf.data ()) / 2);
3886           hex2bin (rs->buf.data (), (gdb_byte *) &extra[0], extra.size ());
3887           return extra.c_str ();
3888         }
3889     }
3890
3891   /* If the above query fails, fall back to the old method.  */
3892   rs->use_threadextra_query = 0;
3893   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3894     | TAG_MOREDISPLAY | TAG_DISPLAY;
3895   int_to_threadref (&id, tp->ptid.lwp ());
3896   if (remote_get_threadinfo (&id, set, &threadinfo))
3897     if (threadinfo.active)
3898       {
3899         if (*threadinfo.shortname)
3900           string_appendf (extra, " Name: %s", threadinfo.shortname);
3901         if (*threadinfo.display)
3902           {
3903             if (!extra.empty ())
3904               extra += ',';
3905             string_appendf (extra, " State: %s", threadinfo.display);
3906           }
3907         if (*threadinfo.more_display)
3908           {
3909             if (!extra.empty ())
3910               extra += ',';
3911             string_appendf (extra, " Priority: %s", threadinfo.more_display);
3912           }
3913         return extra.c_str ();
3914       }
3915   return NULL;
3916 }
3917 \f
3918
3919 bool
3920 remote_target::static_tracepoint_marker_at (CORE_ADDR addr,
3921                                             struct static_tracepoint_marker *marker)
3922 {
3923   struct remote_state *rs = get_remote_state ();
3924   char *p = rs->buf.data ();
3925
3926   xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
3927   p += strlen (p);
3928   p += hexnumstr (p, addr);
3929   putpkt (rs->buf);
3930   getpkt (&rs->buf, 0);
3931   p = rs->buf.data ();
3932
3933   if (*p == 'E')
3934     error (_("Remote failure reply: %s"), p);
3935
3936   if (*p++ == 'm')
3937     {
3938       parse_static_tracepoint_marker_definition (p, NULL, marker);
3939       return true;
3940     }
3941
3942   return false;
3943 }
3944
3945 std::vector<static_tracepoint_marker>
3946 remote_target::static_tracepoint_markers_by_strid (const char *strid)
3947 {
3948   struct remote_state *rs = get_remote_state ();
3949   std::vector<static_tracepoint_marker> markers;
3950   const char *p;
3951   static_tracepoint_marker marker;
3952
3953   /* Ask for a first packet of static tracepoint marker
3954      definition.  */
3955   putpkt ("qTfSTM");
3956   getpkt (&rs->buf, 0);
3957   p = rs->buf.data ();
3958   if (*p == 'E')
3959     error (_("Remote failure reply: %s"), p);
3960
3961   while (*p++ == 'm')
3962     {
3963       do
3964         {
3965           parse_static_tracepoint_marker_definition (p, &p, &marker);
3966
3967           if (strid == NULL || marker.str_id == strid)
3968             markers.push_back (std::move (marker));
3969         }
3970       while (*p++ == ',');      /* comma-separated list */
3971       /* Ask for another packet of static tracepoint definition.  */
3972       putpkt ("qTsSTM");
3973       getpkt (&rs->buf, 0);
3974       p = rs->buf.data ();
3975     }
3976
3977   return markers;
3978 }
3979
3980 \f
3981 /* Implement the to_get_ada_task_ptid function for the remote targets.  */
3982
3983 ptid_t
3984 remote_target::get_ada_task_ptid (long lwp, long thread)
3985 {
3986   return ptid_t (inferior_ptid.pid (), lwp, 0);
3987 }
3988 \f
3989
3990 /* Restart the remote side; this is an extended protocol operation.  */
3991
3992 void
3993 remote_target::extended_remote_restart ()
3994 {
3995   struct remote_state *rs = get_remote_state ();
3996
3997   /* Send the restart command; for reasons I don't understand the
3998      remote side really expects a number after the "R".  */
3999   xsnprintf (rs->buf.data (), get_remote_packet_size (), "R%x", 0);
4000   putpkt (rs->buf);
4001
4002   remote_fileio_reset ();
4003 }
4004 \f
4005 /* Clean up connection to a remote debugger.  */
4006
4007 void
4008 remote_target::close ()
4009 {
4010   /* Make sure we leave stdin registered in the event loop.  */
4011   terminal_ours ();
4012
4013   /* We don't have a connection to the remote stub anymore.  Get rid
4014      of all the inferiors and their threads we were controlling.
4015      Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
4016      will be unable to find the thread corresponding to (pid, 0, 0).  */
4017   inferior_ptid = null_ptid;
4018   discard_all_inferiors ();
4019
4020   trace_reset_local_state ();
4021
4022   delete this;
4023 }
4024
4025 remote_target::~remote_target ()
4026 {
4027   struct remote_state *rs = get_remote_state ();
4028
4029   /* Check for NULL because we may get here with a partially
4030      constructed target/connection.  */
4031   if (rs->remote_desc == nullptr)
4032     return;
4033
4034   serial_close (rs->remote_desc);
4035
4036   /* We are destroying the remote target, so we should discard
4037      everything of this target.  */
4038   discard_pending_stop_replies_in_queue ();
4039
4040   if (rs->remote_async_inferior_event_token)
4041     delete_async_event_handler (&rs->remote_async_inferior_event_token);
4042
4043   delete rs->notif_state;
4044 }
4045
4046 /* Query the remote side for the text, data and bss offsets.  */
4047
4048 void
4049 remote_target::get_offsets ()
4050 {
4051   struct remote_state *rs = get_remote_state ();
4052   char *buf;
4053   char *ptr;
4054   int lose, num_segments = 0, do_sections, do_segments;
4055   CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
4056   struct section_offsets *offs;
4057   struct symfile_segment_data *data;
4058
4059   if (symfile_objfile == NULL)
4060     return;
4061
4062   putpkt ("qOffsets");
4063   getpkt (&rs->buf, 0);
4064   buf = rs->buf.data ();
4065
4066   if (buf[0] == '\000')
4067     return;                     /* Return silently.  Stub doesn't support
4068                                    this command.  */
4069   if (buf[0] == 'E')
4070     {
4071       warning (_("Remote failure reply: %s"), buf);
4072       return;
4073     }
4074
4075   /* Pick up each field in turn.  This used to be done with scanf, but
4076      scanf will make trouble if CORE_ADDR size doesn't match
4077      conversion directives correctly.  The following code will work
4078      with any size of CORE_ADDR.  */
4079   text_addr = data_addr = bss_addr = 0;
4080   ptr = buf;
4081   lose = 0;
4082
4083   if (startswith (ptr, "Text="))
4084     {
4085       ptr += 5;
4086       /* Don't use strtol, could lose on big values.  */
4087       while (*ptr && *ptr != ';')
4088         text_addr = (text_addr << 4) + fromhex (*ptr++);
4089
4090       if (startswith (ptr, ";Data="))
4091         {
4092           ptr += 6;
4093           while (*ptr && *ptr != ';')
4094             data_addr = (data_addr << 4) + fromhex (*ptr++);
4095         }
4096       else
4097         lose = 1;
4098
4099       if (!lose && startswith (ptr, ";Bss="))
4100         {
4101           ptr += 5;
4102           while (*ptr && *ptr != ';')
4103             bss_addr = (bss_addr << 4) + fromhex (*ptr++);
4104
4105           if (bss_addr != data_addr)
4106             warning (_("Target reported unsupported offsets: %s"), buf);
4107         }
4108       else
4109         lose = 1;
4110     }
4111   else if (startswith (ptr, "TextSeg="))
4112     {
4113       ptr += 8;
4114       /* Don't use strtol, could lose on big values.  */
4115       while (*ptr && *ptr != ';')
4116         text_addr = (text_addr << 4) + fromhex (*ptr++);
4117       num_segments = 1;
4118
4119       if (startswith (ptr, ";DataSeg="))
4120         {
4121           ptr += 9;
4122           while (*ptr && *ptr != ';')
4123             data_addr = (data_addr << 4) + fromhex (*ptr++);
4124           num_segments++;
4125         }
4126     }
4127   else
4128     lose = 1;
4129
4130   if (lose)
4131     error (_("Malformed response to offset query, %s"), buf);
4132   else if (*ptr != '\0')
4133     warning (_("Target reported unsupported offsets: %s"), buf);
4134
4135   offs = ((struct section_offsets *)
4136           alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
4137   memcpy (offs, symfile_objfile->section_offsets,
4138           SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
4139
4140   data = get_symfile_segment_data (symfile_objfile->obfd);
4141   do_segments = (data != NULL);
4142   do_sections = num_segments == 0;
4143
4144   if (num_segments > 0)
4145     {
4146       segments[0] = text_addr;
4147       segments[1] = data_addr;
4148     }
4149   /* If we have two segments, we can still try to relocate everything
4150      by assuming that the .text and .data offsets apply to the whole
4151      text and data segments.  Convert the offsets given in the packet
4152      to base addresses for symfile_map_offsets_to_segments.  */
4153   else if (data && data->num_segments == 2)
4154     {
4155       segments[0] = data->segment_bases[0] + text_addr;
4156       segments[1] = data->segment_bases[1] + data_addr;
4157       num_segments = 2;
4158     }
4159   /* If the object file has only one segment, assume that it is text
4160      rather than data; main programs with no writable data are rare,
4161      but programs with no code are useless.  Of course the code might
4162      have ended up in the data segment... to detect that we would need
4163      the permissions here.  */
4164   else if (data && data->num_segments == 1)
4165     {
4166       segments[0] = data->segment_bases[0] + text_addr;
4167       num_segments = 1;
4168     }
4169   /* There's no way to relocate by segment.  */
4170   else
4171     do_segments = 0;
4172
4173   if (do_segments)
4174     {
4175       int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
4176                                                  offs, num_segments, segments);
4177
4178       if (ret == 0 && !do_sections)
4179         error (_("Can not handle qOffsets TextSeg "
4180                  "response with this symbol file"));
4181
4182       if (ret > 0)
4183         do_sections = 0;
4184     }
4185
4186   if (data)
4187     free_symfile_segment_data (data);
4188
4189   if (do_sections)
4190     {
4191       offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
4192
4193       /* This is a temporary kludge to force data and bss to use the
4194          same offsets because that's what nlmconv does now.  The real
4195          solution requires changes to the stub and remote.c that I
4196          don't have time to do right now.  */
4197
4198       offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
4199       offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
4200     }
4201
4202   objfile_relocate (symfile_objfile, offs);
4203 }
4204
4205 /* Send interrupt_sequence to remote target.  */
4206
4207 void
4208 remote_target::send_interrupt_sequence ()
4209 {
4210   struct remote_state *rs = get_remote_state ();
4211
4212   if (interrupt_sequence_mode == interrupt_sequence_control_c)
4213     remote_serial_write ("\x03", 1);
4214   else if (interrupt_sequence_mode == interrupt_sequence_break)
4215     serial_send_break (rs->remote_desc);
4216   else if (interrupt_sequence_mode == interrupt_sequence_break_g)
4217     {
4218       serial_send_break (rs->remote_desc);
4219       remote_serial_write ("g", 1);
4220     }
4221   else
4222     internal_error (__FILE__, __LINE__,
4223                     _("Invalid value for interrupt_sequence_mode: %s."),
4224                     interrupt_sequence_mode);
4225 }
4226
4227
4228 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
4229    and extract the PTID.  Returns NULL_PTID if not found.  */
4230
4231 static ptid_t
4232 stop_reply_extract_thread (char *stop_reply)
4233 {
4234   if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
4235     {
4236       const char *p;
4237
4238       /* Txx r:val ; r:val (...)  */
4239       p = &stop_reply[3];
4240
4241       /* Look for "register" named "thread".  */
4242       while (*p != '\0')
4243         {
4244           const char *p1;
4245
4246           p1 = strchr (p, ':');
4247           if (p1 == NULL)
4248             return null_ptid;
4249
4250           if (strncmp (p, "thread", p1 - p) == 0)
4251             return read_ptid (++p1, &p);
4252
4253           p1 = strchr (p, ';');
4254           if (p1 == NULL)
4255             return null_ptid;
4256           p1++;
4257
4258           p = p1;
4259         }
4260     }
4261
4262   return null_ptid;
4263 }
4264
4265 /* Determine the remote side's current thread.  If we have a stop
4266    reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
4267    "thread" register we can extract the current thread from.  If not,
4268    ask the remote which is the current thread with qC.  The former
4269    method avoids a roundtrip.  */
4270
4271 ptid_t
4272 remote_target::get_current_thread (char *wait_status)
4273 {
4274   ptid_t ptid = null_ptid;
4275
4276   /* Note we don't use remote_parse_stop_reply as that makes use of
4277      the target architecture, which we haven't yet fully determined at
4278      this point.  */
4279   if (wait_status != NULL)
4280     ptid = stop_reply_extract_thread (wait_status);
4281   if (ptid == null_ptid)
4282     ptid = remote_current_thread (inferior_ptid);
4283
4284   return ptid;
4285 }
4286
4287 /* Query the remote target for which is the current thread/process,
4288    add it to our tables, and update INFERIOR_PTID.  The caller is
4289    responsible for setting the state such that the remote end is ready
4290    to return the current thread.
4291
4292    This function is called after handling the '?' or 'vRun' packets,
4293    whose response is a stop reply from which we can also try
4294    extracting the thread.  If the target doesn't support the explicit
4295    qC query, we infer the current thread from that stop reply, passed
4296    in in WAIT_STATUS, which may be NULL.  */
4297
4298 void
4299 remote_target::add_current_inferior_and_thread (char *wait_status)
4300 {
4301   struct remote_state *rs = get_remote_state ();
4302   bool fake_pid_p = false;
4303
4304   inferior_ptid = null_ptid;
4305
4306   /* Now, if we have thread information, update inferior_ptid.  */
4307   ptid_t curr_ptid = get_current_thread (wait_status);
4308
4309   if (curr_ptid != null_ptid)
4310     {
4311       if (!remote_multi_process_p (rs))
4312         fake_pid_p = true;
4313     }
4314   else
4315     {
4316       /* Without this, some commands which require an active target
4317          (such as kill) won't work.  This variable serves (at least)
4318          double duty as both the pid of the target process (if it has
4319          such), and as a flag indicating that a target is active.  */
4320       curr_ptid = magic_null_ptid;
4321       fake_pid_p = true;
4322     }
4323
4324   remote_add_inferior (fake_pid_p, curr_ptid.pid (), -1, 1);
4325
4326   /* Add the main thread and switch to it.  Don't try reading
4327      registers yet, since we haven't fetched the target description
4328      yet.  */
4329   thread_info *tp = add_thread_silent (curr_ptid);
4330   switch_to_thread_no_regs (tp);
4331 }
4332
4333 /* Print info about a thread that was found already stopped on
4334    connection.  */
4335
4336 static void
4337 print_one_stopped_thread (struct thread_info *thread)
4338 {
4339   struct target_waitstatus *ws = &thread->suspend.waitstatus;
4340
4341   switch_to_thread (thread);
4342   thread->suspend.stop_pc = get_frame_pc (get_current_frame ());
4343   set_current_sal_from_frame (get_current_frame ());
4344
4345   thread->suspend.waitstatus_pending_p = 0;
4346
4347   if (ws->kind == TARGET_WAITKIND_STOPPED)
4348     {
4349       enum gdb_signal sig = ws->value.sig;
4350
4351       if (signal_print_state (sig))
4352         gdb::observers::signal_received.notify (sig);
4353     }
4354   gdb::observers::normal_stop.notify (NULL, 1);
4355 }
4356
4357 /* Process all initial stop replies the remote side sent in response
4358    to the ? packet.  These indicate threads that were already stopped
4359    on initial connection.  We mark these threads as stopped and print
4360    their current frame before giving the user the prompt.  */
4361
4362 void
4363 remote_target::process_initial_stop_replies (int from_tty)
4364 {
4365   int pending_stop_replies = stop_reply_queue_length ();
4366   struct thread_info *selected = NULL;
4367   struct thread_info *lowest_stopped = NULL;
4368   struct thread_info *first = NULL;
4369
4370   /* Consume the initial pending events.  */
4371   while (pending_stop_replies-- > 0)
4372     {
4373       ptid_t waiton_ptid = minus_one_ptid;
4374       ptid_t event_ptid;
4375       struct target_waitstatus ws;
4376       int ignore_event = 0;
4377
4378       memset (&ws, 0, sizeof (ws));
4379       event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
4380       if (remote_debug)
4381         print_target_wait_results (waiton_ptid, event_ptid, &ws);
4382
4383       switch (ws.kind)
4384         {
4385         case TARGET_WAITKIND_IGNORE:
4386         case TARGET_WAITKIND_NO_RESUMED:
4387         case TARGET_WAITKIND_SIGNALLED:
4388         case TARGET_WAITKIND_EXITED:
4389           /* We shouldn't see these, but if we do, just ignore.  */
4390           if (remote_debug)
4391             fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
4392           ignore_event = 1;
4393           break;
4394
4395         case TARGET_WAITKIND_EXECD:
4396           xfree (ws.value.execd_pathname);
4397           break;
4398         default:
4399           break;
4400         }
4401
4402       if (ignore_event)
4403         continue;
4404
4405       struct thread_info *evthread = find_thread_ptid (event_ptid);
4406
4407       if (ws.kind == TARGET_WAITKIND_STOPPED)
4408         {
4409           enum gdb_signal sig = ws.value.sig;
4410
4411           /* Stubs traditionally report SIGTRAP as initial signal,
4412              instead of signal 0.  Suppress it.  */
4413           if (sig == GDB_SIGNAL_TRAP)
4414             sig = GDB_SIGNAL_0;
4415           evthread->suspend.stop_signal = sig;
4416           ws.value.sig = sig;
4417         }
4418
4419       evthread->suspend.waitstatus = ws;
4420
4421       if (ws.kind != TARGET_WAITKIND_STOPPED
4422           || ws.value.sig != GDB_SIGNAL_0)
4423         evthread->suspend.waitstatus_pending_p = 1;
4424
4425       set_executing (event_ptid, 0);
4426       set_running (event_ptid, 0);
4427       get_remote_thread_info (evthread)->vcont_resumed = 0;
4428     }
4429
4430   /* "Notice" the new inferiors before anything related to
4431      registers/memory.  */
4432   for (inferior *inf : all_non_exited_inferiors ())
4433     {
4434       inf->needs_setup = 1;
4435
4436       if (non_stop)
4437         {
4438           thread_info *thread = any_live_thread_of_inferior (inf);
4439           notice_new_inferior (thread, thread->state == THREAD_RUNNING,
4440                                from_tty);
4441         }
4442     }
4443
4444   /* If all-stop on top of non-stop, pause all threads.  Note this
4445      records the threads' stop pc, so must be done after "noticing"
4446      the inferiors.  */
4447   if (!non_stop)
4448     {
4449       stop_all_threads ();
4450
4451       /* If all threads of an inferior were already stopped, we
4452          haven't setup the inferior yet.  */
4453       for (inferior *inf : all_non_exited_inferiors ())
4454         {
4455           if (inf->needs_setup)
4456             {
4457               thread_info *thread = any_live_thread_of_inferior (inf);
4458               switch_to_thread_no_regs (thread);
4459               setup_inferior (0);
4460             }
4461         }
4462     }
4463
4464   /* Now go over all threads that are stopped, and print their current
4465      frame.  If all-stop, then if there's a signalled thread, pick
4466      that as current.  */
4467   for (thread_info *thread : all_non_exited_threads ())
4468     {
4469       if (first == NULL)
4470         first = thread;
4471
4472       if (!non_stop)
4473         thread->set_running (false);
4474       else if (thread->state != THREAD_STOPPED)
4475         continue;
4476
4477       if (selected == NULL
4478           && thread->suspend.waitstatus_pending_p)
4479         selected = thread;
4480
4481       if (lowest_stopped == NULL
4482           || thread->inf->num < lowest_stopped->inf->num
4483           || thread->per_inf_num < lowest_stopped->per_inf_num)
4484         lowest_stopped = thread;
4485
4486       if (non_stop)
4487         print_one_stopped_thread (thread);
4488     }
4489
4490   /* In all-stop, we only print the status of one thread, and leave
4491      others with their status pending.  */
4492   if (!non_stop)
4493     {
4494       thread_info *thread = selected;
4495       if (thread == NULL)
4496         thread = lowest_stopped;
4497       if (thread == NULL)
4498         thread = first;
4499
4500       print_one_stopped_thread (thread);
4501     }
4502
4503   /* For "info program".  */
4504   thread_info *thread = inferior_thread ();
4505   if (thread->state == THREAD_STOPPED)
4506     set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
4507 }
4508
4509 /* Start the remote connection and sync state.  */
4510
4511 void
4512 remote_target::start_remote (int from_tty, int extended_p)
4513 {
4514   struct remote_state *rs = get_remote_state ();
4515   struct packet_config *noack_config;
4516   char *wait_status = NULL;
4517
4518   /* Signal other parts that we're going through the initial setup,
4519      and so things may not be stable yet.  E.g., we don't try to
4520      install tracepoints until we've relocated symbols.  Also, a
4521      Ctrl-C before we're connected and synced up can't interrupt the
4522      target.  Instead, it offers to drop the (potentially wedged)
4523      connection.  */
4524   rs->starting_up = 1;
4525
4526   QUIT;
4527
4528   if (interrupt_on_connect)
4529     send_interrupt_sequence ();
4530
4531   /* Ack any packet which the remote side has already sent.  */
4532   remote_serial_write ("+", 1);
4533
4534   /* The first packet we send to the target is the optional "supported
4535      packets" request.  If the target can answer this, it will tell us
4536      which later probes to skip.  */
4537   remote_query_supported ();
4538
4539   /* If the stub wants to get a QAllow, compose one and send it.  */
4540   if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
4541     set_permissions ();
4542
4543   /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4544      unknown 'v' packet with string "OK".  "OK" gets interpreted by GDB
4545      as a reply to known packet.  For packet "vFile:setfs:" it is an
4546      invalid reply and GDB would return error in
4547      remote_hostio_set_filesystem, making remote files access impossible.
4548      Disable "vFile:setfs:" in such case.  Do not disable other 'v' packets as
4549      other "vFile" packets get correctly detected even on gdbserver < 7.7.  */
4550   {
4551     const char v_mustreplyempty[] = "vMustReplyEmpty";
4552
4553     putpkt (v_mustreplyempty);
4554     getpkt (&rs->buf, 0);
4555     if (strcmp (rs->buf.data (), "OK") == 0)
4556       remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
4557     else if (strcmp (rs->buf.data (), "") != 0)
4558       error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
4559              rs->buf.data ());
4560   }
4561
4562   /* Next, we possibly activate noack mode.
4563
4564      If the QStartNoAckMode packet configuration is set to AUTO,
4565      enable noack mode if the stub reported a wish for it with
4566      qSupported.
4567
4568      If set to TRUE, then enable noack mode even if the stub didn't
4569      report it in qSupported.  If the stub doesn't reply OK, the
4570      session ends with an error.
4571
4572      If FALSE, then don't activate noack mode, regardless of what the
4573      stub claimed should be the default with qSupported.  */
4574
4575   noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
4576   if (packet_config_support (noack_config) != PACKET_DISABLE)
4577     {
4578       putpkt ("QStartNoAckMode");
4579       getpkt (&rs->buf, 0);
4580       if (packet_ok (rs->buf, noack_config) == PACKET_OK)
4581         rs->noack_mode = 1;
4582     }
4583
4584   if (extended_p)
4585     {
4586       /* Tell the remote that we are using the extended protocol.  */
4587       putpkt ("!");
4588       getpkt (&rs->buf, 0);
4589     }
4590
4591   /* Let the target know which signals it is allowed to pass down to
4592      the program.  */
4593   update_signals_program_target ();
4594
4595   /* Next, if the target can specify a description, read it.  We do
4596      this before anything involving memory or registers.  */
4597   target_find_description ();
4598
4599   /* Next, now that we know something about the target, update the
4600      address spaces in the program spaces.  */
4601   update_address_spaces ();
4602
4603   /* On OSs where the list of libraries is global to all
4604      processes, we fetch them early.  */
4605   if (gdbarch_has_global_solist (target_gdbarch ()))
4606     solib_add (NULL, from_tty, auto_solib_add);
4607
4608   if (target_is_non_stop_p ())
4609     {
4610       if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
4611         error (_("Non-stop mode requested, but remote "
4612                  "does not support non-stop"));
4613
4614       putpkt ("QNonStop:1");
4615       getpkt (&rs->buf, 0);
4616
4617       if (strcmp (rs->buf.data (), "OK") != 0)
4618         error (_("Remote refused setting non-stop mode with: %s"),
4619                rs->buf.data ());
4620
4621       /* Find about threads and processes the stub is already
4622          controlling.  We default to adding them in the running state.
4623          The '?' query below will then tell us about which threads are
4624          stopped.  */
4625       this->update_thread_list ();
4626     }
4627   else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
4628     {
4629       /* Don't assume that the stub can operate in all-stop mode.
4630          Request it explicitly.  */
4631       putpkt ("QNonStop:0");
4632       getpkt (&rs->buf, 0);
4633
4634       if (strcmp (rs->buf.data (), "OK") != 0)
4635         error (_("Remote refused setting all-stop mode with: %s"),
4636                rs->buf.data ());
4637     }
4638
4639   /* Upload TSVs regardless of whether the target is running or not.  The
4640      remote stub, such as GDBserver, may have some predefined or builtin
4641      TSVs, even if the target is not running.  */
4642   if (get_trace_status (current_trace_status ()) != -1)
4643     {
4644       struct uploaded_tsv *uploaded_tsvs = NULL;
4645
4646       upload_trace_state_variables (&uploaded_tsvs);
4647       merge_uploaded_trace_state_variables (&uploaded_tsvs);
4648     }
4649
4650   /* Check whether the target is running now.  */
4651   putpkt ("?");
4652   getpkt (&rs->buf, 0);
4653
4654   if (!target_is_non_stop_p ())
4655     {
4656       if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
4657         {
4658           if (!extended_p)
4659             error (_("The target is not running (try extended-remote?)"));
4660
4661           /* We're connected, but not running.  Drop out before we
4662              call start_remote.  */
4663           rs->starting_up = 0;
4664           return;
4665         }
4666       else
4667         {
4668           /* Save the reply for later.  */
4669           wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
4670           strcpy (wait_status, rs->buf.data ());
4671         }
4672
4673       /* Fetch thread list.  */
4674       target_update_thread_list ();
4675
4676       /* Let the stub know that we want it to return the thread.  */
4677       set_continue_thread (minus_one_ptid);
4678
4679       if (thread_count () == 0)
4680         {
4681           /* Target has no concept of threads at all.  GDB treats
4682              non-threaded target as single-threaded; add a main
4683              thread.  */
4684           add_current_inferior_and_thread (wait_status);
4685         }
4686       else
4687         {
4688           /* We have thread information; select the thread the target
4689              says should be current.  If we're reconnecting to a
4690              multi-threaded program, this will ideally be the thread
4691              that last reported an event before GDB disconnected.  */
4692           inferior_ptid = get_current_thread (wait_status);
4693           if (inferior_ptid == null_ptid)
4694             {
4695               /* Odd... The target was able to list threads, but not
4696                  tell us which thread was current (no "thread"
4697                  register in T stop reply?).  Just pick the first
4698                  thread in the thread list then.  */
4699               
4700               if (remote_debug)
4701                 fprintf_unfiltered (gdb_stdlog,
4702                                     "warning: couldn't determine remote "
4703                                     "current thread; picking first in list.\n");
4704
4705               inferior_ptid = inferior_list->thread_list->ptid;
4706             }
4707         }
4708
4709       /* init_wait_for_inferior should be called before get_offsets in order
4710          to manage `inserted' flag in bp loc in a correct state.
4711          breakpoint_init_inferior, called from init_wait_for_inferior, set
4712          `inserted' flag to 0, while before breakpoint_re_set, called from
4713          start_remote, set `inserted' flag to 1.  In the initialization of
4714          inferior, breakpoint_init_inferior should be called first, and then
4715          breakpoint_re_set can be called.  If this order is broken, state of
4716          `inserted' flag is wrong, and cause some problems on breakpoint
4717          manipulation.  */
4718       init_wait_for_inferior ();
4719
4720       get_offsets ();           /* Get text, data & bss offsets.  */
4721
4722       /* If we could not find a description using qXfer, and we know
4723          how to do it some other way, try again.  This is not
4724          supported for non-stop; it could be, but it is tricky if
4725          there are no stopped threads when we connect.  */
4726       if (remote_read_description_p (this)
4727           && gdbarch_target_desc (target_gdbarch ()) == NULL)
4728         {
4729           target_clear_description ();
4730           target_find_description ();
4731         }
4732
4733       /* Use the previously fetched status.  */
4734       gdb_assert (wait_status != NULL);
4735       strcpy (rs->buf.data (), wait_status);
4736       rs->cached_wait_status = 1;
4737
4738       ::start_remote (from_tty); /* Initialize gdb process mechanisms.  */
4739     }
4740   else
4741     {
4742       /* Clear WFI global state.  Do this before finding about new
4743          threads and inferiors, and setting the current inferior.
4744          Otherwise we would clear the proceed status of the current
4745          inferior when we want its stop_soon state to be preserved
4746          (see notice_new_inferior).  */
4747       init_wait_for_inferior ();
4748
4749       /* In non-stop, we will either get an "OK", meaning that there
4750          are no stopped threads at this time; or, a regular stop
4751          reply.  In the latter case, there may be more than one thread
4752          stopped --- we pull them all out using the vStopped
4753          mechanism.  */
4754       if (strcmp (rs->buf.data (), "OK") != 0)
4755         {
4756           struct notif_client *notif = &notif_client_stop;
4757
4758           /* remote_notif_get_pending_replies acks this one, and gets
4759              the rest out.  */
4760           rs->notif_state->pending_event[notif_client_stop.id]
4761             = remote_notif_parse (this, notif, rs->buf.data ());
4762           remote_notif_get_pending_events (notif);
4763         }
4764
4765       if (thread_count () == 0)
4766         {
4767           if (!extended_p)
4768             error (_("The target is not running (try extended-remote?)"));
4769
4770           /* We're connected, but not running.  Drop out before we
4771              call start_remote.  */
4772           rs->starting_up = 0;
4773           return;
4774         }
4775
4776       /* In non-stop mode, any cached wait status will be stored in
4777          the stop reply queue.  */
4778       gdb_assert (wait_status == NULL);
4779
4780       /* Report all signals during attach/startup.  */
4781       pass_signals ({});
4782
4783       /* If there are already stopped threads, mark them stopped and
4784          report their stops before giving the prompt to the user.  */
4785       process_initial_stop_replies (from_tty);
4786
4787       if (target_can_async_p ())
4788         target_async (1);
4789     }
4790
4791   /* If we connected to a live target, do some additional setup.  */
4792   if (target_has_execution)
4793     {
4794       if (symfile_objfile)      /* No use without a symbol-file.  */
4795         remote_check_symbols ();
4796     }
4797
4798   /* Possibly the target has been engaged in a trace run started
4799      previously; find out where things are at.  */
4800   if (get_trace_status (current_trace_status ()) != -1)
4801     {
4802       struct uploaded_tp *uploaded_tps = NULL;
4803
4804       if (current_trace_status ()->running)
4805         printf_filtered (_("Trace is already running on the target.\n"));
4806
4807       upload_tracepoints (&uploaded_tps);
4808
4809       merge_uploaded_tracepoints (&uploaded_tps);
4810     }
4811
4812   /* Possibly the target has been engaged in a btrace record started
4813      previously; find out where things are at.  */
4814   remote_btrace_maybe_reopen ();
4815
4816   /* The thread and inferior lists are now synchronized with the
4817      target, our symbols have been relocated, and we're merged the
4818      target's tracepoints with ours.  We're done with basic start
4819      up.  */
4820   rs->starting_up = 0;
4821
4822   /* Maybe breakpoints are global and need to be inserted now.  */
4823   if (breakpoints_should_be_inserted_now ())
4824     insert_breakpoints ();
4825 }
4826
4827 /* Open a connection to a remote debugger.
4828    NAME is the filename used for communication.  */
4829
4830 void
4831 remote_target::open (const char *name, int from_tty)
4832 {
4833   open_1 (name, from_tty, 0);
4834 }
4835
4836 /* Open a connection to a remote debugger using the extended
4837    remote gdb protocol.  NAME is the filename used for communication.  */
4838
4839 void
4840 extended_remote_target::open (const char *name, int from_tty)
4841 {
4842   open_1 (name, from_tty, 1 /*extended_p */);
4843 }
4844
4845 /* Reset all packets back to "unknown support".  Called when opening a
4846    new connection to a remote target.  */
4847
4848 static void
4849 reset_all_packet_configs_support (void)
4850 {
4851   int i;
4852
4853   for (i = 0; i < PACKET_MAX; i++)
4854     remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4855 }
4856
4857 /* Initialize all packet configs.  */
4858
4859 static void
4860 init_all_packet_configs (void)
4861 {
4862   int i;
4863
4864   for (i = 0; i < PACKET_MAX; i++)
4865     {
4866       remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
4867       remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4868     }
4869 }
4870
4871 /* Symbol look-up.  */
4872
4873 void
4874 remote_target::remote_check_symbols ()
4875 {
4876   char *tmp;
4877   int end;
4878
4879   /* The remote side has no concept of inferiors that aren't running
4880      yet, it only knows about running processes.  If we're connected
4881      but our current inferior is not running, we should not invite the
4882      remote target to request symbol lookups related to its
4883      (unrelated) current process.  */
4884   if (!target_has_execution)
4885     return;
4886
4887   if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
4888     return;
4889
4890   /* Make sure the remote is pointing at the right process.  Note
4891      there's no way to select "no process".  */
4892   set_general_process ();
4893
4894   /* Allocate a message buffer.  We can't reuse the input buffer in RS,
4895      because we need both at the same time.  */
4896   gdb::char_vector msg (get_remote_packet_size ());
4897   gdb::char_vector reply (get_remote_packet_size ());
4898
4899   /* Invite target to request symbol lookups.  */
4900
4901   putpkt ("qSymbol::");
4902   getpkt (&reply, 0);
4903   packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
4904
4905   while (startswith (reply.data (), "qSymbol:"))
4906     {
4907       struct bound_minimal_symbol sym;
4908
4909       tmp = &reply[8];
4910       end = hex2bin (tmp, reinterpret_cast <gdb_byte *> (msg.data ()),
4911                      strlen (tmp) / 2);
4912       msg[end] = '\0';
4913       sym = lookup_minimal_symbol (msg.data (), NULL, NULL);
4914       if (sym.minsym == NULL)
4915         xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol::%s",
4916                    &reply[8]);
4917       else
4918         {
4919           int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
4920           CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
4921
4922           /* If this is a function address, return the start of code
4923              instead of any data function descriptor.  */
4924           sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4925                                                          sym_addr,
4926                                                          current_top_target ());
4927
4928           xsnprintf (msg.data (), get_remote_packet_size (), "qSymbol:%s:%s",
4929                      phex_nz (sym_addr, addr_size), &reply[8]);
4930         }
4931
4932       putpkt (msg.data ());
4933       getpkt (&reply, 0);
4934     }
4935 }
4936
4937 static struct serial *
4938 remote_serial_open (const char *name)
4939 {
4940   static int udp_warning = 0;
4941
4942   /* FIXME: Parsing NAME here is a hack.  But we want to warn here instead
4943      of in ser-tcp.c, because it is the remote protocol assuming that the
4944      serial connection is reliable and not the serial connection promising
4945      to be.  */
4946   if (!udp_warning && startswith (name, "udp:"))
4947     {
4948       warning (_("The remote protocol may be unreliable over UDP.\n"
4949                  "Some events may be lost, rendering further debugging "
4950                  "impossible."));
4951       udp_warning = 1;
4952     }
4953
4954   return serial_open (name);
4955 }
4956
4957 /* Inform the target of our permission settings.  The permission flags
4958    work without this, but if the target knows the settings, it can do
4959    a couple things.  First, it can add its own check, to catch cases
4960    that somehow manage to get by the permissions checks in target
4961    methods.  Second, if the target is wired to disallow particular
4962    settings (for instance, a system in the field that is not set up to
4963    be able to stop at a breakpoint), it can object to any unavailable
4964    permissions.  */
4965
4966 void
4967 remote_target::set_permissions ()
4968 {
4969   struct remote_state *rs = get_remote_state ();
4970
4971   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAllow:"
4972              "WriteReg:%x;WriteMem:%x;"
4973              "InsertBreak:%x;InsertTrace:%x;"
4974              "InsertFastTrace:%x;Stop:%x",
4975              may_write_registers, may_write_memory,
4976              may_insert_breakpoints, may_insert_tracepoints,
4977              may_insert_fast_tracepoints, may_stop);
4978   putpkt (rs->buf);
4979   getpkt (&rs->buf, 0);
4980
4981   /* If the target didn't like the packet, warn the user.  Do not try
4982      to undo the user's settings, that would just be maddening.  */
4983   if (strcmp (rs->buf.data (), "OK") != 0)
4984     warning (_("Remote refused setting permissions with: %s"),
4985              rs->buf.data ());
4986 }
4987
4988 /* This type describes each known response to the qSupported
4989    packet.  */
4990 struct protocol_feature
4991 {
4992   /* The name of this protocol feature.  */
4993   const char *name;
4994
4995   /* The default for this protocol feature.  */
4996   enum packet_support default_support;
4997
4998   /* The function to call when this feature is reported, or after
4999      qSupported processing if the feature is not supported.
5000      The first argument points to this structure.  The second
5001      argument indicates whether the packet requested support be
5002      enabled, disabled, or probed (or the default, if this function
5003      is being called at the end of processing and this feature was
5004      not reported).  The third argument may be NULL; if not NULL, it
5005      is a NUL-terminated string taken from the packet following
5006      this feature's name and an equals sign.  */
5007   void (*func) (remote_target *remote, const struct protocol_feature *,
5008                 enum packet_support, const char *);
5009
5010   /* The corresponding packet for this feature.  Only used if
5011      FUNC is remote_supported_packet.  */
5012   int packet;
5013 };
5014
5015 static void
5016 remote_supported_packet (remote_target *remote,
5017                          const struct protocol_feature *feature,
5018                          enum packet_support support,
5019                          const char *argument)
5020 {
5021   if (argument)
5022     {
5023       warning (_("Remote qSupported response supplied an unexpected value for"
5024                  " \"%s\"."), feature->name);
5025       return;
5026     }
5027
5028   remote_protocol_packets[feature->packet].support = support;
5029 }
5030
5031 void
5032 remote_target::remote_packet_size (const protocol_feature *feature,
5033                                    enum packet_support support, const char *value)
5034 {
5035   struct remote_state *rs = get_remote_state ();
5036
5037   int packet_size;
5038   char *value_end;
5039
5040   if (support != PACKET_ENABLE)
5041     return;
5042
5043   if (value == NULL || *value == '\0')
5044     {
5045       warning (_("Remote target reported \"%s\" without a size."),
5046                feature->name);
5047       return;
5048     }
5049
5050   errno = 0;
5051   packet_size = strtol (value, &value_end, 16);
5052   if (errno != 0 || *value_end != '\0' || packet_size < 0)
5053     {
5054       warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
5055                feature->name, value);
5056       return;
5057     }
5058
5059   /* Record the new maximum packet size.  */
5060   rs->explicit_packet_size = packet_size;
5061 }
5062
5063 void
5064 remote_packet_size (remote_target *remote, const protocol_feature *feature,
5065                     enum packet_support support, const char *value)
5066 {
5067   remote->remote_packet_size (feature, support, value);
5068 }
5069
5070 static const struct protocol_feature remote_protocol_features[] = {
5071   { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
5072   { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
5073     PACKET_qXfer_auxv },
5074   { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet,
5075     PACKET_qXfer_exec_file },
5076   { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
5077     PACKET_qXfer_features },
5078   { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
5079     PACKET_qXfer_libraries },
5080   { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
5081     PACKET_qXfer_libraries_svr4 },
5082   { "augmented-libraries-svr4-read", PACKET_DISABLE,
5083     remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
5084   { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
5085     PACKET_qXfer_memory_map },
5086   { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
5087     PACKET_qXfer_spu_read },
5088   { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
5089     PACKET_qXfer_spu_write },
5090   { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
5091     PACKET_qXfer_osdata },
5092   { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
5093     PACKET_qXfer_threads },
5094   { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
5095     PACKET_qXfer_traceframe_info },
5096   { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
5097     PACKET_QPassSignals },
5098   { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet,
5099     PACKET_QCatchSyscalls },
5100   { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
5101     PACKET_QProgramSignals },
5102   { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet,
5103     PACKET_QSetWorkingDir },
5104   { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet,
5105     PACKET_QStartupWithShell },
5106   { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet,
5107     PACKET_QEnvironmentHexEncoded },
5108   { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet,
5109     PACKET_QEnvironmentReset },
5110   { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet,
5111     PACKET_QEnvironmentUnset },
5112   { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
5113     PACKET_QStartNoAckMode },
5114   { "multiprocess", PACKET_DISABLE, remote_supported_packet,
5115     PACKET_multiprocess_feature },
5116   { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
5117   { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
5118     PACKET_qXfer_siginfo_read },
5119   { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
5120     PACKET_qXfer_siginfo_write },
5121   { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
5122     PACKET_ConditionalTracepoints },
5123   { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
5124     PACKET_ConditionalBreakpoints },
5125   { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
5126     PACKET_BreakpointCommands },
5127   { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
5128     PACKET_FastTracepoints },
5129   { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
5130     PACKET_StaticTracepoints },
5131   {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
5132    PACKET_InstallInTrace},
5133   { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
5134     PACKET_DisconnectedTracing_feature },
5135   { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
5136     PACKET_bc },
5137   { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
5138     PACKET_bs },
5139   { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
5140     PACKET_TracepointSource },
5141   { "QAllow", PACKET_DISABLE, remote_supported_packet,
5142     PACKET_QAllow },
5143   { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
5144     PACKET_EnableDisableTracepoints_feature },
5145   { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
5146     PACKET_qXfer_fdpic },
5147   { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
5148     PACKET_qXfer_uib },
5149   { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
5150     PACKET_QDisableRandomization },
5151   { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
5152   { "QTBuffer:size", PACKET_DISABLE,
5153     remote_supported_packet, PACKET_QTBuffer_size},
5154   { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
5155   { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
5156   { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
5157   { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt },
5158   { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
5159     PACKET_qXfer_btrace },
5160   { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet,
5161     PACKET_qXfer_btrace_conf },
5162   { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet,
5163     PACKET_Qbtrace_conf_bts_size },
5164   { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
5165   { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
5166   { "fork-events", PACKET_DISABLE, remote_supported_packet,
5167     PACKET_fork_event_feature },
5168   { "vfork-events", PACKET_DISABLE, remote_supported_packet,
5169     PACKET_vfork_event_feature },
5170   { "exec-events", PACKET_DISABLE, remote_supported_packet,
5171     PACKET_exec_event_feature },
5172   { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet,
5173     PACKET_Qbtrace_conf_pt_size },
5174   { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
5175   { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
5176   { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
5177 };
5178
5179 static char *remote_support_xml;
5180
5181 /* Register string appended to "xmlRegisters=" in qSupported query.  */
5182
5183 void
5184 register_remote_support_xml (const char *xml)
5185 {
5186 #if defined(HAVE_LIBEXPAT)
5187   if (remote_support_xml == NULL)
5188     remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
5189   else
5190     {
5191       char *copy = xstrdup (remote_support_xml + 13);
5192       char *p = strtok (copy, ",");
5193
5194       do
5195         {
5196           if (strcmp (p, xml) == 0)
5197             {
5198               /* already there */
5199               xfree (copy);
5200               return;
5201             }
5202         }
5203       while ((p = strtok (NULL, ",")) != NULL);
5204       xfree (copy);
5205
5206       remote_support_xml = reconcat (remote_support_xml,
5207                                      remote_support_xml, ",", xml,
5208                                      (char *) NULL);
5209     }
5210 #endif
5211 }
5212
5213 static void
5214 remote_query_supported_append (std::string *msg, const char *append)
5215 {
5216   if (!msg->empty ())
5217     msg->append (";");
5218   msg->append (append);
5219 }
5220
5221 void
5222 remote_target::remote_query_supported ()
5223 {
5224   struct remote_state *rs = get_remote_state ();
5225   char *next;
5226   int i;
5227   unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
5228
5229   /* The packet support flags are handled differently for this packet
5230      than for most others.  We treat an error, a disabled packet, and
5231      an empty response identically: any features which must be reported
5232      to be used will be automatically disabled.  An empty buffer
5233      accomplishes this, since that is also the representation for a list
5234      containing no features.  */
5235
5236   rs->buf[0] = 0;
5237   if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
5238     {
5239       std::string q;
5240
5241       if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
5242         remote_query_supported_append (&q, "multiprocess+");
5243
5244       if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
5245         remote_query_supported_append (&q, "swbreak+");
5246       if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
5247         remote_query_supported_append (&q, "hwbreak+");
5248
5249       remote_query_supported_append (&q, "qRelocInsn+");
5250
5251       if (packet_set_cmd_state (PACKET_fork_event_feature)
5252           != AUTO_BOOLEAN_FALSE)
5253         remote_query_supported_append (&q, "fork-events+");
5254       if (packet_set_cmd_state (PACKET_vfork_event_feature)
5255           != AUTO_BOOLEAN_FALSE)
5256         remote_query_supported_append (&q, "vfork-events+");
5257       if (packet_set_cmd_state (PACKET_exec_event_feature)
5258           != AUTO_BOOLEAN_FALSE)
5259         remote_query_supported_append (&q, "exec-events+");
5260
5261       if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
5262         remote_query_supported_append (&q, "vContSupported+");
5263
5264       if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
5265         remote_query_supported_append (&q, "QThreadEvents+");
5266
5267       if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
5268         remote_query_supported_append (&q, "no-resumed+");
5269
5270       /* Keep this one last to work around a gdbserver <= 7.10 bug in
5271          the qSupported:xmlRegisters=i386 handling.  */
5272       if (remote_support_xml != NULL
5273           && packet_support (PACKET_qXfer_features) != PACKET_DISABLE)
5274         remote_query_supported_append (&q, remote_support_xml);
5275
5276       q = "qSupported:" + q;
5277       putpkt (q.c_str ());
5278
5279       getpkt (&rs->buf, 0);
5280
5281       /* If an error occured, warn, but do not return - just reset the
5282          buffer to empty and go on to disable features.  */
5283       if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
5284           == PACKET_ERROR)
5285         {
5286           warning (_("Remote failure reply: %s"), rs->buf.data ());
5287           rs->buf[0] = 0;
5288         }
5289     }
5290
5291   memset (seen, 0, sizeof (seen));
5292
5293   next = rs->buf.data ();
5294   while (*next)
5295     {
5296       enum packet_support is_supported;
5297       char *p, *end, *name_end, *value;
5298
5299       /* First separate out this item from the rest of the packet.  If
5300          there's another item after this, we overwrite the separator
5301          (terminated strings are much easier to work with).  */
5302       p = next;
5303       end = strchr (p, ';');
5304       if (end == NULL)
5305         {
5306           end = p + strlen (p);
5307           next = end;
5308         }
5309       else
5310         {
5311           *end = '\0';
5312           next = end + 1;
5313
5314           if (end == p)
5315             {
5316               warning (_("empty item in \"qSupported\" response"));
5317               continue;
5318             }
5319         }
5320
5321       name_end = strchr (p, '=');
5322       if (name_end)
5323         {
5324           /* This is a name=value entry.  */
5325           is_supported = PACKET_ENABLE;
5326           value = name_end + 1;
5327           *name_end = '\0';
5328         }
5329       else
5330         {
5331           value = NULL;
5332           switch (end[-1])
5333             {
5334             case '+':
5335               is_supported = PACKET_ENABLE;
5336               break;
5337
5338             case '-':
5339               is_supported = PACKET_DISABLE;
5340               break;
5341
5342             case '?':
5343               is_supported = PACKET_SUPPORT_UNKNOWN;
5344               break;
5345
5346             default:
5347               warning (_("unrecognized item \"%s\" "
5348                          "in \"qSupported\" response"), p);
5349               continue;
5350             }
5351           end[-1] = '\0';
5352         }
5353
5354       for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5355         if (strcmp (remote_protocol_features[i].name, p) == 0)
5356           {
5357             const struct protocol_feature *feature;
5358
5359             seen[i] = 1;
5360             feature = &remote_protocol_features[i];
5361             feature->func (this, feature, is_supported, value);
5362             break;
5363           }
5364     }
5365
5366   /* If we increased the packet size, make sure to increase the global
5367      buffer size also.  We delay this until after parsing the entire
5368      qSupported packet, because this is the same buffer we were
5369      parsing.  */
5370   if (rs->buf.size () < rs->explicit_packet_size)
5371     rs->buf.resize (rs->explicit_packet_size);
5372
5373   /* Handle the defaults for unmentioned features.  */
5374   for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
5375     if (!seen[i])
5376       {
5377         const struct protocol_feature *feature;
5378
5379         feature = &remote_protocol_features[i];
5380         feature->func (this, feature, feature->default_support, NULL);
5381       }
5382 }
5383
5384 /* Serial QUIT handler for the remote serial descriptor.
5385
5386    Defers handling a Ctrl-C until we're done with the current
5387    command/response packet sequence, unless:
5388
5389    - We're setting up the connection.  Don't send a remote interrupt
5390      request, as we're not fully synced yet.  Quit immediately
5391      instead.
5392
5393    - The target has been resumed in the foreground
5394      (target_terminal::is_ours is false) with a synchronous resume
5395      packet, and we're blocked waiting for the stop reply, thus a
5396      Ctrl-C should be immediately sent to the target.
5397
5398    - We get a second Ctrl-C while still within the same serial read or
5399      write.  In that case the serial is seemingly wedged --- offer to
5400      quit/disconnect.
5401
5402    - We see a second Ctrl-C without target response, after having
5403      previously interrupted the target.  In that case the target/stub
5404      is probably wedged --- offer to quit/disconnect.
5405 */
5406
5407 void
5408 remote_target::remote_serial_quit_handler ()
5409 {
5410   struct remote_state *rs = get_remote_state ();
5411
5412   if (check_quit_flag ())
5413     {
5414       /* If we're starting up, we're not fully synced yet.  Quit
5415          immediately.  */
5416       if (rs->starting_up)
5417         quit ();
5418       else if (rs->got_ctrlc_during_io)
5419         {
5420           if (query (_("The target is not responding to GDB commands.\n"
5421                        "Stop debugging it? ")))
5422             remote_unpush_and_throw ();
5423         }
5424       /* If ^C has already been sent once, offer to disconnect.  */
5425       else if (!target_terminal::is_ours () && rs->ctrlc_pending_p)
5426         interrupt_query ();
5427       /* All-stop protocol, and blocked waiting for stop reply.  Send
5428          an interrupt request.  */
5429       else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply)
5430         target_interrupt ();
5431       else
5432         rs->got_ctrlc_during_io = 1;
5433     }
5434 }
5435
5436 /* The remote_target that is current while the quit handler is
5437    overridden with remote_serial_quit_handler.  */
5438 static remote_target *curr_quit_handler_target;
5439
5440 static void
5441 remote_serial_quit_handler ()
5442 {
5443   curr_quit_handler_target->remote_serial_quit_handler ();
5444 }
5445
5446 /* Remove any of the remote.c targets from target stack.  Upper targets depend
5447    on it so remove them first.  */
5448
5449 static void
5450 remote_unpush_target (void)
5451 {
5452   pop_all_targets_at_and_above (process_stratum);
5453 }
5454
5455 static void
5456 remote_unpush_and_throw (void)
5457 {
5458   remote_unpush_target ();
5459   throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
5460 }
5461
5462 void
5463 remote_target::open_1 (const char *name, int from_tty, int extended_p)
5464 {
5465   remote_target *curr_remote = get_current_remote_target ();
5466
5467   if (name == 0)
5468     error (_("To open a remote debug connection, you need to specify what\n"
5469            "serial device is attached to the remote system\n"
5470            "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5471
5472   /* If we're connected to a running target, target_preopen will kill it.
5473      Ask this question first, before target_preopen has a chance to kill
5474      anything.  */
5475   if (curr_remote != NULL && !have_inferiors ())
5476     {
5477       if (from_tty
5478           && !query (_("Already connected to a remote target.  Disconnect? ")))
5479         error (_("Still connected."));
5480     }
5481
5482   /* Here the possibly existing remote target gets unpushed.  */
5483   target_preopen (from_tty);
5484
5485   remote_fileio_reset ();
5486   reopen_exec_file ();
5487   reread_symbols ();
5488
5489   remote_target *remote
5490     = (extended_p ? new extended_remote_target () : new remote_target ());
5491   target_ops_up target_holder (remote);
5492
5493   remote_state *rs = remote->get_remote_state ();
5494
5495   /* See FIXME above.  */
5496   if (!target_async_permitted)
5497     rs->wait_forever_enabled_p = 1;
5498
5499   rs->remote_desc = remote_serial_open (name);
5500   if (!rs->remote_desc)
5501     perror_with_name (name);
5502
5503   if (baud_rate != -1)
5504     {
5505       if (serial_setbaudrate (rs->remote_desc, baud_rate))
5506         {
5507           /* The requested speed could not be set.  Error out to
5508              top level after closing remote_desc.  Take care to
5509              set remote_desc to NULL to avoid closing remote_desc
5510              more than once.  */
5511           serial_close (rs->remote_desc);
5512           rs->remote_desc = NULL;
5513           perror_with_name (name);
5514         }
5515     }
5516
5517   serial_setparity (rs->remote_desc, serial_parity);
5518   serial_raw (rs->remote_desc);
5519
5520   /* If there is something sitting in the buffer we might take it as a
5521      response to a command, which would be bad.  */
5522   serial_flush_input (rs->remote_desc);
5523
5524   if (from_tty)
5525     {
5526       puts_filtered ("Remote debugging using ");
5527       puts_filtered (name);
5528       puts_filtered ("\n");
5529     }
5530
5531   /* Switch to using the remote target now.  */
5532   push_target (std::move (target_holder));
5533
5534   /* Register extra event sources in the event loop.  */
5535   rs->remote_async_inferior_event_token
5536     = create_async_event_handler (remote_async_inferior_event_handler,
5537                                   remote);
5538   rs->notif_state = remote_notif_state_allocate (remote);
5539
5540   /* Reset the target state; these things will be queried either by
5541      remote_query_supported or as they are needed.  */
5542   reset_all_packet_configs_support ();
5543   rs->cached_wait_status = 0;
5544   rs->explicit_packet_size = 0;
5545   rs->noack_mode = 0;
5546   rs->extended = extended_p;
5547   rs->waiting_for_stop_reply = 0;
5548   rs->ctrlc_pending_p = 0;
5549   rs->got_ctrlc_during_io = 0;
5550
5551   rs->general_thread = not_sent_ptid;
5552   rs->continue_thread = not_sent_ptid;
5553   rs->remote_traceframe_number = -1;
5554
5555   rs->last_resume_exec_dir = EXEC_FORWARD;
5556
5557   /* Probe for ability to use "ThreadInfo" query, as required.  */
5558   rs->use_threadinfo_query = 1;
5559   rs->use_threadextra_query = 1;
5560
5561   rs->readahead_cache.invalidate ();
5562
5563   if (target_async_permitted)
5564     {
5565       /* FIXME: cagney/1999-09-23: During the initial connection it is
5566          assumed that the target is already ready and able to respond to
5567          requests.  Unfortunately remote_start_remote() eventually calls
5568          wait_for_inferior() with no timeout.  wait_forever_enabled_p gets
5569          around this.  Eventually a mechanism that allows
5570          wait_for_inferior() to expect/get timeouts will be
5571          implemented.  */
5572       rs->wait_forever_enabled_p = 0;
5573     }
5574
5575   /* First delete any symbols previously loaded from shared libraries.  */
5576   no_shared_libraries (NULL, 0);
5577
5578   /* Start the remote connection.  If error() or QUIT, discard this
5579      target (we'd otherwise be in an inconsistent state) and then
5580      propogate the error on up the exception chain.  This ensures that
5581      the caller doesn't stumble along blindly assuming that the
5582      function succeeded.  The CLI doesn't have this problem but other
5583      UI's, such as MI do.
5584
5585      FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5586      this function should return an error indication letting the
5587      caller restore the previous state.  Unfortunately the command
5588      ``target remote'' is directly wired to this function making that
5589      impossible.  On a positive note, the CLI side of this problem has
5590      been fixed - the function set_cmd_context() makes it possible for
5591      all the ``target ....'' commands to share a common callback
5592      function.  See cli-dump.c.  */
5593   {
5594
5595     try
5596       {
5597         remote->start_remote (from_tty, extended_p);
5598       }
5599     catch (const gdb_exception &ex)
5600       {
5601         /* Pop the partially set up target - unless something else did
5602            already before throwing the exception.  */
5603         if (ex.error != TARGET_CLOSE_ERROR)
5604           remote_unpush_target ();
5605         throw;
5606       }
5607   }
5608
5609   remote_btrace_reset (rs);
5610
5611   if (target_async_permitted)
5612     rs->wait_forever_enabled_p = 1;
5613 }
5614
5615 /* Detach the specified process.  */
5616
5617 void
5618 remote_target::remote_detach_pid (int pid)
5619 {
5620   struct remote_state *rs = get_remote_state ();
5621
5622   /* This should not be necessary, but the handling for D;PID in
5623      GDBserver versions prior to 8.2 incorrectly assumes that the
5624      selected process points to the same process we're detaching,
5625      leading to misbehavior (and possibly GDBserver crashing) when it
5626      does not.  Since it's easy and cheap, work around it by forcing
5627      GDBserver to select GDB's current process.  */
5628   set_general_process ();
5629
5630   if (remote_multi_process_p (rs))
5631     xsnprintf (rs->buf.data (), get_remote_packet_size (), "D;%x", pid);
5632   else
5633     strcpy (rs->buf.data (), "D");
5634
5635   putpkt (rs->buf);
5636   getpkt (&rs->buf, 0);
5637
5638   if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
5639     ;
5640   else if (rs->buf[0] == '\0')
5641     error (_("Remote doesn't know how to detach"));
5642   else
5643     error (_("Can't detach process."));
5644 }
5645
5646 /* This detaches a program to which we previously attached, using
5647    inferior_ptid to identify the process.  After this is done, GDB
5648    can be used to debug some other program.  We better not have left
5649    any breakpoints in the target program or it'll die when it hits
5650    one.  */
5651
5652 void
5653 remote_target::remote_detach_1 (inferior *inf, int from_tty)
5654 {
5655   int pid = inferior_ptid.pid ();
5656   struct remote_state *rs = get_remote_state ();
5657   int is_fork_parent;
5658
5659   if (!target_has_execution)
5660     error (_("No process to detach from."));
5661
5662   target_announce_detach (from_tty);
5663
5664   /* Tell the remote target to detach.  */
5665   remote_detach_pid (pid);
5666
5667   /* Exit only if this is the only active inferior.  */
5668   if (from_tty && !rs->extended && number_of_live_inferiors () == 1)
5669     puts_filtered (_("Ending remote debugging.\n"));
5670
5671   struct thread_info *tp = find_thread_ptid (inferior_ptid);
5672
5673   /* Check to see if we are detaching a fork parent.  Note that if we
5674      are detaching a fork child, tp == NULL.  */
5675   is_fork_parent = (tp != NULL
5676                     && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
5677
5678   /* If doing detach-on-fork, we don't mourn, because that will delete
5679      breakpoints that should be available for the followed inferior.  */
5680   if (!is_fork_parent)
5681     {
5682       /* Save the pid as a string before mourning, since that will
5683          unpush the remote target, and we need the string after.  */
5684       std::string infpid = target_pid_to_str (ptid_t (pid));
5685
5686       target_mourn_inferior (inferior_ptid);
5687       if (print_inferior_events)
5688         printf_unfiltered (_("[Inferior %d (%s) detached]\n"),
5689                            inf->num, infpid.c_str ());
5690     }
5691   else
5692     {
5693       inferior_ptid = null_ptid;
5694       detach_inferior (current_inferior ());
5695     }
5696 }
5697
5698 void
5699 remote_target::detach (inferior *inf, int from_tty)
5700 {
5701   remote_detach_1 (inf, from_tty);
5702 }
5703
5704 void
5705 extended_remote_target::detach (inferior *inf, int from_tty)
5706 {
5707   remote_detach_1 (inf, from_tty);
5708 }
5709
5710 /* Target follow-fork function for remote targets.  On entry, and
5711    at return, the current inferior is the fork parent.
5712
5713    Note that although this is currently only used for extended-remote,
5714    it is named remote_follow_fork in anticipation of using it for the
5715    remote target as well.  */
5716
5717 int
5718 remote_target::follow_fork (int follow_child, int detach_fork)
5719 {
5720   struct remote_state *rs = get_remote_state ();
5721   enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
5722
5723   if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
5724       || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
5725     {
5726       /* When following the parent and detaching the child, we detach
5727          the child here.  For the case of following the child and
5728          detaching the parent, the detach is done in the target-
5729          independent follow fork code in infrun.c.  We can't use
5730          target_detach when detaching an unfollowed child because
5731          the client side doesn't know anything about the child.  */
5732       if (detach_fork && !follow_child)
5733         {
5734           /* Detach the fork child.  */
5735           ptid_t child_ptid;
5736           pid_t child_pid;
5737
5738           child_ptid = inferior_thread ()->pending_follow.value.related_pid;
5739           child_pid = child_ptid.pid ();
5740
5741           remote_detach_pid (child_pid);
5742         }
5743     }
5744   return 0;
5745 }
5746
5747 /* Target follow-exec function for remote targets.  Save EXECD_PATHNAME
5748    in the program space of the new inferior.  On entry and at return the
5749    current inferior is the exec'ing inferior.  INF is the new exec'd
5750    inferior, which may be the same as the exec'ing inferior unless
5751    follow-exec-mode is "new".  */
5752
5753 void
5754 remote_target::follow_exec (struct inferior *inf, const char *execd_pathname)
5755 {
5756   /* We know that this is a target file name, so if it has the "target:"
5757      prefix we strip it off before saving it in the program space.  */
5758   if (is_target_filename (execd_pathname))
5759     execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
5760
5761   set_pspace_remote_exec_file (inf->pspace, execd_pathname);
5762 }
5763
5764 /* Same as remote_detach, but don't send the "D" packet; just disconnect.  */
5765
5766 void
5767 remote_target::disconnect (const char *args, int from_tty)
5768 {
5769   if (args)
5770     error (_("Argument given to \"disconnect\" when remotely debugging."));
5771
5772   /* Make sure we unpush even the extended remote targets.  Calling
5773      target_mourn_inferior won't unpush, and remote_mourn won't
5774      unpush if there is more than one inferior left.  */
5775   unpush_target (this);
5776   generic_mourn_inferior ();
5777
5778   if (from_tty)
5779     puts_filtered ("Ending remote debugging.\n");
5780 }
5781
5782 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
5783    be chatty about it.  */
5784
5785 void
5786 extended_remote_target::attach (const char *args, int from_tty)
5787 {
5788   struct remote_state *rs = get_remote_state ();
5789   int pid;
5790   char *wait_status = NULL;
5791
5792   pid = parse_pid_to_attach (args);
5793
5794   /* Remote PID can be freely equal to getpid, do not check it here the same
5795      way as in other targets.  */
5796
5797   if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
5798     error (_("This target does not support attaching to a process"));
5799
5800   if (from_tty)
5801     {
5802       char *exec_file = get_exec_file (0);
5803
5804       if (exec_file)
5805         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
5806                            target_pid_to_str (ptid_t (pid)).c_str ());
5807       else
5808         printf_unfiltered (_("Attaching to %s\n"),
5809                            target_pid_to_str (ptid_t (pid)).c_str ());
5810     }
5811
5812   xsnprintf (rs->buf.data (), get_remote_packet_size (), "vAttach;%x", pid);
5813   putpkt (rs->buf);
5814   getpkt (&rs->buf, 0);
5815
5816   switch (packet_ok (rs->buf,
5817                      &remote_protocol_packets[PACKET_vAttach]))
5818     {
5819     case PACKET_OK:
5820       if (!target_is_non_stop_p ())
5821         {
5822           /* Save the reply for later.  */
5823           wait_status = (char *) alloca (strlen (rs->buf.data ()) + 1);
5824           strcpy (wait_status, rs->buf.data ());
5825         }
5826       else if (strcmp (rs->buf.data (), "OK") != 0)
5827         error (_("Attaching to %s failed with: %s"),
5828                target_pid_to_str (ptid_t (pid)).c_str (),
5829                rs->buf.data ());
5830       break;
5831     case PACKET_UNKNOWN:
5832       error (_("This target does not support attaching to a process"));
5833     default:
5834       error (_("Attaching to %s failed"),
5835              target_pid_to_str (ptid_t (pid)).c_str ());
5836     }
5837
5838   set_current_inferior (remote_add_inferior (false, pid, 1, 0));
5839
5840   inferior_ptid = ptid_t (pid);
5841
5842   if (target_is_non_stop_p ())
5843     {
5844       struct thread_info *thread;
5845
5846       /* Get list of threads.  */
5847       update_thread_list ();
5848
5849       thread = first_thread_of_inferior (current_inferior ());
5850       if (thread)
5851         inferior_ptid = thread->ptid;
5852       else
5853         inferior_ptid = ptid_t (pid);
5854
5855       /* Invalidate our notion of the remote current thread.  */
5856       record_currthread (rs, minus_one_ptid);
5857     }
5858   else
5859     {
5860       /* Now, if we have thread information, update inferior_ptid.  */
5861       inferior_ptid = remote_current_thread (inferior_ptid);
5862
5863       /* Add the main thread to the thread list.  */
5864       thread_info *thr = add_thread_silent (inferior_ptid);
5865       /* Don't consider the thread stopped until we've processed the
5866          saved stop reply.  */
5867       set_executing (thr->ptid, true);
5868     }
5869
5870   /* Next, if the target can specify a description, read it.  We do
5871      this before anything involving memory or registers.  */
5872   target_find_description ();
5873
5874   if (!target_is_non_stop_p ())
5875     {
5876       /* Use the previously fetched status.  */
5877       gdb_assert (wait_status != NULL);
5878
5879       if (target_can_async_p ())
5880         {
5881           struct notif_event *reply
5882             =  remote_notif_parse (this, &notif_client_stop, wait_status);
5883
5884           push_stop_reply ((struct stop_reply *) reply);
5885
5886           target_async (1);
5887         }
5888       else
5889         {
5890           gdb_assert (wait_status != NULL);
5891           strcpy (rs->buf.data (), wait_status);
5892           rs->cached_wait_status = 1;
5893         }
5894     }
5895   else
5896     gdb_assert (wait_status == NULL);
5897 }
5898
5899 /* Implementation of the to_post_attach method.  */
5900
5901 void
5902 extended_remote_target::post_attach (int pid)
5903 {
5904   /* Get text, data & bss offsets.  */
5905   get_offsets ();
5906
5907   /* In certain cases GDB might not have had the chance to start
5908      symbol lookup up until now.  This could happen if the debugged
5909      binary is not using shared libraries, the vsyscall page is not
5910      present (on Linux) and the binary itself hadn't changed since the
5911      debugging process was started.  */
5912   if (symfile_objfile != NULL)
5913     remote_check_symbols();
5914 }
5915
5916 \f
5917 /* Check for the availability of vCont.  This function should also check
5918    the response.  */
5919
5920 void
5921 remote_target::remote_vcont_probe ()
5922 {
5923   remote_state *rs = get_remote_state ();
5924   char *buf;
5925
5926   strcpy (rs->buf.data (), "vCont?");
5927   putpkt (rs->buf);
5928   getpkt (&rs->buf, 0);
5929   buf = rs->buf.data ();
5930
5931   /* Make sure that the features we assume are supported.  */
5932   if (startswith (buf, "vCont"))
5933     {
5934       char *p = &buf[5];
5935       int support_c, support_C;
5936
5937       rs->supports_vCont.s = 0;
5938       rs->supports_vCont.S = 0;
5939       support_c = 0;
5940       support_C = 0;
5941       rs->supports_vCont.t = 0;
5942       rs->supports_vCont.r = 0;
5943       while (p && *p == ';')
5944         {
5945           p++;
5946           if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
5947             rs->supports_vCont.s = 1;
5948           else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
5949             rs->supports_vCont.S = 1;
5950           else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
5951             support_c = 1;
5952           else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
5953             support_C = 1;
5954           else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
5955             rs->supports_vCont.t = 1;
5956           else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0))
5957             rs->supports_vCont.r = 1;
5958
5959           p = strchr (p, ';');
5960         }
5961
5962       /* If c, and C are not all supported, we can't use vCont.  Clearing
5963          BUF will make packet_ok disable the packet.  */
5964       if (!support_c || !support_C)
5965         buf[0] = 0;
5966     }
5967
5968   packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCont]);
5969 }
5970
5971 /* Helper function for building "vCont" resumptions.  Write a
5972    resumption to P.  ENDP points to one-passed-the-end of the buffer
5973    we're allowed to write to.  Returns BUF+CHARACTERS_WRITTEN.  The
5974    thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5975    resumed thread should be single-stepped and/or signalled.  If PTID
5976    equals minus_one_ptid, then all threads are resumed; if PTID
5977    represents a process, then all threads of the process are resumed;
5978    the thread to be stepped and/or signalled is given in the global
5979    INFERIOR_PTID.  */
5980
5981 char *
5982 remote_target::append_resumption (char *p, char *endp,
5983                                   ptid_t ptid, int step, gdb_signal siggnal)
5984 {
5985   struct remote_state *rs = get_remote_state ();
5986
5987   if (step && siggnal != GDB_SIGNAL_0)
5988     p += xsnprintf (p, endp - p, ";S%02x", siggnal);
5989   else if (step
5990            /* GDB is willing to range step.  */
5991            && use_range_stepping
5992            /* Target supports range stepping.  */
5993            && rs->supports_vCont.r
5994            /* We don't currently support range stepping multiple
5995               threads with a wildcard (though the protocol allows it,
5996               so stubs shouldn't make an active effort to forbid
5997               it).  */
5998            && !(remote_multi_process_p (rs) && ptid.is_pid ()))
5999     {
6000       struct thread_info *tp;
6001
6002       if (ptid == minus_one_ptid)
6003         {
6004           /* If we don't know about the target thread's tid, then
6005              we're resuming magic_null_ptid (see caller).  */
6006           tp = find_thread_ptid (magic_null_ptid);
6007         }
6008       else
6009         tp = find_thread_ptid (ptid);
6010       gdb_assert (tp != NULL);
6011
6012       if (tp->control.may_range_step)
6013         {
6014           int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
6015
6016           p += xsnprintf (p, endp - p, ";r%s,%s",
6017                           phex_nz (tp->control.step_range_start,
6018                                    addr_size),
6019                           phex_nz (tp->control.step_range_end,
6020                                    addr_size));
6021         }
6022       else
6023         p += xsnprintf (p, endp - p, ";s");
6024     }
6025   else if (step)
6026     p += xsnprintf (p, endp - p, ";s");
6027   else if (siggnal != GDB_SIGNAL_0)
6028     p += xsnprintf (p, endp - p, ";C%02x", siggnal);
6029   else
6030     p += xsnprintf (p, endp - p, ";c");
6031
6032   if (remote_multi_process_p (rs) && ptid.is_pid ())
6033     {
6034       ptid_t nptid;
6035
6036       /* All (-1) threads of process.  */
6037       nptid = ptid_t (ptid.pid (), -1, 0);
6038
6039       p += xsnprintf (p, endp - p, ":");
6040       p = write_ptid (p, endp, nptid);
6041     }
6042   else if (ptid != minus_one_ptid)
6043     {
6044       p += xsnprintf (p, endp - p, ":");
6045       p = write_ptid (p, endp, ptid);
6046     }
6047
6048   return p;
6049 }
6050
6051 /* Clear the thread's private info on resume.  */
6052
6053 static void
6054 resume_clear_thread_private_info (struct thread_info *thread)
6055 {
6056   if (thread->priv != NULL)
6057     {
6058       remote_thread_info *priv = get_remote_thread_info (thread);
6059
6060       priv->stop_reason = TARGET_STOPPED_BY_NO_REASON;
6061       priv->watch_data_address = 0;
6062     }
6063 }
6064
6065 /* Append a vCont continue-with-signal action for threads that have a
6066    non-zero stop signal.  */
6067
6068 char *
6069 remote_target::append_pending_thread_resumptions (char *p, char *endp,
6070                                                   ptid_t ptid)
6071 {
6072   for (thread_info *thread : all_non_exited_threads (ptid))
6073     if (inferior_ptid != thread->ptid
6074         && thread->suspend.stop_signal != GDB_SIGNAL_0)
6075       {
6076         p = append_resumption (p, endp, thread->ptid,
6077                                0, thread->suspend.stop_signal);
6078         thread->suspend.stop_signal = GDB_SIGNAL_0;
6079         resume_clear_thread_private_info (thread);
6080       }
6081
6082   return p;
6083 }
6084
6085 /* Set the target running, using the packets that use Hc
6086    (c/s/C/S).  */
6087
6088 void
6089 remote_target::remote_resume_with_hc (ptid_t ptid, int step,
6090                                       gdb_signal siggnal)
6091 {
6092   struct remote_state *rs = get_remote_state ();
6093   char *buf;
6094
6095   rs->last_sent_signal = siggnal;
6096   rs->last_sent_step = step;
6097
6098   /* The c/s/C/S resume packets use Hc, so set the continue
6099      thread.  */
6100   if (ptid == minus_one_ptid)
6101     set_continue_thread (any_thread_ptid);
6102   else
6103     set_continue_thread (ptid);
6104
6105   for (thread_info *thread : all_non_exited_threads ())
6106     resume_clear_thread_private_info (thread);
6107
6108   buf = rs->buf.data ();
6109   if (::execution_direction == EXEC_REVERSE)
6110     {
6111       /* We don't pass signals to the target in reverse exec mode.  */
6112       if (info_verbose && siggnal != GDB_SIGNAL_0)
6113         warning (_(" - Can't pass signal %d to target in reverse: ignored."),
6114                  siggnal);
6115
6116       if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
6117         error (_("Remote reverse-step not supported."));
6118       if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
6119         error (_("Remote reverse-continue not supported."));
6120
6121       strcpy (buf, step ? "bs" : "bc");
6122     }
6123   else if (siggnal != GDB_SIGNAL_0)
6124     {
6125       buf[0] = step ? 'S' : 'C';
6126       buf[1] = tohex (((int) siggnal >> 4) & 0xf);
6127       buf[2] = tohex (((int) siggnal) & 0xf);
6128       buf[3] = '\0';
6129     }
6130   else
6131     strcpy (buf, step ? "s" : "c");
6132
6133   putpkt (buf);
6134 }
6135
6136 /* Resume the remote inferior by using a "vCont" packet.  The thread
6137    to be resumed is PTID; STEP and SIGGNAL indicate whether the
6138    resumed thread should be single-stepped and/or signalled.  If PTID
6139    equals minus_one_ptid, then all threads are resumed; the thread to
6140    be stepped and/or signalled is given in the global INFERIOR_PTID.
6141    This function returns non-zero iff it resumes the inferior.
6142
6143    This function issues a strict subset of all possible vCont commands
6144    at the moment.  */
6145
6146 int
6147 remote_target::remote_resume_with_vcont (ptid_t ptid, int step,
6148                                          enum gdb_signal siggnal)
6149 {
6150   struct remote_state *rs = get_remote_state ();
6151   char *p;
6152   char *endp;
6153
6154   /* No reverse execution actions defined for vCont.  */
6155   if (::execution_direction == EXEC_REVERSE)
6156     return 0;
6157
6158   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6159     remote_vcont_probe ();
6160
6161   if (packet_support (PACKET_vCont) == PACKET_DISABLE)
6162     return 0;
6163
6164   p = rs->buf.data ();
6165   endp = p + get_remote_packet_size ();
6166
6167   /* If we could generate a wider range of packets, we'd have to worry
6168      about overflowing BUF.  Should there be a generic
6169      "multi-part-packet" packet?  */
6170
6171   p += xsnprintf (p, endp - p, "vCont");
6172
6173   if (ptid == magic_null_ptid)
6174     {
6175       /* MAGIC_NULL_PTID means that we don't have any active threads,
6176          so we don't have any TID numbers the inferior will
6177          understand.  Make sure to only send forms that do not specify
6178          a TID.  */
6179       append_resumption (p, endp, minus_one_ptid, step, siggnal);
6180     }
6181   else if (ptid == minus_one_ptid || ptid.is_pid ())
6182     {
6183       /* Resume all threads (of all processes, or of a single
6184          process), with preference for INFERIOR_PTID.  This assumes
6185          inferior_ptid belongs to the set of all threads we are about
6186          to resume.  */
6187       if (step || siggnal != GDB_SIGNAL_0)
6188         {
6189           /* Step inferior_ptid, with or without signal.  */
6190           p = append_resumption (p, endp, inferior_ptid, step, siggnal);
6191         }
6192
6193       /* Also pass down any pending signaled resumption for other
6194          threads not the current.  */
6195       p = append_pending_thread_resumptions (p, endp, ptid);
6196
6197       /* And continue others without a signal.  */
6198       append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
6199     }
6200   else
6201     {
6202       /* Scheduler locking; resume only PTID.  */
6203       append_resumption (p, endp, ptid, step, siggnal);
6204     }
6205
6206   gdb_assert (strlen (rs->buf.data ()) < get_remote_packet_size ());
6207   putpkt (rs->buf);
6208
6209   if (target_is_non_stop_p ())
6210     {
6211       /* In non-stop, the stub replies to vCont with "OK".  The stop
6212          reply will be reported asynchronously by means of a `%Stop'
6213          notification.  */
6214       getpkt (&rs->buf, 0);
6215       if (strcmp (rs->buf.data (), "OK") != 0)
6216         error (_("Unexpected vCont reply in non-stop mode: %s"),
6217                rs->buf.data ());
6218     }
6219
6220   return 1;
6221 }
6222
6223 /* Tell the remote machine to resume.  */
6224
6225 void
6226 remote_target::resume (ptid_t ptid, int step, enum gdb_signal siggnal)
6227 {
6228   struct remote_state *rs = get_remote_state ();
6229
6230   /* When connected in non-stop mode, the core resumes threads
6231      individually.  Resuming remote threads directly in target_resume
6232      would thus result in sending one packet per thread.  Instead, to
6233      minimize roundtrip latency, here we just store the resume
6234      request; the actual remote resumption will be done in
6235      target_commit_resume / remote_commit_resume, where we'll be able
6236      to do vCont action coalescing.  */
6237   if (target_is_non_stop_p () && ::execution_direction != EXEC_REVERSE)
6238     {
6239       remote_thread_info *remote_thr;
6240
6241       if (minus_one_ptid == ptid || ptid.is_pid ())
6242         remote_thr = get_remote_thread_info (inferior_ptid);
6243       else
6244         remote_thr = get_remote_thread_info (ptid);
6245
6246       remote_thr->last_resume_step = step;
6247       remote_thr->last_resume_sig = siggnal;
6248       return;
6249     }
6250
6251   /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
6252      (explained in remote-notif.c:handle_notification) so
6253      remote_notif_process is not called.  We need find a place where
6254      it is safe to start a 'vNotif' sequence.  It is good to do it
6255      before resuming inferior, because inferior was stopped and no RSP
6256      traffic at that moment.  */
6257   if (!target_is_non_stop_p ())
6258     remote_notif_process (rs->notif_state, &notif_client_stop);
6259
6260   rs->last_resume_exec_dir = ::execution_direction;
6261
6262   /* Prefer vCont, and fallback to s/c/S/C, which use Hc.  */
6263   if (!remote_resume_with_vcont (ptid, step, siggnal))
6264     remote_resume_with_hc (ptid, step, siggnal);
6265
6266   /* We are about to start executing the inferior, let's register it
6267      with the event loop.  NOTE: this is the one place where all the
6268      execution commands end up.  We could alternatively do this in each
6269      of the execution commands in infcmd.c.  */
6270   /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
6271      into infcmd.c in order to allow inferior function calls to work
6272      NOT asynchronously.  */
6273   if (target_can_async_p ())
6274     target_async (1);
6275
6276   /* We've just told the target to resume.  The remote server will
6277      wait for the inferior to stop, and then send a stop reply.  In
6278      the mean time, we can't start another command/query ourselves
6279      because the stub wouldn't be ready to process it.  This applies
6280      only to the base all-stop protocol, however.  In non-stop (which
6281      only supports vCont), the stub replies with an "OK", and is
6282      immediate able to process further serial input.  */
6283   if (!target_is_non_stop_p ())
6284     rs->waiting_for_stop_reply = 1;
6285 }
6286
6287 static int is_pending_fork_parent_thread (struct thread_info *thread);
6288
6289 /* Private per-inferior info for target remote processes.  */
6290
6291 struct remote_inferior : public private_inferior
6292 {
6293   /* Whether we can send a wildcard vCont for this process.  */
6294   bool may_wildcard_vcont = true;
6295 };
6296
6297 /* Get the remote private inferior data associated to INF.  */
6298
6299 static remote_inferior *
6300 get_remote_inferior (inferior *inf)
6301 {
6302   if (inf->priv == NULL)
6303     inf->priv.reset (new remote_inferior);
6304
6305   return static_cast<remote_inferior *> (inf->priv.get ());
6306 }
6307
6308 /* Class used to track the construction of a vCont packet in the
6309    outgoing packet buffer.  This is used to send multiple vCont
6310    packets if we have more actions than would fit a single packet.  */
6311
6312 class vcont_builder
6313 {
6314 public:
6315   explicit vcont_builder (remote_target *remote)
6316     : m_remote (remote)
6317   {
6318     restart ();
6319   }
6320
6321   void flush ();
6322   void push_action (ptid_t ptid, bool step, gdb_signal siggnal);
6323
6324 private:
6325   void restart ();
6326
6327   /* The remote target.  */
6328   remote_target *m_remote;
6329
6330   /* Pointer to the first action.  P points here if no action has been
6331      appended yet.  */
6332   char *m_first_action;
6333
6334   /* Where the next action will be appended.  */
6335   char *m_p;
6336
6337   /* The end of the buffer.  Must never write past this.  */
6338   char *m_endp;
6339 };
6340
6341 /* Prepare the outgoing buffer for a new vCont packet.  */
6342
6343 void
6344 vcont_builder::restart ()
6345 {
6346   struct remote_state *rs = m_remote->get_remote_state ();
6347
6348   m_p = rs->buf.data ();
6349   m_endp = m_p + m_remote->get_remote_packet_size ();
6350   m_p += xsnprintf (m_p, m_endp - m_p, "vCont");
6351   m_first_action = m_p;
6352 }
6353
6354 /* If the vCont packet being built has any action, send it to the
6355    remote end.  */
6356
6357 void
6358 vcont_builder::flush ()
6359 {
6360   struct remote_state *rs;
6361
6362   if (m_p == m_first_action)
6363     return;
6364
6365   rs = m_remote->get_remote_state ();
6366   m_remote->putpkt (rs->buf);
6367   m_remote->getpkt (&rs->buf, 0);
6368   if (strcmp (rs->buf.data (), "OK") != 0)
6369     error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf.data ());
6370 }
6371
6372 /* The largest action is range-stepping, with its two addresses.  This
6373    is more than sufficient.  If a new, bigger action is created, it'll
6374    quickly trigger a failed assertion in append_resumption (and we'll
6375    just bump this).  */
6376 #define MAX_ACTION_SIZE 200
6377
6378 /* Append a new vCont action in the outgoing packet being built.  If
6379    the action doesn't fit the packet along with previous actions, push
6380    what we've got so far to the remote end and start over a new vCont
6381    packet (with the new action).  */
6382
6383 void
6384 vcont_builder::push_action (ptid_t ptid, bool step, gdb_signal siggnal)
6385 {
6386   char buf[MAX_ACTION_SIZE + 1];
6387
6388   char *endp = m_remote->append_resumption (buf, buf + sizeof (buf),
6389                                             ptid, step, siggnal);
6390
6391   /* Check whether this new action would fit in the vCont packet along
6392      with previous actions.  If not, send what we've got so far and
6393      start a new vCont packet.  */
6394   size_t rsize = endp - buf;
6395   if (rsize > m_endp - m_p)
6396     {
6397       flush ();
6398       restart ();
6399
6400       /* Should now fit.  */
6401       gdb_assert (rsize <= m_endp - m_p);
6402     }
6403
6404   memcpy (m_p, buf, rsize);
6405   m_p += rsize;
6406   *m_p = '\0';
6407 }
6408
6409 /* to_commit_resume implementation.  */
6410
6411 void
6412 remote_target::commit_resume ()
6413 {
6414   int any_process_wildcard;
6415   int may_global_wildcard_vcont;
6416
6417   /* If connected in all-stop mode, we'd send the remote resume
6418      request directly from remote_resume.  Likewise if
6419      reverse-debugging, as there are no defined vCont actions for
6420      reverse execution.  */
6421   if (!target_is_non_stop_p () || ::execution_direction == EXEC_REVERSE)
6422     return;
6423
6424   /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
6425      instead of resuming all threads of each process individually.
6426      However, if any thread of a process must remain halted, we can't
6427      send wildcard resumes and must send one action per thread.
6428
6429      Care must be taken to not resume threads/processes the server
6430      side already told us are stopped, but the core doesn't know about
6431      yet, because the events are still in the vStopped notification
6432      queue.  For example:
6433
6434        #1 => vCont s:p1.1;c
6435        #2 <= OK
6436        #3 <= %Stopped T05 p1.1
6437        #4 => vStopped
6438        #5 <= T05 p1.2
6439        #6 => vStopped
6440        #7 <= OK
6441        #8 (infrun handles the stop for p1.1 and continues stepping)
6442        #9 => vCont s:p1.1;c
6443
6444      The last vCont above would resume thread p1.2 by mistake, because
6445      the server has no idea that the event for p1.2 had not been
6446      handled yet.
6447
6448      The server side must similarly ignore resume actions for the
6449      thread that has a pending %Stopped notification (and any other
6450      threads with events pending), until GDB acks the notification
6451      with vStopped.  Otherwise, e.g., the following case is
6452      mishandled:
6453
6454        #1 => g  (or any other packet)
6455        #2 <= [registers]
6456        #3 <= %Stopped T05 p1.2
6457        #4 => vCont s:p1.1;c
6458        #5 <= OK
6459
6460      Above, the server must not resume thread p1.2.  GDB can't know
6461      that p1.2 stopped until it acks the %Stopped notification, and
6462      since from GDB's perspective all threads should be running, it
6463      sends a "c" action.
6464
6465      Finally, special care must also be given to handling fork/vfork
6466      events.  A (v)fork event actually tells us that two processes
6467      stopped -- the parent and the child.  Until we follow the fork,
6468      we must not resume the child.  Therefore, if we have a pending
6469      fork follow, we must not send a global wildcard resume action
6470      (vCont;c).  We can still send process-wide wildcards though.  */
6471
6472   /* Start by assuming a global wildcard (vCont;c) is possible.  */
6473   may_global_wildcard_vcont = 1;
6474
6475   /* And assume every process is individually wildcard-able too.  */
6476   for (inferior *inf : all_non_exited_inferiors ())
6477     {
6478       remote_inferior *priv = get_remote_inferior (inf);
6479
6480       priv->may_wildcard_vcont = true;
6481     }
6482
6483   /* Check for any pending events (not reported or processed yet) and
6484      disable process and global wildcard resumes appropriately.  */
6485   check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
6486
6487   for (thread_info *tp : all_non_exited_threads ())
6488     {
6489       /* If a thread of a process is not meant to be resumed, then we
6490          can't wildcard that process.  */
6491       if (!tp->executing)
6492         {
6493           get_remote_inferior (tp->inf)->may_wildcard_vcont = false;
6494
6495           /* And if we can't wildcard a process, we can't wildcard
6496              everything either.  */
6497           may_global_wildcard_vcont = 0;
6498           continue;
6499         }
6500
6501       /* If a thread is the parent of an unfollowed fork, then we
6502          can't do a global wildcard, as that would resume the fork
6503          child.  */
6504       if (is_pending_fork_parent_thread (tp))
6505         may_global_wildcard_vcont = 0;
6506     }
6507
6508   /* Now let's build the vCont packet(s).  Actions must be appended
6509      from narrower to wider scopes (thread -> process -> global).  If
6510      we end up with too many actions for a single packet vcont_builder
6511      flushes the current vCont packet to the remote side and starts a
6512      new one.  */
6513   struct vcont_builder vcont_builder (this);
6514
6515   /* Threads first.  */
6516   for (thread_info *tp : all_non_exited_threads ())
6517     {
6518       remote_thread_info *remote_thr = get_remote_thread_info (tp);
6519
6520       if (!tp->executing || remote_thr->vcont_resumed)
6521         continue;
6522
6523       gdb_assert (!thread_is_in_step_over_chain (tp));
6524
6525       if (!remote_thr->last_resume_step
6526           && remote_thr->last_resume_sig == GDB_SIGNAL_0
6527           && get_remote_inferior (tp->inf)->may_wildcard_vcont)
6528         {
6529           /* We'll send a wildcard resume instead.  */
6530           remote_thr->vcont_resumed = 1;
6531           continue;
6532         }
6533
6534       vcont_builder.push_action (tp->ptid,
6535                                  remote_thr->last_resume_step,
6536                                  remote_thr->last_resume_sig);
6537       remote_thr->vcont_resumed = 1;
6538     }
6539
6540   /* Now check whether we can send any process-wide wildcard.  This is
6541      to avoid sending a global wildcard in the case nothing is
6542      supposed to be resumed.  */
6543   any_process_wildcard = 0;
6544
6545   for (inferior *inf : all_non_exited_inferiors ())
6546     {
6547       if (get_remote_inferior (inf)->may_wildcard_vcont)
6548         {
6549           any_process_wildcard = 1;
6550           break;
6551         }
6552     }
6553
6554   if (any_process_wildcard)
6555     {
6556       /* If all processes are wildcard-able, then send a single "c"
6557          action, otherwise, send an "all (-1) threads of process"
6558          continue action for each running process, if any.  */
6559       if (may_global_wildcard_vcont)
6560         {
6561           vcont_builder.push_action (minus_one_ptid,
6562                                      false, GDB_SIGNAL_0);
6563         }
6564       else
6565         {
6566           for (inferior *inf : all_non_exited_inferiors ())
6567             {
6568               if (get_remote_inferior (inf)->may_wildcard_vcont)
6569                 {
6570                   vcont_builder.push_action (ptid_t (inf->pid),
6571                                              false, GDB_SIGNAL_0);
6572                 }
6573             }
6574         }
6575     }
6576
6577   vcont_builder.flush ();
6578 }
6579
6580 \f
6581
6582 /* Non-stop version of target_stop.  Uses `vCont;t' to stop a remote
6583    thread, all threads of a remote process, or all threads of all
6584    processes.  */
6585
6586 void
6587 remote_target::remote_stop_ns (ptid_t ptid)
6588 {
6589   struct remote_state *rs = get_remote_state ();
6590   char *p = rs->buf.data ();
6591   char *endp = p + get_remote_packet_size ();
6592
6593   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6594     remote_vcont_probe ();
6595
6596   if (!rs->supports_vCont.t)
6597     error (_("Remote server does not support stopping threads"));
6598
6599   if (ptid == minus_one_ptid
6600       || (!remote_multi_process_p (rs) && ptid.is_pid ()))
6601     p += xsnprintf (p, endp - p, "vCont;t");
6602   else
6603     {
6604       ptid_t nptid;
6605
6606       p += xsnprintf (p, endp - p, "vCont;t:");
6607
6608       if (ptid.is_pid ())
6609           /* All (-1) threads of process.  */
6610         nptid = ptid_t (ptid.pid (), -1, 0);
6611       else
6612         {
6613           /* Small optimization: if we already have a stop reply for
6614              this thread, no use in telling the stub we want this
6615              stopped.  */
6616           if (peek_stop_reply (ptid))
6617             return;
6618
6619           nptid = ptid;
6620         }
6621
6622       write_ptid (p, endp, nptid);
6623     }
6624
6625   /* In non-stop, we get an immediate OK reply.  The stop reply will
6626      come in asynchronously by notification.  */
6627   putpkt (rs->buf);
6628   getpkt (&rs->buf, 0);
6629   if (strcmp (rs->buf.data (), "OK") != 0)
6630     error (_("Stopping %s failed: %s"), target_pid_to_str (ptid).c_str (),
6631            rs->buf.data ());
6632 }
6633
6634 /* All-stop version of target_interrupt.  Sends a break or a ^C to
6635    interrupt the remote target.  It is undefined which thread of which
6636    process reports the interrupt.  */
6637
6638 void
6639 remote_target::remote_interrupt_as ()
6640 {
6641   struct remote_state *rs = get_remote_state ();
6642
6643   rs->ctrlc_pending_p = 1;
6644
6645   /* If the inferior is stopped already, but the core didn't know
6646      about it yet, just ignore the request.  The cached wait status
6647      will be collected in remote_wait.  */
6648   if (rs->cached_wait_status)
6649     return;
6650
6651   /* Send interrupt_sequence to remote target.  */
6652   send_interrupt_sequence ();
6653 }
6654
6655 /* Non-stop version of target_interrupt.  Uses `vCtrlC' to interrupt
6656    the remote target.  It is undefined which thread of which process
6657    reports the interrupt.  Throws an error if the packet is not
6658    supported by the server.  */
6659
6660 void
6661 remote_target::remote_interrupt_ns ()
6662 {
6663   struct remote_state *rs = get_remote_state ();
6664   char *p = rs->buf.data ();
6665   char *endp = p + get_remote_packet_size ();
6666
6667   xsnprintf (p, endp - p, "vCtrlC");
6668
6669   /* In non-stop, we get an immediate OK reply.  The stop reply will
6670      come in asynchronously by notification.  */
6671   putpkt (rs->buf);
6672   getpkt (&rs->buf, 0);
6673
6674   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
6675     {
6676     case PACKET_OK:
6677       break;
6678     case PACKET_UNKNOWN:
6679       error (_("No support for interrupting the remote target."));
6680     case PACKET_ERROR:
6681       error (_("Interrupting target failed: %s"), rs->buf.data ());
6682     }
6683 }
6684
6685 /* Implement the to_stop function for the remote targets.  */
6686
6687 void
6688 remote_target::stop (ptid_t ptid)
6689 {
6690   if (remote_debug)
6691     fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
6692
6693   if (target_is_non_stop_p ())
6694     remote_stop_ns (ptid);
6695   else
6696     {
6697       /* We don't currently have a way to transparently pause the
6698          remote target in all-stop mode.  Interrupt it instead.  */
6699       remote_interrupt_as ();
6700     }
6701 }
6702
6703 /* Implement the to_interrupt function for the remote targets.  */
6704
6705 void
6706 remote_target::interrupt ()
6707 {
6708   if (remote_debug)
6709     fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
6710
6711   if (target_is_non_stop_p ())
6712     remote_interrupt_ns ();
6713   else
6714     remote_interrupt_as ();
6715 }
6716
6717 /* Implement the to_pass_ctrlc function for the remote targets.  */
6718
6719 void
6720 remote_target::pass_ctrlc ()
6721 {
6722   struct remote_state *rs = get_remote_state ();
6723
6724   if (remote_debug)
6725     fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
6726
6727   /* If we're starting up, we're not fully synced yet.  Quit
6728      immediately.  */
6729   if (rs->starting_up)
6730     quit ();
6731   /* If ^C has already been sent once, offer to disconnect.  */
6732   else if (rs->ctrlc_pending_p)
6733     interrupt_query ();
6734   else
6735     target_interrupt ();
6736 }
6737
6738 /* Ask the user what to do when an interrupt is received.  */
6739
6740 void
6741 remote_target::interrupt_query ()
6742 {
6743   struct remote_state *rs = get_remote_state ();
6744
6745   if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p)
6746     {
6747       if (query (_("The target is not responding to interrupt requests.\n"
6748                    "Stop debugging it? ")))
6749         {
6750           remote_unpush_target ();
6751           throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
6752         }
6753     }
6754   else
6755     {
6756       if (query (_("Interrupted while waiting for the program.\n"
6757                    "Give up waiting? ")))
6758         quit ();
6759     }
6760 }
6761
6762 /* Enable/disable target terminal ownership.  Most targets can use
6763    terminal groups to control terminal ownership.  Remote targets are
6764    different in that explicit transfer of ownership to/from GDB/target
6765    is required.  */
6766
6767 void
6768 remote_target::terminal_inferior ()
6769 {
6770   /* NOTE: At this point we could also register our selves as the
6771      recipient of all input.  Any characters typed could then be
6772      passed on down to the target.  */
6773 }
6774
6775 void
6776 remote_target::terminal_ours ()
6777 {
6778 }
6779
6780 static void
6781 remote_console_output (const char *msg)
6782 {
6783   const char *p;
6784
6785   for (p = msg; p[0] && p[1]; p += 2)
6786     {
6787       char tb[2];
6788       char c = fromhex (p[0]) * 16 + fromhex (p[1]);
6789
6790       tb[0] = c;
6791       tb[1] = 0;
6792       fputs_unfiltered (tb, gdb_stdtarg);
6793     }
6794   gdb_flush (gdb_stdtarg);
6795 }
6796
6797 struct stop_reply : public notif_event
6798 {
6799   ~stop_reply ();
6800
6801   /* The identifier of the thread about this event  */
6802   ptid_t ptid;
6803
6804   /* The remote state this event is associated with.  When the remote
6805      connection, represented by a remote_state object, is closed,
6806      all the associated stop_reply events should be released.  */
6807   struct remote_state *rs;
6808
6809   struct target_waitstatus ws;
6810
6811   /* The architecture associated with the expedited registers.  */
6812   gdbarch *arch;
6813
6814   /* Expedited registers.  This makes remote debugging a bit more
6815      efficient for those targets that provide critical registers as
6816      part of their normal status mechanism (as another roundtrip to
6817      fetch them is avoided).  */
6818   std::vector<cached_reg_t> regcache;
6819
6820   enum target_stop_reason stop_reason;
6821
6822   CORE_ADDR watch_data_address;
6823
6824   int core;
6825 };
6826
6827 /* Return the length of the stop reply queue.  */
6828
6829 int
6830 remote_target::stop_reply_queue_length ()
6831 {
6832   remote_state *rs = get_remote_state ();
6833   return rs->stop_reply_queue.size ();
6834 }
6835
6836 void
6837 remote_notif_stop_parse (remote_target *remote,
6838                          struct notif_client *self, const char *buf,
6839                          struct notif_event *event)
6840 {
6841   remote->remote_parse_stop_reply (buf, (struct stop_reply *) event);
6842 }
6843
6844 static void
6845 remote_notif_stop_ack (remote_target *remote,
6846                        struct notif_client *self, const char *buf,
6847                        struct notif_event *event)
6848 {
6849   struct stop_reply *stop_reply = (struct stop_reply *) event;
6850
6851   /* acknowledge */
6852   putpkt (remote, self->ack_command);
6853
6854   if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
6855     {
6856       /* We got an unknown stop reply.  */
6857       error (_("Unknown stop reply"));
6858     }
6859
6860   remote->push_stop_reply (stop_reply);
6861 }
6862
6863 static int
6864 remote_notif_stop_can_get_pending_events (remote_target *remote,
6865                                           struct notif_client *self)
6866 {
6867   /* We can't get pending events in remote_notif_process for
6868      notification stop, and we have to do this in remote_wait_ns
6869      instead.  If we fetch all queued events from stub, remote stub
6870      may exit and we have no chance to process them back in
6871      remote_wait_ns.  */
6872   remote_state *rs = remote->get_remote_state ();
6873   mark_async_event_handler (rs->remote_async_inferior_event_token);
6874   return 0;
6875 }
6876
6877 stop_reply::~stop_reply ()
6878 {
6879   for (cached_reg_t &reg : regcache)
6880     xfree (reg.data);
6881 }
6882
6883 static notif_event_up
6884 remote_notif_stop_alloc_reply ()
6885 {
6886   return notif_event_up (new struct stop_reply ());
6887 }
6888
6889 /* A client of notification Stop.  */
6890
6891 struct notif_client notif_client_stop =
6892 {
6893   "Stop",
6894   "vStopped",
6895   remote_notif_stop_parse,
6896   remote_notif_stop_ack,
6897   remote_notif_stop_can_get_pending_events,
6898   remote_notif_stop_alloc_reply,
6899   REMOTE_NOTIF_STOP,
6900 };
6901
6902 /* Determine if THREAD_PTID is a pending fork parent thread.  ARG contains
6903    the pid of the process that owns the threads we want to check, or
6904    -1 if we want to check all threads.  */
6905
6906 static int
6907 is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
6908                         ptid_t thread_ptid)
6909 {
6910   if (ws->kind == TARGET_WAITKIND_FORKED
6911       || ws->kind == TARGET_WAITKIND_VFORKED)
6912     {
6913       if (event_pid == -1 || event_pid == thread_ptid.pid ())
6914         return 1;
6915     }
6916
6917   return 0;
6918 }
6919
6920 /* Return the thread's pending status used to determine whether the
6921    thread is a fork parent stopped at a fork event.  */
6922
6923 static struct target_waitstatus *
6924 thread_pending_fork_status (struct thread_info *thread)
6925 {
6926   if (thread->suspend.waitstatus_pending_p)
6927     return &thread->suspend.waitstatus;
6928   else
6929     return &thread->pending_follow;
6930 }
6931
6932 /* Determine if THREAD is a pending fork parent thread.  */
6933
6934 static int
6935 is_pending_fork_parent_thread (struct thread_info *thread)
6936 {
6937   struct target_waitstatus *ws = thread_pending_fork_status (thread);
6938   int pid = -1;
6939
6940   return is_pending_fork_parent (ws, pid, thread->ptid);
6941 }
6942
6943 /* If CONTEXT contains any fork child threads that have not been
6944    reported yet, remove them from the CONTEXT list.  If such a
6945    thread exists it is because we are stopped at a fork catchpoint
6946    and have not yet called follow_fork, which will set up the
6947    host-side data structures for the new process.  */
6948
6949 void
6950 remote_target::remove_new_fork_children (threads_listing_context *context)
6951 {
6952   int pid = -1;
6953   struct notif_client *notif = &notif_client_stop;
6954
6955   /* For any threads stopped at a fork event, remove the corresponding
6956      fork child threads from the CONTEXT list.  */
6957   for (thread_info *thread : all_non_exited_threads ())
6958     {
6959       struct target_waitstatus *ws = thread_pending_fork_status (thread);
6960
6961       if (is_pending_fork_parent (ws, pid, thread->ptid))
6962         context->remove_thread (ws->value.related_pid);
6963     }
6964
6965   /* Check for any pending fork events (not reported or processed yet)
6966      in process PID and remove those fork child threads from the
6967      CONTEXT list as well.  */
6968   remote_notif_get_pending_events (notif);
6969   for (auto &event : get_remote_state ()->stop_reply_queue)
6970     if (event->ws.kind == TARGET_WAITKIND_FORKED
6971         || event->ws.kind == TARGET_WAITKIND_VFORKED
6972         || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
6973       context->remove_thread (event->ws.value.related_pid);
6974 }
6975
6976 /* Check whether any event pending in the vStopped queue would prevent
6977    a global or process wildcard vCont action.  Clear
6978    *may_global_wildcard if we can't do a global wildcard (vCont;c),
6979    and clear the event inferior's may_wildcard_vcont flag if we can't
6980    do a process-wide wildcard resume (vCont;c:pPID.-1).  */
6981
6982 void
6983 remote_target::check_pending_events_prevent_wildcard_vcont
6984   (int *may_global_wildcard)
6985 {
6986   struct notif_client *notif = &notif_client_stop;
6987
6988   remote_notif_get_pending_events (notif);
6989   for (auto &event : get_remote_state ()->stop_reply_queue)
6990     {
6991       if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
6992           || event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
6993         continue;
6994
6995       if (event->ws.kind == TARGET_WAITKIND_FORKED
6996           || event->ws.kind == TARGET_WAITKIND_VFORKED)
6997         *may_global_wildcard = 0;
6998
6999       struct inferior *inf = find_inferior_ptid (event->ptid);
7000
7001       /* This may be the first time we heard about this process.
7002          Regardless, we must not do a global wildcard resume, otherwise
7003          we'd resume this process too.  */
7004       *may_global_wildcard = 0;
7005       if (inf != NULL)
7006         get_remote_inferior (inf)->may_wildcard_vcont = false;
7007     }
7008 }
7009
7010 /* Discard all pending stop replies of inferior INF.  */
7011
7012 void
7013 remote_target::discard_pending_stop_replies (struct inferior *inf)
7014 {
7015   struct stop_reply *reply;
7016   struct remote_state *rs = get_remote_state ();
7017   struct remote_notif_state *rns = rs->notif_state;
7018
7019   /* This function can be notified when an inferior exists.  When the
7020      target is not remote, the notification state is NULL.  */
7021   if (rs->remote_desc == NULL)
7022     return;
7023
7024   reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];
7025
7026   /* Discard the in-flight notification.  */
7027   if (reply != NULL && reply->ptid.pid () == inf->pid)
7028     {
7029       delete reply;
7030       rns->pending_event[notif_client_stop.id] = NULL;
7031     }
7032
7033   /* Discard the stop replies we have already pulled with
7034      vStopped.  */
7035   auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7036                               rs->stop_reply_queue.end (),
7037                               [=] (const stop_reply_up &event)
7038                               {
7039                                 return event->ptid.pid () == inf->pid;
7040                               });
7041   rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7042 }
7043
7044 /* Discard the stop replies for RS in stop_reply_queue.  */
7045
7046 void
7047 remote_target::discard_pending_stop_replies_in_queue ()
7048 {
7049   remote_state *rs = get_remote_state ();
7050
7051   /* Discard the stop replies we have already pulled with
7052      vStopped.  */
7053   auto iter = std::remove_if (rs->stop_reply_queue.begin (),
7054                               rs->stop_reply_queue.end (),
7055                               [=] (const stop_reply_up &event)
7056                               {
7057                                 return event->rs == rs;
7058                               });
7059   rs->stop_reply_queue.erase (iter, rs->stop_reply_queue.end ());
7060 }
7061
7062 /* Remove the first reply in 'stop_reply_queue' which matches
7063    PTID.  */
7064
7065 struct stop_reply *
7066 remote_target::remote_notif_remove_queued_reply (ptid_t ptid)
7067 {
7068   remote_state *rs = get_remote_state ();
7069
7070   auto iter = std::find_if (rs->stop_reply_queue.begin (),
7071                             rs->stop_reply_queue.end (),
7072                             [=] (const stop_reply_up &event)
7073                             {
7074                               return event->ptid.matches (ptid);
7075                             });
7076   struct stop_reply *result;
7077   if (iter == rs->stop_reply_queue.end ())
7078     result = nullptr;
7079   else
7080     {
7081       result = iter->release ();
7082       rs->stop_reply_queue.erase (iter);
7083     }
7084
7085   if (notif_debug)
7086     fprintf_unfiltered (gdb_stdlog,
7087                         "notif: discard queued event: 'Stop' in %s\n",
7088                         target_pid_to_str (ptid).c_str ());
7089
7090   return result;
7091 }
7092
7093 /* Look for a queued stop reply belonging to PTID.  If one is found,
7094    remove it from the queue, and return it.  Returns NULL if none is
7095    found.  If there are still queued events left to process, tell the
7096    event loop to get back to target_wait soon.  */
7097
7098 struct stop_reply *
7099 remote_target::queued_stop_reply (ptid_t ptid)
7100 {
7101   remote_state *rs = get_remote_state ();
7102   struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
7103
7104   if (!rs->stop_reply_queue.empty ())
7105     {
7106       /* There's still at least an event left.  */
7107       mark_async_event_handler (rs->remote_async_inferior_event_token);
7108     }
7109
7110   return r;
7111 }
7112
7113 /* Push a fully parsed stop reply in the stop reply queue.  Since we
7114    know that we now have at least one queued event left to pass to the
7115    core side, tell the event loop to get back to target_wait soon.  */
7116
7117 void
7118 remote_target::push_stop_reply (struct stop_reply *new_event)
7119 {
7120   remote_state *rs = get_remote_state ();
7121   rs->stop_reply_queue.push_back (stop_reply_up (new_event));
7122
7123   if (notif_debug)
7124     fprintf_unfiltered (gdb_stdlog,
7125                         "notif: push 'Stop' %s to queue %d\n",
7126                         target_pid_to_str (new_event->ptid).c_str (),
7127                         int (rs->stop_reply_queue.size ()));
7128
7129   mark_async_event_handler (rs->remote_async_inferior_event_token);
7130 }
7131
7132 /* Returns true if we have a stop reply for PTID.  */
7133
7134 int
7135 remote_target::peek_stop_reply (ptid_t ptid)
7136 {
7137   remote_state *rs = get_remote_state ();
7138   for (auto &event : rs->stop_reply_queue)
7139     if (ptid == event->ptid
7140         && event->ws.kind == TARGET_WAITKIND_STOPPED)
7141       return 1;
7142   return 0;
7143 }
7144
7145 /* Helper for remote_parse_stop_reply.  Return nonzero if the substring
7146    starting with P and ending with PEND matches PREFIX.  */
7147
7148 static int
7149 strprefix (const char *p, const char *pend, const char *prefix)
7150 {
7151   for ( ; p < pend; p++, prefix++)
7152     if (*p != *prefix)
7153       return 0;
7154   return *prefix == '\0';
7155 }
7156
7157 /* Parse the stop reply in BUF.  Either the function succeeds, and the
7158    result is stored in EVENT, or throws an error.  */
7159
7160 void
7161 remote_target::remote_parse_stop_reply (const char *buf, stop_reply *event)
7162 {
7163   remote_arch_state *rsa = NULL;
7164   ULONGEST addr;
7165   const char *p;
7166   int skipregs = 0;
7167
7168   event->ptid = null_ptid;
7169   event->rs = get_remote_state ();
7170   event->ws.kind = TARGET_WAITKIND_IGNORE;
7171   event->ws.value.integer = 0;
7172   event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
7173   event->regcache.clear ();
7174   event->core = -1;
7175
7176   switch (buf[0])
7177     {
7178     case 'T':           /* Status with PC, SP, FP, ...  */
7179       /* Expedited reply, containing Signal, {regno, reg} repeat.  */
7180       /*  format is:  'Tssn...:r...;n...:r...;n...:r...;#cc', where
7181             ss = signal number
7182             n... = register number
7183             r... = register contents
7184       */
7185
7186       p = &buf[3];      /* after Txx */
7187       while (*p)
7188         {
7189           const char *p1;
7190           int fieldsize;
7191
7192           p1 = strchr (p, ':');
7193           if (p1 == NULL)
7194             error (_("Malformed packet(a) (missing colon): %s\n\
7195 Packet: '%s'\n"),
7196                    p, buf);
7197           if (p == p1)
7198             error (_("Malformed packet(a) (missing register number): %s\n\
7199 Packet: '%s'\n"),
7200                    p, buf);
7201
7202           /* Some "registers" are actually extended stop information.
7203              Note if you're adding a new entry here: GDB 7.9 and
7204              earlier assume that all register "numbers" that start
7205              with an hex digit are real register numbers.  Make sure
7206              the server only sends such a packet if it knows the
7207              client understands it.  */
7208
7209           if (strprefix (p, p1, "thread"))
7210             event->ptid = read_ptid (++p1, &p);
7211           else if (strprefix (p, p1, "syscall_entry"))
7212             {
7213               ULONGEST sysno;
7214
7215               event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY;
7216               p = unpack_varlen_hex (++p1, &sysno);
7217               event->ws.value.syscall_number = (int) sysno;
7218             }
7219           else if (strprefix (p, p1, "syscall_return"))
7220             {
7221               ULONGEST sysno;
7222
7223               event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN;
7224               p = unpack_varlen_hex (++p1, &sysno);
7225               event->ws.value.syscall_number = (int) sysno;
7226             }
7227           else if (strprefix (p, p1, "watch")
7228                    || strprefix (p, p1, "rwatch")
7229                    || strprefix (p, p1, "awatch"))
7230             {
7231               event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
7232               p = unpack_varlen_hex (++p1, &addr);
7233               event->watch_data_address = (CORE_ADDR) addr;
7234             }
7235           else if (strprefix (p, p1, "swbreak"))
7236             {
7237               event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
7238
7239               /* Make sure the stub doesn't forget to indicate support
7240                  with qSupported.  */
7241               if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
7242                 error (_("Unexpected swbreak stop reason"));
7243
7244               /* The value part is documented as "must be empty",
7245                  though we ignore it, in case we ever decide to make
7246                  use of it in a backward compatible way.  */
7247               p = strchrnul (p1 + 1, ';');
7248             }
7249           else if (strprefix (p, p1, "hwbreak"))
7250             {
7251               event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
7252
7253               /* Make sure the stub doesn't forget to indicate support
7254                  with qSupported.  */
7255               if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
7256                 error (_("Unexpected hwbreak stop reason"));
7257
7258               /* See above.  */
7259               p = strchrnul (p1 + 1, ';');
7260             }
7261           else if (strprefix (p, p1, "library"))
7262             {
7263               event->ws.kind = TARGET_WAITKIND_LOADED;
7264               p = strchrnul (p1 + 1, ';');
7265             }
7266           else if (strprefix (p, p1, "replaylog"))
7267             {
7268               event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
7269               /* p1 will indicate "begin" or "end", but it makes
7270                  no difference for now, so ignore it.  */
7271               p = strchrnul (p1 + 1, ';');
7272             }
7273           else if (strprefix (p, p1, "core"))
7274             {
7275               ULONGEST c;
7276
7277               p = unpack_varlen_hex (++p1, &c);
7278               event->core = c;
7279             }
7280           else if (strprefix (p, p1, "fork"))
7281             {
7282               event->ws.value.related_pid = read_ptid (++p1, &p);
7283               event->ws.kind = TARGET_WAITKIND_FORKED;
7284             }
7285           else if (strprefix (p, p1, "vfork"))
7286             {
7287               event->ws.value.related_pid = read_ptid (++p1, &p);
7288               event->ws.kind = TARGET_WAITKIND_VFORKED;
7289             }
7290           else if (strprefix (p, p1, "vforkdone"))
7291             {
7292               event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
7293               p = strchrnul (p1 + 1, ';');
7294             }
7295           else if (strprefix (p, p1, "exec"))
7296             {
7297               ULONGEST ignored;
7298               int pathlen;
7299
7300               /* Determine the length of the execd pathname.  */
7301               p = unpack_varlen_hex (++p1, &ignored);
7302               pathlen = (p - p1) / 2;
7303
7304               /* Save the pathname for event reporting and for
7305                  the next run command.  */
7306               gdb::unique_xmalloc_ptr<char[]> pathname
7307                 ((char *) xmalloc (pathlen + 1));
7308               hex2bin (p1, (gdb_byte *) pathname.get (), pathlen);
7309               pathname[pathlen] = '\0';
7310
7311               /* This is freed during event handling.  */
7312               event->ws.value.execd_pathname = pathname.release ();
7313               event->ws.kind = TARGET_WAITKIND_EXECD;
7314
7315               /* Skip the registers included in this packet, since
7316                  they may be for an architecture different from the
7317                  one used by the original program.  */
7318               skipregs = 1;
7319             }
7320           else if (strprefix (p, p1, "create"))
7321             {
7322               event->ws.kind = TARGET_WAITKIND_THREAD_CREATED;
7323               p = strchrnul (p1 + 1, ';');
7324             }
7325           else
7326             {
7327               ULONGEST pnum;
7328               const char *p_temp;
7329
7330               if (skipregs)
7331                 {
7332                   p = strchrnul (p1 + 1, ';');
7333                   p++;
7334                   continue;
7335                 }
7336
7337               /* Maybe a real ``P'' register number.  */
7338               p_temp = unpack_varlen_hex (p, &pnum);
7339               /* If the first invalid character is the colon, we got a
7340                  register number.  Otherwise, it's an unknown stop
7341                  reason.  */
7342               if (p_temp == p1)
7343                 {
7344                   /* If we haven't parsed the event's thread yet, find
7345                      it now, in order to find the architecture of the
7346                      reported expedited registers.  */
7347                   if (event->ptid == null_ptid)
7348                     {
7349                       const char *thr = strstr (p1 + 1, ";thread:");
7350                       if (thr != NULL)
7351                         event->ptid = read_ptid (thr + strlen (";thread:"),
7352                                                  NULL);
7353                       else
7354                         {
7355                           /* Either the current thread hasn't changed,
7356                              or the inferior is not multi-threaded.
7357                              The event must be for the thread we last
7358                              set as (or learned as being) current.  */
7359                           event->ptid = event->rs->general_thread;
7360                         }
7361                     }
7362
7363                   if (rsa == NULL)
7364                     {
7365                       inferior *inf = (event->ptid == null_ptid
7366                                        ? NULL
7367                                        : find_inferior_ptid (event->ptid));
7368                       /* If this is the first time we learn anything
7369                          about this process, skip the registers
7370                          included in this packet, since we don't yet
7371                          know which architecture to use to parse them.
7372                          We'll determine the architecture later when
7373                          we process the stop reply and retrieve the
7374                          target description, via
7375                          remote_notice_new_inferior ->
7376                          post_create_inferior.  */
7377                       if (inf == NULL)
7378                         {
7379                           p = strchrnul (p1 + 1, ';');
7380                           p++;
7381                           continue;
7382                         }
7383
7384                       event->arch = inf->gdbarch;
7385                       rsa = event->rs->get_remote_arch_state (event->arch);
7386                     }
7387
7388                   packet_reg *reg
7389                     = packet_reg_from_pnum (event->arch, rsa, pnum);
7390                   cached_reg_t cached_reg;
7391
7392                   if (reg == NULL)
7393                     error (_("Remote sent bad register number %s: %s\n\
7394 Packet: '%s'\n"),
7395                            hex_string (pnum), p, buf);
7396
7397                   cached_reg.num = reg->regnum;
7398                   cached_reg.data = (gdb_byte *)
7399                     xmalloc (register_size (event->arch, reg->regnum));
7400
7401                   p = p1 + 1;
7402                   fieldsize = hex2bin (p, cached_reg.data,
7403                                        register_size (event->arch, reg->regnum));
7404                   p += 2 * fieldsize;
7405                   if (fieldsize < register_size (event->arch, reg->regnum))
7406                     warning (_("Remote reply is too short: %s"), buf);
7407
7408                   event->regcache.push_back (cached_reg);
7409                 }
7410               else
7411                 {
7412                   /* Not a number.  Silently skip unknown optional
7413                      info.  */
7414                   p = strchrnul (p1 + 1, ';');
7415                 }
7416             }
7417
7418           if (*p != ';')
7419             error (_("Remote register badly formatted: %s\nhere: %s"),
7420                    buf, p);
7421           ++p;
7422         }
7423
7424       if (event->ws.kind != TARGET_WAITKIND_IGNORE)
7425         break;
7426
7427       /* fall through */
7428     case 'S':           /* Old style status, just signal only.  */
7429       {
7430         int sig;
7431
7432         event->ws.kind = TARGET_WAITKIND_STOPPED;
7433         sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
7434         if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
7435           event->ws.value.sig = (enum gdb_signal) sig;
7436         else
7437           event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7438       }
7439       break;
7440     case 'w':           /* Thread exited.  */
7441       {
7442         ULONGEST value;
7443
7444         event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
7445         p = unpack_varlen_hex (&buf[1], &value);
7446         event->ws.value.integer = value;
7447         if (*p != ';')
7448           error (_("stop reply packet badly formatted: %s"), buf);
7449         event->ptid = read_ptid (++p, NULL);
7450         break;
7451       }
7452     case 'W':           /* Target exited.  */
7453     case 'X':
7454       {
7455         int pid;
7456         ULONGEST value;
7457
7458         /* GDB used to accept only 2 hex chars here.  Stubs should
7459            only send more if they detect GDB supports multi-process
7460            support.  */
7461         p = unpack_varlen_hex (&buf[1], &value);
7462
7463         if (buf[0] == 'W')
7464           {
7465             /* The remote process exited.  */
7466             event->ws.kind = TARGET_WAITKIND_EXITED;
7467             event->ws.value.integer = value;
7468           }
7469         else
7470           {
7471             /* The remote process exited with a signal.  */
7472             event->ws.kind = TARGET_WAITKIND_SIGNALLED;
7473             if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
7474               event->ws.value.sig = (enum gdb_signal) value;
7475             else
7476               event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7477           }
7478
7479         /* If no process is specified, assume inferior_ptid.  */
7480         pid = inferior_ptid.pid ();
7481         if (*p == '\0')
7482           ;
7483         else if (*p == ';')
7484           {
7485             p++;
7486
7487             if (*p == '\0')
7488               ;
7489             else if (startswith (p, "process:"))
7490               {
7491                 ULONGEST upid;
7492
7493                 p += sizeof ("process:") - 1;
7494                 unpack_varlen_hex (p, &upid);
7495                 pid = upid;
7496               }
7497             else
7498               error (_("unknown stop reply packet: %s"), buf);
7499           }
7500         else
7501           error (_("unknown stop reply packet: %s"), buf);
7502         event->ptid = ptid_t (pid);
7503       }
7504       break;
7505     case 'N':
7506       event->ws.kind = TARGET_WAITKIND_NO_RESUMED;
7507       event->ptid = minus_one_ptid;
7508       break;
7509     }
7510
7511   if (target_is_non_stop_p () && event->ptid == null_ptid)
7512     error (_("No process or thread specified in stop reply: %s"), buf);
7513 }
7514
7515 /* When the stub wants to tell GDB about a new notification reply, it
7516    sends a notification (%Stop, for example).  Those can come it at
7517    any time, hence, we have to make sure that any pending
7518    putpkt/getpkt sequence we're making is finished, before querying
7519    the stub for more events with the corresponding ack command
7520    (vStopped, for example).  E.g., if we started a vStopped sequence
7521    immediately upon receiving the notification, something like this
7522    could happen:
7523
7524     1.1) --> Hg 1
7525     1.2) <-- OK
7526     1.3) --> g
7527     1.4) <-- %Stop
7528     1.5) --> vStopped
7529     1.6) <-- (registers reply to step #1.3)
7530
7531    Obviously, the reply in step #1.6 would be unexpected to a vStopped
7532    query.
7533
7534    To solve this, whenever we parse a %Stop notification successfully,
7535    we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7536    doing whatever we were doing:
7537
7538     2.1) --> Hg 1
7539     2.2) <-- OK
7540     2.3) --> g
7541     2.4) <-- %Stop
7542       <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7543     2.5) <-- (registers reply to step #2.3)
7544
7545    Eventualy after step #2.5, we return to the event loop, which
7546    notices there's an event on the
7547    REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7548    associated callback --- the function below.  At this point, we're
7549    always safe to start a vStopped sequence. :
7550
7551     2.6) --> vStopped
7552     2.7) <-- T05 thread:2
7553     2.8) --> vStopped
7554     2.9) --> OK
7555 */
7556
7557 void
7558 remote_target::remote_notif_get_pending_events (notif_client *nc)
7559 {
7560   struct remote_state *rs = get_remote_state ();
7561
7562   if (rs->notif_state->pending_event[nc->id] != NULL)
7563     {
7564       if (notif_debug)
7565         fprintf_unfiltered (gdb_stdlog,
7566                             "notif: process: '%s' ack pending event\n",
7567                             nc->name);
7568
7569       /* acknowledge */
7570       nc->ack (this, nc, rs->buf.data (),
7571                rs->notif_state->pending_event[nc->id]);
7572       rs->notif_state->pending_event[nc->id] = NULL;
7573
7574       while (1)
7575         {
7576           getpkt (&rs->buf, 0);
7577           if (strcmp (rs->buf.data (), "OK") == 0)
7578             break;
7579           else
7580             remote_notif_ack (this, nc, rs->buf.data ());
7581         }
7582     }
7583   else
7584     {
7585       if (notif_debug)
7586         fprintf_unfiltered (gdb_stdlog,
7587                             "notif: process: '%s' no pending reply\n",
7588                             nc->name);
7589     }
7590 }
7591
7592 /* Wrapper around remote_target::remote_notif_get_pending_events to
7593    avoid having to export the whole remote_target class.  */
7594
7595 void
7596 remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
7597 {
7598   remote->remote_notif_get_pending_events (nc);
7599 }
7600
7601 /* Called when it is decided that STOP_REPLY holds the info of the
7602    event that is to be returned to the core.  This function always
7603    destroys STOP_REPLY.  */
7604
7605 ptid_t
7606 remote_target::process_stop_reply (struct stop_reply *stop_reply,
7607                                    struct target_waitstatus *status)
7608 {
7609   ptid_t ptid;
7610
7611   *status = stop_reply->ws;
7612   ptid = stop_reply->ptid;
7613
7614   /* If no thread/process was reported by the stub, assume the current
7615      inferior.  */
7616   if (ptid == null_ptid)
7617     ptid = inferior_ptid;
7618
7619   if (status->kind != TARGET_WAITKIND_EXITED
7620       && status->kind != TARGET_WAITKIND_SIGNALLED
7621       && status->kind != TARGET_WAITKIND_NO_RESUMED)
7622     {
7623       /* Expedited registers.  */
7624       if (!stop_reply->regcache.empty ())
7625         {
7626           struct regcache *regcache
7627             = get_thread_arch_regcache (ptid, stop_reply->arch);
7628
7629           for (cached_reg_t &reg : stop_reply->regcache)
7630             {
7631               regcache->raw_supply (reg.num, reg.data);
7632               xfree (reg.data);
7633             }
7634
7635           stop_reply->regcache.clear ();
7636         }
7637
7638       remote_notice_new_inferior (ptid, 0);
7639       remote_thread_info *remote_thr = get_remote_thread_info (ptid);
7640       remote_thr->core = stop_reply->core;
7641       remote_thr->stop_reason = stop_reply->stop_reason;
7642       remote_thr->watch_data_address = stop_reply->watch_data_address;
7643       remote_thr->vcont_resumed = 0;
7644     }
7645
7646   delete stop_reply;
7647   return ptid;
7648 }
7649
7650 /* The non-stop mode version of target_wait.  */
7651
7652 ptid_t
7653 remote_target::wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
7654 {
7655   struct remote_state *rs = get_remote_state ();
7656   struct stop_reply *stop_reply;
7657   int ret;
7658   int is_notif = 0;
7659
7660   /* If in non-stop mode, get out of getpkt even if a
7661      notification is received.  */
7662
7663   ret = getpkt_or_notif_sane (&rs->buf, 0 /* forever */, &is_notif);
7664   while (1)
7665     {
7666       if (ret != -1 && !is_notif)
7667         switch (rs->buf[0])
7668           {
7669           case 'E':             /* Error of some sort.  */
7670             /* We're out of sync with the target now.  Did it continue
7671                or not?  We can't tell which thread it was in non-stop,
7672                so just ignore this.  */
7673             warning (_("Remote failure reply: %s"), rs->buf.data ());
7674             break;
7675           case 'O':             /* Console output.  */
7676             remote_console_output (&rs->buf[1]);
7677             break;
7678           default:
7679             warning (_("Invalid remote reply: %s"), rs->buf.data ());
7680             break;
7681           }
7682
7683       /* Acknowledge a pending stop reply that may have arrived in the
7684          mean time.  */
7685       if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)
7686         remote_notif_get_pending_events (&notif_client_stop);
7687
7688       /* If indeed we noticed a stop reply, we're done.  */
7689       stop_reply = queued_stop_reply (ptid);
7690       if (stop_reply != NULL)
7691         return process_stop_reply (stop_reply, status);
7692
7693       /* Still no event.  If we're just polling for an event, then
7694          return to the event loop.  */
7695       if (options & TARGET_WNOHANG)
7696         {
7697           status->kind = TARGET_WAITKIND_IGNORE;
7698           return minus_one_ptid;
7699         }
7700
7701       /* Otherwise do a blocking wait.  */
7702       ret = getpkt_or_notif_sane (&rs->buf, 1 /* forever */, &is_notif);
7703     }
7704 }
7705
7706 /* Wait until the remote machine stops, then return, storing status in
7707    STATUS just as `wait' would.  */
7708
7709 ptid_t
7710 remote_target::wait_as (ptid_t ptid, target_waitstatus *status, int options)
7711 {
7712   struct remote_state *rs = get_remote_state ();
7713   ptid_t event_ptid = null_ptid;
7714   char *buf;
7715   struct stop_reply *stop_reply;
7716
7717  again:
7718
7719   status->kind = TARGET_WAITKIND_IGNORE;
7720   status->value.integer = 0;
7721
7722   stop_reply = queued_stop_reply (ptid);
7723   if (stop_reply != NULL)
7724     return process_stop_reply (stop_reply, status);
7725
7726   if (rs->cached_wait_status)
7727     /* Use the cached wait status, but only once.  */
7728     rs->cached_wait_status = 0;
7729   else
7730     {
7731       int ret;
7732       int is_notif;
7733       int forever = ((options & TARGET_WNOHANG) == 0
7734                      && rs->wait_forever_enabled_p);
7735
7736       if (!rs->waiting_for_stop_reply)
7737         {
7738           status->kind = TARGET_WAITKIND_NO_RESUMED;
7739           return minus_one_ptid;
7740         }
7741
7742       /* FIXME: cagney/1999-09-27: If we're in async mode we should
7743          _never_ wait for ever -> test on target_is_async_p().
7744          However, before we do that we need to ensure that the caller
7745          knows how to take the target into/out of async mode.  */
7746       ret = getpkt_or_notif_sane (&rs->buf, forever, &is_notif);
7747
7748       /* GDB gets a notification.  Return to core as this event is
7749          not interesting.  */
7750       if (ret != -1 && is_notif)
7751         return minus_one_ptid;
7752
7753       if (ret == -1 && (options & TARGET_WNOHANG) != 0)
7754         return minus_one_ptid;
7755     }
7756
7757   buf = rs->buf.data ();
7758
7759   /* Assume that the target has acknowledged Ctrl-C unless we receive
7760      an 'F' or 'O' packet.  */
7761   if (buf[0] != 'F' && buf[0] != 'O')
7762     rs->ctrlc_pending_p = 0;
7763
7764   switch (buf[0])
7765     {
7766     case 'E':           /* Error of some sort.  */
7767       /* We're out of sync with the target now.  Did it continue or
7768          not?  Not is more likely, so report a stop.  */
7769       rs->waiting_for_stop_reply = 0;
7770
7771       warning (_("Remote failure reply: %s"), buf);
7772       status->kind = TARGET_WAITKIND_STOPPED;
7773       status->value.sig = GDB_SIGNAL_0;
7774       break;
7775     case 'F':           /* File-I/O request.  */
7776       /* GDB may access the inferior memory while handling the File-I/O
7777          request, but we don't want GDB accessing memory while waiting
7778          for a stop reply.  See the comments in putpkt_binary.  Set
7779          waiting_for_stop_reply to 0 temporarily.  */
7780       rs->waiting_for_stop_reply = 0;
7781       remote_fileio_request (this, buf, rs->ctrlc_pending_p);
7782       rs->ctrlc_pending_p = 0;
7783       /* GDB handled the File-I/O request, and the target is running
7784          again.  Keep waiting for events.  */
7785       rs->waiting_for_stop_reply = 1;
7786       break;
7787     case 'N': case 'T': case 'S': case 'X': case 'W':
7788       {
7789         /* There is a stop reply to handle.  */
7790         rs->waiting_for_stop_reply = 0;
7791
7792         stop_reply
7793           = (struct stop_reply *) remote_notif_parse (this,
7794                                                       &notif_client_stop,
7795                                                       rs->buf.data ());
7796
7797         event_ptid = process_stop_reply (stop_reply, status);
7798         break;
7799       }
7800     case 'O':           /* Console output.  */
7801       remote_console_output (buf + 1);
7802       break;
7803     case '\0':
7804       if (rs->last_sent_signal != GDB_SIGNAL_0)
7805         {
7806           /* Zero length reply means that we tried 'S' or 'C' and the
7807              remote system doesn't support it.  */
7808           target_terminal::ours_for_output ();
7809           printf_filtered
7810             ("Can't send signals to this remote system.  %s not sent.\n",
7811              gdb_signal_to_name (rs->last_sent_signal));
7812           rs->last_sent_signal = GDB_SIGNAL_0;
7813           target_terminal::inferior ();
7814
7815           strcpy (buf, rs->last_sent_step ? "s" : "c");
7816           putpkt (buf);
7817           break;
7818         }
7819       /* fallthrough */
7820     default:
7821       warning (_("Invalid remote reply: %s"), buf);
7822       break;
7823     }
7824
7825   if (status->kind == TARGET_WAITKIND_NO_RESUMED)
7826     return minus_one_ptid;
7827   else if (status->kind == TARGET_WAITKIND_IGNORE)
7828     {
7829       /* Nothing interesting happened.  If we're doing a non-blocking
7830          poll, we're done.  Otherwise, go back to waiting.  */
7831       if (options & TARGET_WNOHANG)
7832         return minus_one_ptid;
7833       else
7834         goto again;
7835     }
7836   else if (status->kind != TARGET_WAITKIND_EXITED
7837            && status->kind != TARGET_WAITKIND_SIGNALLED)
7838     {
7839       if (event_ptid != null_ptid)
7840         record_currthread (rs, event_ptid);
7841       else
7842         event_ptid = inferior_ptid;
7843     }
7844   else
7845     /* A process exit.  Invalidate our notion of current thread.  */
7846     record_currthread (rs, minus_one_ptid);
7847
7848   return event_ptid;
7849 }
7850
7851 /* Wait until the remote machine stops, then return, storing status in
7852    STATUS just as `wait' would.  */
7853
7854 ptid_t
7855 remote_target::wait (ptid_t ptid, struct target_waitstatus *status, int options)
7856 {
7857   ptid_t event_ptid;
7858
7859   if (target_is_non_stop_p ())
7860     event_ptid = wait_ns (ptid, status, options);
7861   else
7862     event_ptid = wait_as (ptid, status, options);
7863
7864   if (target_is_async_p ())
7865     {
7866       remote_state *rs = get_remote_state ();
7867
7868       /* If there are are events left in the queue tell the event loop
7869          to return here.  */
7870       if (!rs->stop_reply_queue.empty ())
7871         mark_async_event_handler (rs->remote_async_inferior_event_token);
7872     }
7873
7874   return event_ptid;
7875 }
7876
7877 /* Fetch a single register using a 'p' packet.  */
7878
7879 int
7880 remote_target::fetch_register_using_p (struct regcache *regcache,
7881                                        packet_reg *reg)
7882 {
7883   struct gdbarch *gdbarch = regcache->arch ();
7884   struct remote_state *rs = get_remote_state ();
7885   char *buf, *p;
7886   gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
7887   int i;
7888
7889   if (packet_support (PACKET_p) == PACKET_DISABLE)
7890     return 0;
7891
7892   if (reg->pnum == -1)
7893     return 0;
7894
7895   p = rs->buf.data ();
7896   *p++ = 'p';
7897   p += hexnumstr (p, reg->pnum);
7898   *p++ = '\0';
7899   putpkt (rs->buf);
7900   getpkt (&rs->buf, 0);
7901
7902   buf = rs->buf.data ();
7903
7904   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_p]))
7905     {
7906     case PACKET_OK:
7907       break;
7908     case PACKET_UNKNOWN:
7909       return 0;
7910     case PACKET_ERROR:
7911       error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7912              gdbarch_register_name (regcache->arch (), 
7913                                     reg->regnum), 
7914              buf);
7915     }
7916
7917   /* If this register is unfetchable, tell the regcache.  */
7918   if (buf[0] == 'x')
7919     {
7920       regcache->raw_supply (reg->regnum, NULL);
7921       return 1;
7922     }
7923
7924   /* Otherwise, parse and supply the value.  */
7925   p = buf;
7926   i = 0;
7927   while (p[0] != 0)
7928     {
7929       if (p[1] == 0)
7930         error (_("fetch_register_using_p: early buf termination"));
7931
7932       regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
7933       p += 2;
7934     }
7935   regcache->raw_supply (reg->regnum, regp);
7936   return 1;
7937 }
7938
7939 /* Fetch the registers included in the target's 'g' packet.  */
7940
7941 int
7942 remote_target::send_g_packet ()
7943 {
7944   struct remote_state *rs = get_remote_state ();
7945   int buf_len;
7946
7947   xsnprintf (rs->buf.data (), get_remote_packet_size (), "g");
7948   putpkt (rs->buf);
7949   getpkt (&rs->buf, 0);
7950   if (packet_check_result (rs->buf) == PACKET_ERROR)
7951     error (_("Could not read registers; remote failure reply '%s'"),
7952            rs->buf.data ());
7953
7954   /* We can get out of synch in various cases.  If the first character
7955      in the buffer is not a hex character, assume that has happened
7956      and try to fetch another packet to read.  */
7957   while ((rs->buf[0] < '0' || rs->buf[0] > '9')
7958          && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
7959          && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
7960          && rs->buf[0] != 'x')  /* New: unavailable register value.  */
7961     {
7962       if (remote_debug)
7963         fprintf_unfiltered (gdb_stdlog,
7964                             "Bad register packet; fetching a new packet\n");
7965       getpkt (&rs->buf, 0);
7966     }
7967
7968   buf_len = strlen (rs->buf.data ());
7969
7970   /* Sanity check the received packet.  */
7971   if (buf_len % 2 != 0)
7972     error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf.data ());
7973
7974   return buf_len / 2;
7975 }
7976
7977 void
7978 remote_target::process_g_packet (struct regcache *regcache)
7979 {
7980   struct gdbarch *gdbarch = regcache->arch ();
7981   struct remote_state *rs = get_remote_state ();
7982   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
7983   int i, buf_len;
7984   char *p;
7985   char *regs;
7986
7987   buf_len = strlen (rs->buf.data ());
7988
7989   /* Further sanity checks, with knowledge of the architecture.  */
7990   if (buf_len > 2 * rsa->sizeof_g_packet)
7991     error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7992              "bytes): %s"),
7993            rsa->sizeof_g_packet, buf_len / 2,
7994            rs->buf.data ());
7995
7996   /* Save the size of the packet sent to us by the target.  It is used
7997      as a heuristic when determining the max size of packets that the
7998      target can safely receive.  */
7999   if (rsa->actual_register_packet_size == 0)
8000     rsa->actual_register_packet_size = buf_len;
8001
8002   /* If this is smaller than we guessed the 'g' packet would be,
8003      update our records.  A 'g' reply that doesn't include a register's
8004      value implies either that the register is not available, or that
8005      the 'p' packet must be used.  */
8006   if (buf_len < 2 * rsa->sizeof_g_packet)
8007     {
8008       long sizeof_g_packet = buf_len / 2;
8009
8010       for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8011         {
8012           long offset = rsa->regs[i].offset;
8013           long reg_size = register_size (gdbarch, i);
8014
8015           if (rsa->regs[i].pnum == -1)
8016             continue;
8017
8018           if (offset >= sizeof_g_packet)
8019             rsa->regs[i].in_g_packet = 0;
8020           else if (offset + reg_size > sizeof_g_packet)
8021             error (_("Truncated register %d in remote 'g' packet"), i);
8022           else
8023             rsa->regs[i].in_g_packet = 1;
8024         }
8025
8026       /* Looks valid enough, we can assume this is the correct length
8027          for a 'g' packet.  It's important not to adjust
8028          rsa->sizeof_g_packet if we have truncated registers otherwise
8029          this "if" won't be run the next time the method is called
8030          with a packet of the same size and one of the internal errors
8031          below will trigger instead.  */
8032       rsa->sizeof_g_packet = sizeof_g_packet;
8033     }
8034
8035   regs = (char *) alloca (rsa->sizeof_g_packet);
8036
8037   /* Unimplemented registers read as all bits zero.  */
8038   memset (regs, 0, rsa->sizeof_g_packet);
8039
8040   /* Reply describes registers byte by byte, each byte encoded as two
8041      hex characters.  Suck them all up, then supply them to the
8042      register cacheing/storage mechanism.  */
8043
8044   p = rs->buf.data ();
8045   for (i = 0; i < rsa->sizeof_g_packet; i++)
8046     {
8047       if (p[0] == 0 || p[1] == 0)
8048         /* This shouldn't happen - we adjusted sizeof_g_packet above.  */
8049         internal_error (__FILE__, __LINE__,
8050                         _("unexpected end of 'g' packet reply"));
8051
8052       if (p[0] == 'x' && p[1] == 'x')
8053         regs[i] = 0;            /* 'x' */
8054       else
8055         regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
8056       p += 2;
8057     }
8058
8059   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8060     {
8061       struct packet_reg *r = &rsa->regs[i];
8062       long reg_size = register_size (gdbarch, i);
8063
8064       if (r->in_g_packet)
8065         {
8066           if ((r->offset + reg_size) * 2 > strlen (rs->buf.data ()))
8067             /* This shouldn't happen - we adjusted in_g_packet above.  */
8068             internal_error (__FILE__, __LINE__,
8069                             _("unexpected end of 'g' packet reply"));
8070           else if (rs->buf[r->offset * 2] == 'x')
8071             {
8072               gdb_assert (r->offset * 2 < strlen (rs->buf.data ()));
8073               /* The register isn't available, mark it as such (at
8074                  the same time setting the value to zero).  */
8075               regcache->raw_supply (r->regnum, NULL);
8076             }
8077           else
8078             regcache->raw_supply (r->regnum, regs + r->offset);
8079         }
8080     }
8081 }
8082
8083 void
8084 remote_target::fetch_registers_using_g (struct regcache *regcache)
8085 {
8086   send_g_packet ();
8087   process_g_packet (regcache);
8088 }
8089
8090 /* Make the remote selected traceframe match GDB's selected
8091    traceframe.  */
8092
8093 void
8094 remote_target::set_remote_traceframe ()
8095 {
8096   int newnum;
8097   struct remote_state *rs = get_remote_state ();
8098
8099   if (rs->remote_traceframe_number == get_traceframe_number ())
8100     return;
8101
8102   /* Avoid recursion, remote_trace_find calls us again.  */
8103   rs->remote_traceframe_number = get_traceframe_number ();
8104
8105   newnum = target_trace_find (tfind_number,
8106                               get_traceframe_number (), 0, 0, NULL);
8107
8108   /* Should not happen.  If it does, all bets are off.  */
8109   if (newnum != get_traceframe_number ())
8110     warning (_("could not set remote traceframe"));
8111 }
8112
8113 void
8114 remote_target::fetch_registers (struct regcache *regcache, int regnum)
8115 {
8116   struct gdbarch *gdbarch = regcache->arch ();
8117   struct remote_state *rs = get_remote_state ();
8118   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8119   int i;
8120
8121   set_remote_traceframe ();
8122   set_general_thread (regcache->ptid ());
8123
8124   if (regnum >= 0)
8125     {
8126       packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8127
8128       gdb_assert (reg != NULL);
8129
8130       /* If this register might be in the 'g' packet, try that first -
8131          we are likely to read more than one register.  If this is the
8132          first 'g' packet, we might be overly optimistic about its
8133          contents, so fall back to 'p'.  */
8134       if (reg->in_g_packet)
8135         {
8136           fetch_registers_using_g (regcache);
8137           if (reg->in_g_packet)
8138             return;
8139         }
8140
8141       if (fetch_register_using_p (regcache, reg))
8142         return;
8143
8144       /* This register is not available.  */
8145       regcache->raw_supply (reg->regnum, NULL);
8146
8147       return;
8148     }
8149
8150   fetch_registers_using_g (regcache);
8151
8152   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8153     if (!rsa->regs[i].in_g_packet)
8154       if (!fetch_register_using_p (regcache, &rsa->regs[i]))
8155         {
8156           /* This register is not available.  */
8157           regcache->raw_supply (i, NULL);
8158         }
8159 }
8160
8161 /* Prepare to store registers.  Since we may send them all (using a
8162    'G' request), we have to read out the ones we don't want to change
8163    first.  */
8164
8165 void
8166 remote_target::prepare_to_store (struct regcache *regcache)
8167 {
8168   struct remote_state *rs = get_remote_state ();
8169   remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8170   int i;
8171
8172   /* Make sure the entire registers array is valid.  */
8173   switch (packet_support (PACKET_P))
8174     {
8175     case PACKET_DISABLE:
8176     case PACKET_SUPPORT_UNKNOWN:
8177       /* Make sure all the necessary registers are cached.  */
8178       for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8179         if (rsa->regs[i].in_g_packet)
8180           regcache->raw_update (rsa->regs[i].regnum);
8181       break;
8182     case PACKET_ENABLE:
8183       break;
8184     }
8185 }
8186
8187 /* Helper: Attempt to store REGNUM using the P packet.  Return fail IFF
8188    packet was not recognized.  */
8189
8190 int
8191 remote_target::store_register_using_P (const struct regcache *regcache,
8192                                        packet_reg *reg)
8193 {
8194   struct gdbarch *gdbarch = regcache->arch ();
8195   struct remote_state *rs = get_remote_state ();
8196   /* Try storing a single register.  */
8197   char *buf = rs->buf.data ();
8198   gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
8199   char *p;
8200
8201   if (packet_support (PACKET_P) == PACKET_DISABLE)
8202     return 0;
8203
8204   if (reg->pnum == -1)
8205     return 0;
8206
8207   xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
8208   p = buf + strlen (buf);
8209   regcache->raw_collect (reg->regnum, regp);
8210   bin2hex (regp, p, register_size (gdbarch, reg->regnum));
8211   putpkt (rs->buf);
8212   getpkt (&rs->buf, 0);
8213
8214   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
8215     {
8216     case PACKET_OK:
8217       return 1;
8218     case PACKET_ERROR:
8219       error (_("Could not write register \"%s\"; remote failure reply '%s'"),
8220              gdbarch_register_name (gdbarch, reg->regnum), rs->buf.data ());
8221     case PACKET_UNKNOWN:
8222       return 0;
8223     default:
8224       internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
8225     }
8226 }
8227
8228 /* Store register REGNUM, or all registers if REGNUM == -1, from the
8229    contents of the register cache buffer.  FIXME: ignores errors.  */
8230
8231 void
8232 remote_target::store_registers_using_G (const struct regcache *regcache)
8233 {
8234   struct remote_state *rs = get_remote_state ();
8235   remote_arch_state *rsa = rs->get_remote_arch_state (regcache->arch ());
8236   gdb_byte *regs;
8237   char *p;
8238
8239   /* Extract all the registers in the regcache copying them into a
8240      local buffer.  */
8241   {
8242     int i;
8243
8244     regs = (gdb_byte *) alloca (rsa->sizeof_g_packet);
8245     memset (regs, 0, rsa->sizeof_g_packet);
8246     for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
8247       {
8248         struct packet_reg *r = &rsa->regs[i];
8249
8250         if (r->in_g_packet)
8251           regcache->raw_collect (r->regnum, regs + r->offset);
8252       }
8253   }
8254
8255   /* Command describes registers byte by byte,
8256      each byte encoded as two hex characters.  */
8257   p = rs->buf.data ();
8258   *p++ = 'G';
8259   bin2hex (regs, p, rsa->sizeof_g_packet);
8260   putpkt (rs->buf);
8261   getpkt (&rs->buf, 0);
8262   if (packet_check_result (rs->buf) == PACKET_ERROR)
8263     error (_("Could not write registers; remote failure reply '%s'"), 
8264            rs->buf.data ());
8265 }
8266
8267 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
8268    of the register cache buffer.  FIXME: ignores errors.  */
8269
8270 void
8271 remote_target::store_registers (struct regcache *regcache, int regnum)
8272 {
8273   struct gdbarch *gdbarch = regcache->arch ();
8274   struct remote_state *rs = get_remote_state ();
8275   remote_arch_state *rsa = rs->get_remote_arch_state (gdbarch);
8276   int i;
8277
8278   set_remote_traceframe ();
8279   set_general_thread (regcache->ptid ());
8280
8281   if (regnum >= 0)
8282     {
8283       packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
8284
8285       gdb_assert (reg != NULL);
8286
8287       /* Always prefer to store registers using the 'P' packet if
8288          possible; we often change only a small number of registers.
8289          Sometimes we change a larger number; we'd need help from a
8290          higher layer to know to use 'G'.  */
8291       if (store_register_using_P (regcache, reg))
8292         return;
8293
8294       /* For now, don't complain if we have no way to write the
8295          register.  GDB loses track of unavailable registers too
8296          easily.  Some day, this may be an error.  We don't have
8297          any way to read the register, either...  */
8298       if (!reg->in_g_packet)
8299         return;
8300
8301       store_registers_using_G (regcache);
8302       return;
8303     }
8304
8305   store_registers_using_G (regcache);
8306
8307   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
8308     if (!rsa->regs[i].in_g_packet)
8309       if (!store_register_using_P (regcache, &rsa->regs[i]))
8310         /* See above for why we do not issue an error here.  */
8311         continue;
8312 }
8313 \f
8314
8315 /* Return the number of hex digits in num.  */
8316
8317 static int
8318 hexnumlen (ULONGEST num)
8319 {
8320   int i;
8321
8322   for (i = 0; num != 0; i++)
8323     num >>= 4;
8324
8325   return std::max (i, 1);
8326 }
8327
8328 /* Set BUF to the minimum number of hex digits representing NUM.  */
8329
8330 static int
8331 hexnumstr (char *buf, ULONGEST num)
8332 {
8333   int len = hexnumlen (num);
8334
8335   return hexnumnstr (buf, num, len);
8336 }
8337
8338
8339 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters.  */
8340
8341 static int
8342 hexnumnstr (char *buf, ULONGEST num, int width)
8343 {
8344   int i;
8345
8346   buf[width] = '\0';
8347
8348   for (i = width - 1; i >= 0; i--)
8349     {
8350       buf[i] = "0123456789abcdef"[(num & 0xf)];
8351       num >>= 4;
8352     }
8353
8354   return width;
8355 }
8356
8357 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits.  */
8358
8359 static CORE_ADDR
8360 remote_address_masked (CORE_ADDR addr)
8361 {
8362   unsigned int address_size = remote_address_size;
8363
8364   /* If "remoteaddresssize" was not set, default to target address size.  */
8365   if (!address_size)
8366     address_size = gdbarch_addr_bit (target_gdbarch ());
8367
8368   if (address_size > 0
8369       && address_size < (sizeof (ULONGEST) * 8))
8370     {
8371       /* Only create a mask when that mask can safely be constructed
8372          in a ULONGEST variable.  */
8373       ULONGEST mask = 1;
8374
8375       mask = (mask << address_size) - 1;
8376       addr &= mask;
8377     }
8378   return addr;
8379 }
8380
8381 /* Determine whether the remote target supports binary downloading.
8382    This is accomplished by sending a no-op memory write of zero length
8383    to the target at the specified address. It does not suffice to send
8384    the whole packet, since many stubs strip the eighth bit and
8385    subsequently compute a wrong checksum, which causes real havoc with
8386    remote_write_bytes.
8387
8388    NOTE: This can still lose if the serial line is not eight-bit
8389    clean.  In cases like this, the user should clear "remote
8390    X-packet".  */
8391
8392 void
8393 remote_target::check_binary_download (CORE_ADDR addr)
8394 {
8395   struct remote_state *rs = get_remote_state ();
8396
8397   switch (packet_support (PACKET_X))
8398     {
8399     case PACKET_DISABLE:
8400       break;
8401     case PACKET_ENABLE:
8402       break;
8403     case PACKET_SUPPORT_UNKNOWN:
8404       {
8405         char *p;
8406
8407         p = rs->buf.data ();
8408         *p++ = 'X';
8409         p += hexnumstr (p, (ULONGEST) addr);
8410         *p++ = ',';
8411         p += hexnumstr (p, (ULONGEST) 0);
8412         *p++ = ':';
8413         *p = '\0';
8414
8415         putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
8416         getpkt (&rs->buf, 0);
8417
8418         if (rs->buf[0] == '\0')
8419           {
8420             if (remote_debug)
8421               fprintf_unfiltered (gdb_stdlog,
8422                                   "binary downloading NOT "
8423                                   "supported by target\n");
8424             remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
8425           }
8426         else
8427           {
8428             if (remote_debug)
8429               fprintf_unfiltered (gdb_stdlog,
8430                                   "binary downloading supported by target\n");
8431             remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
8432           }
8433         break;
8434       }
8435     }
8436 }
8437
8438 /* Helper function to resize the payload in order to try to get a good
8439    alignment.  We try to write an amount of data such that the next write will
8440    start on an address aligned on REMOTE_ALIGN_WRITES.  */
8441
8442 static int
8443 align_for_efficient_write (int todo, CORE_ADDR memaddr)
8444 {
8445   return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
8446 }
8447
8448 /* Write memory data directly to the remote machine.
8449    This does not inform the data cache; the data cache uses this.
8450    HEADER is the starting part of the packet.
8451    MEMADDR is the address in the remote memory space.
8452    MYADDR is the address of the buffer in our space.
8453    LEN_UNITS is the number of addressable units to write.
8454    UNIT_SIZE is the length in bytes of an addressable unit.
8455    PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8456    should send data as binary ('X'), or hex-encoded ('M').
8457
8458    The function creates packet of the form
8459        <HEADER><ADDRESS>,<LENGTH>:<DATA>
8460
8461    where encoding of <DATA> is terminated by PACKET_FORMAT.
8462
8463    If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8464    are omitted.
8465
8466    Return the transferred status, error or OK (an
8467    'enum target_xfer_status' value).  Save the number of addressable units
8468    transferred in *XFERED_LEN_UNITS.  Only transfer a single packet.
8469
8470    On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8471    exchange between gdb and the stub could look like (?? in place of the
8472    checksum):
8473
8474    -> $m1000,4#??
8475    <- aaaabbbbccccdddd
8476
8477    -> $M1000,3:eeeeffffeeee#??
8478    <- OK
8479
8480    -> $m1000,4#??
8481    <- eeeeffffeeeedddd  */
8482
8483 target_xfer_status
8484 remote_target::remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
8485                                        const gdb_byte *myaddr,
8486                                        ULONGEST len_units,
8487                                        int unit_size,
8488                                        ULONGEST *xfered_len_units,
8489                                        char packet_format, int use_length)
8490 {
8491   struct remote_state *rs = get_remote_state ();
8492   char *p;
8493   char *plen = NULL;
8494   int plenlen = 0;
8495   int todo_units;
8496   int units_written;
8497   int payload_capacity_bytes;
8498   int payload_length_bytes;
8499
8500   if (packet_format != 'X' && packet_format != 'M')
8501     internal_error (__FILE__, __LINE__,
8502                     _("remote_write_bytes_aux: bad packet format"));
8503
8504   if (len_units == 0)
8505     return TARGET_XFER_EOF;
8506
8507   payload_capacity_bytes = get_memory_write_packet_size ();
8508
8509   /* The packet buffer will be large enough for the payload;
8510      get_memory_packet_size ensures this.  */
8511   rs->buf[0] = '\0';
8512
8513   /* Compute the size of the actual payload by subtracting out the
8514      packet header and footer overhead: "$M<memaddr>,<len>:...#nn".  */
8515
8516   payload_capacity_bytes -= strlen ("$,:#NN");
8517   if (!use_length)
8518     /* The comma won't be used.  */
8519     payload_capacity_bytes += 1;
8520   payload_capacity_bytes -= strlen (header);
8521   payload_capacity_bytes -= hexnumlen (memaddr);
8522
8523   /* Construct the packet excluding the data: "<header><memaddr>,<len>:".  */
8524
8525   strcat (rs->buf.data (), header);
8526   p = rs->buf.data () + strlen (header);
8527
8528   /* Compute a best guess of the number of bytes actually transfered.  */
8529   if (packet_format == 'X')
8530     {
8531       /* Best guess at number of bytes that will fit.  */
8532       todo_units = std::min (len_units,
8533                              (ULONGEST) payload_capacity_bytes / unit_size);
8534       if (use_length)
8535         payload_capacity_bytes -= hexnumlen (todo_units);
8536       todo_units = std::min (todo_units, payload_capacity_bytes / unit_size);
8537     }
8538   else
8539     {
8540       /* Number of bytes that will fit.  */
8541       todo_units
8542         = std::min (len_units,
8543                     (ULONGEST) (payload_capacity_bytes / unit_size) / 2);
8544       if (use_length)
8545         payload_capacity_bytes -= hexnumlen (todo_units);
8546       todo_units = std::min (todo_units,
8547                              (payload_capacity_bytes / unit_size) / 2);
8548     }
8549
8550   if (todo_units <= 0)
8551     internal_error (__FILE__, __LINE__,
8552                     _("minimum packet size too small to write data"));
8553
8554   /* If we already need another packet, then try to align the end
8555      of this packet to a useful boundary.  */
8556   if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units)
8557     todo_units = align_for_efficient_write (todo_units, memaddr);
8558
8559   /* Append "<memaddr>".  */
8560   memaddr = remote_address_masked (memaddr);
8561   p += hexnumstr (p, (ULONGEST) memaddr);
8562
8563   if (use_length)
8564     {
8565       /* Append ",".  */
8566       *p++ = ',';
8567
8568       /* Append the length and retain its location and size.  It may need to be
8569          adjusted once the packet body has been created.  */
8570       plen = p;
8571       plenlen = hexnumstr (p, (ULONGEST) todo_units);
8572       p += plenlen;
8573     }
8574
8575   /* Append ":".  */
8576   *p++ = ':';
8577   *p = '\0';
8578
8579   /* Append the packet body.  */
8580   if (packet_format == 'X')
8581     {
8582       /* Binary mode.  Send target system values byte by byte, in
8583          increasing byte addresses.  Only escape certain critical
8584          characters.  */
8585       payload_length_bytes =
8586           remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p,
8587                                 &units_written, payload_capacity_bytes);
8588
8589       /* If not all TODO units fit, then we'll need another packet.  Make
8590          a second try to keep the end of the packet aligned.  Don't do
8591          this if the packet is tiny.  */
8592       if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES)
8593         {
8594           int new_todo_units;
8595
8596           new_todo_units = align_for_efficient_write (units_written, memaddr);
8597
8598           if (new_todo_units != units_written)
8599             payload_length_bytes =
8600                 remote_escape_output (myaddr, new_todo_units, unit_size,
8601                                       (gdb_byte *) p, &units_written,
8602                                       payload_capacity_bytes);
8603         }
8604
8605       p += payload_length_bytes;
8606       if (use_length && units_written < todo_units)
8607         {
8608           /* Escape chars have filled up the buffer prematurely,
8609              and we have actually sent fewer units than planned.
8610              Fix-up the length field of the packet.  Use the same
8611              number of characters as before.  */
8612           plen += hexnumnstr (plen, (ULONGEST) units_written,
8613                               plenlen);
8614           *plen = ':';  /* overwrite \0 from hexnumnstr() */
8615         }
8616     }
8617   else
8618     {
8619       /* Normal mode: Send target system values byte by byte, in
8620          increasing byte addresses.  Each byte is encoded as a two hex
8621          value.  */
8622       p += 2 * bin2hex (myaddr, p, todo_units * unit_size);
8623       units_written = todo_units;
8624     }
8625
8626   putpkt_binary (rs->buf.data (), (int) (p - rs->buf.data ()));
8627   getpkt (&rs->buf, 0);
8628
8629   if (rs->buf[0] == 'E')
8630     return TARGET_XFER_E_IO;
8631
8632   /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8633      send fewer units than we'd planned.  */
8634   *xfered_len_units = (ULONGEST) units_written;
8635   return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8636 }
8637
8638 /* Write memory data directly to the remote machine.
8639    This does not inform the data cache; the data cache uses this.
8640    MEMADDR is the address in the remote memory space.
8641    MYADDR is the address of the buffer in our space.
8642    LEN is the number of bytes.
8643
8644    Return the transferred status, error or OK (an
8645    'enum target_xfer_status' value).  Save the number of bytes
8646    transferred in *XFERED_LEN.  Only transfer a single packet.  */
8647
8648 target_xfer_status
8649 remote_target::remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr,
8650                                    ULONGEST len, int unit_size,
8651                                    ULONGEST *xfered_len)
8652 {
8653   const char *packet_format = NULL;
8654
8655   /* Check whether the target supports binary download.  */
8656   check_binary_download (memaddr);
8657
8658   switch (packet_support (PACKET_X))
8659     {
8660     case PACKET_ENABLE:
8661       packet_format = "X";
8662       break;
8663     case PACKET_DISABLE:
8664       packet_format = "M";
8665       break;
8666     case PACKET_SUPPORT_UNKNOWN:
8667       internal_error (__FILE__, __LINE__,
8668                       _("remote_write_bytes: bad internal state"));
8669     default:
8670       internal_error (__FILE__, __LINE__, _("bad switch"));
8671     }
8672
8673   return remote_write_bytes_aux (packet_format,
8674                                  memaddr, myaddr, len, unit_size, xfered_len,
8675                                  packet_format[0], 1);
8676 }
8677
8678 /* Read memory data directly from the remote machine.
8679    This does not use the data cache; the data cache uses this.
8680    MEMADDR is the address in the remote memory space.
8681    MYADDR is the address of the buffer in our space.
8682    LEN_UNITS is the number of addressable memory units to read..
8683    UNIT_SIZE is the length in bytes of an addressable unit.
8684
8685    Return the transferred status, error or OK (an
8686    'enum target_xfer_status' value).  Save the number of bytes
8687    transferred in *XFERED_LEN_UNITS.
8688
8689    See the comment of remote_write_bytes_aux for an example of
8690    memory read/write exchange between gdb and the stub.  */
8691
8692 target_xfer_status
8693 remote_target::remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr,
8694                                     ULONGEST len_units,
8695                                     int unit_size, ULONGEST *xfered_len_units)
8696 {
8697   struct remote_state *rs = get_remote_state ();
8698   int buf_size_bytes;           /* Max size of packet output buffer.  */
8699   char *p;
8700   int todo_units;
8701   int decoded_bytes;
8702
8703   buf_size_bytes = get_memory_read_packet_size ();
8704   /* The packet buffer will be large enough for the payload;
8705      get_memory_packet_size ensures this.  */
8706
8707   /* Number of units that will fit.  */
8708   todo_units = std::min (len_units,
8709                          (ULONGEST) (buf_size_bytes / unit_size) / 2);
8710
8711   /* Construct "m"<memaddr>","<len>".  */
8712   memaddr = remote_address_masked (memaddr);
8713   p = rs->buf.data ();
8714   *p++ = 'm';
8715   p += hexnumstr (p, (ULONGEST) memaddr);
8716   *p++ = ',';
8717   p += hexnumstr (p, (ULONGEST) todo_units);
8718   *p = '\0';
8719   putpkt (rs->buf);
8720   getpkt (&rs->buf, 0);
8721   if (rs->buf[0] == 'E'
8722       && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
8723       && rs->buf[3] == '\0')
8724     return TARGET_XFER_E_IO;
8725   /* Reply describes memory byte by byte, each byte encoded as two hex
8726      characters.  */
8727   p = rs->buf.data ();
8728   decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
8729   /* Return what we have.  Let higher layers handle partial reads.  */
8730   *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
8731   return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8732 }
8733
8734 /* Using the set of read-only target sections of remote, read live
8735    read-only memory.
8736
8737    For interface/parameters/return description see target.h,
8738    to_xfer_partial.  */
8739
8740 target_xfer_status
8741 remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
8742                                                   ULONGEST memaddr,
8743                                                   ULONGEST len,
8744                                                   int unit_size,
8745                                                   ULONGEST *xfered_len)
8746 {
8747   struct target_section *secp;
8748   struct target_section_table *table;
8749
8750   secp = target_section_by_addr (this, memaddr);
8751   if (secp != NULL
8752       && (bfd_get_section_flags (secp->the_bfd_section->owner,
8753                                  secp->the_bfd_section)
8754           & SEC_READONLY))
8755     {
8756       struct target_section *p;
8757       ULONGEST memend = memaddr + len;
8758
8759       table = target_get_section_table (this);
8760
8761       for (p = table->sections; p < table->sections_end; p++)
8762         {
8763           if (memaddr >= p->addr)
8764             {
8765               if (memend <= p->endaddr)
8766                 {
8767                   /* Entire transfer is within this section.  */
8768                   return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8769                                               xfered_len);
8770                 }
8771               else if (memaddr >= p->endaddr)
8772                 {
8773                   /* This section ends before the transfer starts.  */
8774                   continue;
8775                 }
8776               else
8777                 {
8778                   /* This section overlaps the transfer.  Just do half.  */
8779                   len = p->endaddr - memaddr;
8780                   return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8781                                               xfered_len);
8782                 }
8783             }
8784         }
8785     }
8786
8787   return TARGET_XFER_EOF;
8788 }
8789
8790 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8791    first if the requested memory is unavailable in traceframe.
8792    Otherwise, fall back to remote_read_bytes_1.  */
8793
8794 target_xfer_status
8795 remote_target::remote_read_bytes (CORE_ADDR memaddr,
8796                                   gdb_byte *myaddr, ULONGEST len, int unit_size,
8797                                   ULONGEST *xfered_len)
8798 {
8799   if (len == 0)
8800     return TARGET_XFER_EOF;
8801
8802   if (get_traceframe_number () != -1)
8803     {
8804       std::vector<mem_range> available;
8805
8806       /* If we fail to get the set of available memory, then the
8807          target does not support querying traceframe info, and so we
8808          attempt reading from the traceframe anyway (assuming the
8809          target implements the old QTro packet then).  */
8810       if (traceframe_available_memory (&available, memaddr, len))
8811         {
8812           if (available.empty () || available[0].start != memaddr)
8813             {
8814               enum target_xfer_status res;
8815
8816               /* Don't read into the traceframe's available
8817                  memory.  */
8818               if (!available.empty ())
8819                 {
8820                   LONGEST oldlen = len;
8821
8822                   len = available[0].start - memaddr;
8823                   gdb_assert (len <= oldlen);
8824                 }
8825
8826               /* This goes through the topmost target again.  */
8827               res = remote_xfer_live_readonly_partial (myaddr, memaddr,
8828                                                        len, unit_size, xfered_len);
8829               if (res == TARGET_XFER_OK)
8830                 return TARGET_XFER_OK;
8831               else
8832                 {
8833                   /* No use trying further, we know some memory starting
8834                      at MEMADDR isn't available.  */
8835                   *xfered_len = len;
8836                   return (*xfered_len != 0) ?
8837                     TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF;
8838                 }
8839             }
8840
8841           /* Don't try to read more than how much is available, in
8842              case the target implements the deprecated QTro packet to
8843              cater for older GDBs (the target's knowledge of read-only
8844              sections may be outdated by now).  */
8845           len = available[0].length;
8846         }
8847     }
8848
8849   return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len);
8850 }
8851
8852 \f
8853
8854 /* Sends a packet with content determined by the printf format string
8855    FORMAT and the remaining arguments, then gets the reply.  Returns
8856    whether the packet was a success, a failure, or unknown.  */
8857
8858 packet_result
8859 remote_target::remote_send_printf (const char *format, ...)
8860 {
8861   struct remote_state *rs = get_remote_state ();
8862   int max_size = get_remote_packet_size ();
8863   va_list ap;
8864
8865   va_start (ap, format);
8866
8867   rs->buf[0] = '\0';
8868   int size = vsnprintf (rs->buf.data (), max_size, format, ap);
8869
8870   va_end (ap);
8871
8872   if (size >= max_size)
8873     internal_error (__FILE__, __LINE__, _("Too long remote packet."));
8874
8875   if (putpkt (rs->buf) < 0)
8876     error (_("Communication problem with target."));
8877
8878   rs->buf[0] = '\0';
8879   getpkt (&rs->buf, 0);
8880
8881   return packet_check_result (rs->buf);
8882 }
8883
8884 /* Flash writing can take quite some time.  We'll set
8885    effectively infinite timeout for flash operations.
8886    In future, we'll need to decide on a better approach.  */
8887 static const int remote_flash_timeout = 1000;
8888
8889 void
8890 remote_target::flash_erase (ULONGEST address, LONGEST length)
8891 {
8892   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
8893   enum packet_result ret;
8894   scoped_restore restore_timeout
8895     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8896
8897   ret = remote_send_printf ("vFlashErase:%s,%s",
8898                             phex (address, addr_size),
8899                             phex (length, 4));
8900   switch (ret)
8901     {
8902     case PACKET_UNKNOWN:
8903       error (_("Remote target does not support flash erase"));
8904     case PACKET_ERROR:
8905       error (_("Error erasing flash with vFlashErase packet"));
8906     default:
8907       break;
8908     }
8909 }
8910
8911 target_xfer_status
8912 remote_target::remote_flash_write (ULONGEST address,
8913                                    ULONGEST length, ULONGEST *xfered_len,
8914                                    const gdb_byte *data)
8915 {
8916   scoped_restore restore_timeout
8917     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8918   return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1,
8919                                  xfered_len,'X', 0);
8920 }
8921
8922 void
8923 remote_target::flash_done ()
8924 {
8925   int ret;
8926
8927   scoped_restore restore_timeout
8928     = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8929
8930   ret = remote_send_printf ("vFlashDone");
8931
8932   switch (ret)
8933     {
8934     case PACKET_UNKNOWN:
8935       error (_("Remote target does not support vFlashDone"));
8936     case PACKET_ERROR:
8937       error (_("Error finishing flash operation"));
8938     default:
8939       break;
8940     }
8941 }
8942
8943 void
8944 remote_target::files_info ()
8945 {
8946   puts_filtered ("Debugging a target over a serial line.\n");
8947 }
8948 \f
8949 /* Stuff for dealing with the packets which are part of this protocol.
8950    See comment at top of file for details.  */
8951
8952 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8953    error to higher layers.  Called when a serial error is detected.
8954    The exception message is STRING, followed by a colon and a blank,
8955    the system error message for errno at function entry and final dot
8956    for output compatibility with throw_perror_with_name.  */
8957
8958 static void
8959 unpush_and_perror (const char *string)
8960 {
8961   int saved_errno = errno;
8962
8963   remote_unpush_target ();
8964   throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
8965                safe_strerror (saved_errno));
8966 }
8967
8968 /* Read a single character from the remote end.  The current quit
8969    handler is overridden to avoid quitting in the middle of packet
8970    sequence, as that would break communication with the remote server.
8971    See remote_serial_quit_handler for more detail.  */
8972
8973 int
8974 remote_target::readchar (int timeout)
8975 {
8976   int ch;
8977   struct remote_state *rs = get_remote_state ();
8978
8979   {
8980     scoped_restore restore_quit_target
8981       = make_scoped_restore (&curr_quit_handler_target, this);
8982     scoped_restore restore_quit
8983       = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
8984
8985     rs->got_ctrlc_during_io = 0;
8986
8987     ch = serial_readchar (rs->remote_desc, timeout);
8988
8989     if (rs->got_ctrlc_during_io)
8990       set_quit_flag ();
8991   }
8992
8993   if (ch >= 0)
8994     return ch;
8995
8996   switch ((enum serial_rc) ch)
8997     {
8998     case SERIAL_EOF:
8999       remote_unpush_target ();
9000       throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
9001       /* no return */
9002     case SERIAL_ERROR:
9003       unpush_and_perror (_("Remote communication error.  "
9004                            "Target disconnected."));
9005       /* no return */
9006     case SERIAL_TIMEOUT:
9007       break;
9008     }
9009   return ch;
9010 }
9011
9012 /* Wrapper for serial_write that closes the target and throws if
9013    writing fails.  The current quit handler is overridden to avoid
9014    quitting in the middle of packet sequence, as that would break
9015    communication with the remote server.  See
9016    remote_serial_quit_handler for more detail.  */
9017
9018 void
9019 remote_target::remote_serial_write (const char *str, int len)
9020 {
9021   struct remote_state *rs = get_remote_state ();
9022
9023   scoped_restore restore_quit_target
9024     = make_scoped_restore (&curr_quit_handler_target, this);
9025   scoped_restore restore_quit
9026     = make_scoped_restore (&quit_handler, ::remote_serial_quit_handler);
9027
9028   rs->got_ctrlc_during_io = 0;
9029
9030   if (serial_write (rs->remote_desc, str, len))
9031     {
9032       unpush_and_perror (_("Remote communication error.  "
9033                            "Target disconnected."));
9034     }
9035
9036   if (rs->got_ctrlc_during_io)
9037     set_quit_flag ();
9038 }
9039
9040 /* Return a string representing an escaped version of BUF, of len N.
9041    E.g. \n is converted to \\n, \t to \\t, etc.  */
9042
9043 static std::string
9044 escape_buffer (const char *buf, int n)
9045 {
9046   string_file stb;
9047
9048   stb.putstrn (buf, n, '\\');
9049   return std::move (stb.string ());
9050 }
9051
9052 /* Display a null-terminated packet on stdout, for debugging, using C
9053    string notation.  */
9054
9055 static void
9056 print_packet (const char *buf)
9057 {
9058   puts_filtered ("\"");
9059   fputstr_filtered (buf, '"', gdb_stdout);
9060   puts_filtered ("\"");
9061 }
9062
9063 int
9064 remote_target::putpkt (const char *buf)
9065 {
9066   return putpkt_binary (buf, strlen (buf));
9067 }
9068
9069 /* Wrapper around remote_target::putpkt to avoid exporting
9070    remote_target.  */
9071
9072 int
9073 putpkt (remote_target *remote, const char *buf)
9074 {
9075   return remote->putpkt (buf);
9076 }
9077
9078 /* Send a packet to the remote machine, with error checking.  The data
9079    of the packet is in BUF.  The string in BUF can be at most
9080    get_remote_packet_size () - 5 to account for the $, # and checksum,
9081    and for a possible /0 if we are debugging (remote_debug) and want
9082    to print the sent packet as a string.  */
9083
9084 int
9085 remote_target::putpkt_binary (const char *buf, int cnt)
9086 {
9087   struct remote_state *rs = get_remote_state ();
9088   int i;
9089   unsigned char csum = 0;
9090   gdb::def_vector<char> data (cnt + 6);
9091   char *buf2 = data.data ();
9092
9093   int ch;
9094   int tcount = 0;
9095   char *p;
9096
9097   /* Catch cases like trying to read memory or listing threads while
9098      we're waiting for a stop reply.  The remote server wouldn't be
9099      ready to handle this request, so we'd hang and timeout.  We don't
9100      have to worry about this in synchronous mode, because in that
9101      case it's not possible to issue a command while the target is
9102      running.  This is not a problem in non-stop mode, because in that
9103      case, the stub is always ready to process serial input.  */
9104   if (!target_is_non_stop_p ()
9105       && target_is_async_p ()
9106       && rs->waiting_for_stop_reply)
9107     {
9108       error (_("Cannot execute this command while the target is running.\n"
9109                "Use the \"interrupt\" command to stop the target\n"
9110                "and then try again."));
9111     }
9112
9113   /* We're sending out a new packet.  Make sure we don't look at a
9114      stale cached response.  */
9115   rs->cached_wait_status = 0;
9116
9117   /* Copy the packet into buffer BUF2, encapsulating it
9118      and giving it a checksum.  */
9119
9120   p = buf2;
9121   *p++ = '$';
9122
9123   for (i = 0; i < cnt; i++)
9124     {
9125       csum += buf[i];
9126       *p++ = buf[i];
9127     }
9128   *p++ = '#';
9129   *p++ = tohex ((csum >> 4) & 0xf);
9130   *p++ = tohex (csum & 0xf);
9131
9132   /* Send it over and over until we get a positive ack.  */
9133
9134   while (1)
9135     {
9136       int started_error_output = 0;
9137
9138       if (remote_debug)
9139         {
9140           *p = '\0';
9141
9142           int len = (int) (p - buf2);
9143
9144           std::string str
9145             = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
9146
9147           fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
9148
9149           if (len > REMOTE_DEBUG_MAX_CHAR)
9150             fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9151                                 len - REMOTE_DEBUG_MAX_CHAR);
9152
9153           fprintf_unfiltered (gdb_stdlog, "...");
9154
9155           gdb_flush (gdb_stdlog);
9156         }
9157       remote_serial_write (buf2, p - buf2);
9158
9159       /* If this is a no acks version of the remote protocol, send the
9160          packet and move on.  */
9161       if (rs->noack_mode)
9162         break;
9163
9164       /* Read until either a timeout occurs (-2) or '+' is read.
9165          Handle any notification that arrives in the mean time.  */
9166       while (1)
9167         {
9168           ch = readchar (remote_timeout);
9169
9170           if (remote_debug)
9171             {
9172               switch (ch)
9173                 {
9174                 case '+':
9175                 case '-':
9176                 case SERIAL_TIMEOUT:
9177                 case '$':
9178                 case '%':
9179                   if (started_error_output)
9180                     {
9181                       putchar_unfiltered ('\n');
9182                       started_error_output = 0;
9183                     }
9184                 }
9185             }
9186
9187           switch (ch)
9188             {
9189             case '+':
9190               if (remote_debug)
9191                 fprintf_unfiltered (gdb_stdlog, "Ack\n");
9192               return 1;
9193             case '-':
9194               if (remote_debug)
9195                 fprintf_unfiltered (gdb_stdlog, "Nak\n");
9196               /* FALLTHROUGH */
9197             case SERIAL_TIMEOUT:
9198               tcount++;
9199               if (tcount > 3)
9200                 return 0;
9201               break;            /* Retransmit buffer.  */
9202             case '$':
9203               {
9204                 if (remote_debug)
9205                   fprintf_unfiltered (gdb_stdlog,
9206                                       "Packet instead of Ack, ignoring it\n");
9207                 /* It's probably an old response sent because an ACK
9208                    was lost.  Gobble up the packet and ack it so it
9209                    doesn't get retransmitted when we resend this
9210                    packet.  */
9211                 skip_frame ();
9212                 remote_serial_write ("+", 1);
9213                 continue;       /* Now, go look for +.  */
9214               }
9215
9216             case '%':
9217               {
9218                 int val;
9219
9220                 /* If we got a notification, handle it, and go back to looking
9221                    for an ack.  */
9222                 /* We've found the start of a notification.  Now
9223                    collect the data.  */
9224                 val = read_frame (&rs->buf);
9225                 if (val >= 0)
9226                   {
9227                     if (remote_debug)
9228                       {
9229                         std::string str = escape_buffer (rs->buf.data (), val);
9230
9231                         fprintf_unfiltered (gdb_stdlog,
9232                                             "  Notification received: %s\n",
9233                                             str.c_str ());
9234                       }
9235                     handle_notification (rs->notif_state, rs->buf.data ());
9236                     /* We're in sync now, rewait for the ack.  */
9237                     tcount = 0;
9238                   }
9239                 else
9240                   {
9241                     if (remote_debug)
9242                       {
9243                         if (!started_error_output)
9244                           {
9245                             started_error_output = 1;
9246                             fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9247                           }
9248                         fputc_unfiltered (ch & 0177, gdb_stdlog);
9249                         fprintf_unfiltered (gdb_stdlog, "%s", rs->buf.data ());
9250                       }
9251                   }
9252                 continue;
9253               }
9254               /* fall-through */
9255             default:
9256               if (remote_debug)
9257                 {
9258                   if (!started_error_output)
9259                     {
9260                       started_error_output = 1;
9261                       fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
9262                     }
9263                   fputc_unfiltered (ch & 0177, gdb_stdlog);
9264                 }
9265               continue;
9266             }
9267           break;                /* Here to retransmit.  */
9268         }
9269
9270 #if 0
9271       /* This is wrong.  If doing a long backtrace, the user should be
9272          able to get out next time we call QUIT, without anything as
9273          violent as interrupt_query.  If we want to provide a way out of
9274          here without getting to the next QUIT, it should be based on
9275          hitting ^C twice as in remote_wait.  */
9276       if (quit_flag)
9277         {
9278           quit_flag = 0;
9279           interrupt_query ();
9280         }
9281 #endif
9282     }
9283
9284   return 0;
9285 }
9286
9287 /* Come here after finding the start of a frame when we expected an
9288    ack.  Do our best to discard the rest of this packet.  */
9289
9290 void
9291 remote_target::skip_frame ()
9292 {
9293   int c;
9294
9295   while (1)
9296     {
9297       c = readchar (remote_timeout);
9298       switch (c)
9299         {
9300         case SERIAL_TIMEOUT:
9301           /* Nothing we can do.  */
9302           return;
9303         case '#':
9304           /* Discard the two bytes of checksum and stop.  */
9305           c = readchar (remote_timeout);
9306           if (c >= 0)
9307             c = readchar (remote_timeout);
9308
9309           return;
9310         case '*':               /* Run length encoding.  */
9311           /* Discard the repeat count.  */
9312           c = readchar (remote_timeout);
9313           if (c < 0)
9314             return;
9315           break;
9316         default:
9317           /* A regular character.  */
9318           break;
9319         }
9320     }
9321 }
9322
9323 /* Come here after finding the start of the frame.  Collect the rest
9324    into *BUF, verifying the checksum, length, and handling run-length
9325    compression.  NUL terminate the buffer.  If there is not enough room,
9326    expand *BUF.
9327
9328    Returns -1 on error, number of characters in buffer (ignoring the
9329    trailing NULL) on success. (could be extended to return one of the
9330    SERIAL status indications).  */
9331
9332 long
9333 remote_target::read_frame (gdb::char_vector *buf_p)
9334 {
9335   unsigned char csum;
9336   long bc;
9337   int c;
9338   char *buf = buf_p->data ();
9339   struct remote_state *rs = get_remote_state ();
9340
9341   csum = 0;
9342   bc = 0;
9343
9344   while (1)
9345     {
9346       c = readchar (remote_timeout);
9347       switch (c)
9348         {
9349         case SERIAL_TIMEOUT:
9350           if (remote_debug)
9351             fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
9352           return -1;
9353         case '$':
9354           if (remote_debug)
9355             fputs_filtered ("Saw new packet start in middle of old one\n",
9356                             gdb_stdlog);
9357           return -1;            /* Start a new packet, count retries.  */
9358         case '#':
9359           {
9360             unsigned char pktcsum;
9361             int check_0 = 0;
9362             int check_1 = 0;
9363
9364             buf[bc] = '\0';
9365
9366             check_0 = readchar (remote_timeout);
9367             if (check_0 >= 0)
9368               check_1 = readchar (remote_timeout);
9369
9370             if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
9371               {
9372                 if (remote_debug)
9373                   fputs_filtered ("Timeout in checksum, retrying\n",
9374                                   gdb_stdlog);
9375                 return -1;
9376               }
9377             else if (check_0 < 0 || check_1 < 0)
9378               {
9379                 if (remote_debug)
9380                   fputs_filtered ("Communication error in checksum\n",
9381                                   gdb_stdlog);
9382                 return -1;
9383               }
9384
9385             /* Don't recompute the checksum; with no ack packets we
9386                don't have any way to indicate a packet retransmission
9387                is necessary.  */
9388             if (rs->noack_mode)
9389               return bc;
9390
9391             pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
9392             if (csum == pktcsum)
9393               return bc;
9394
9395             if (remote_debug)
9396               {
9397                 std::string str = escape_buffer (buf, bc);
9398
9399                 fprintf_unfiltered (gdb_stdlog,
9400                                     "Bad checksum, sentsum=0x%x, "
9401                                     "csum=0x%x, buf=%s\n",
9402                                     pktcsum, csum, str.c_str ());
9403               }
9404             /* Number of characters in buffer ignoring trailing
9405                NULL.  */
9406             return -1;
9407           }
9408         case '*':               /* Run length encoding.  */
9409           {
9410             int repeat;
9411
9412             csum += c;
9413             c = readchar (remote_timeout);
9414             csum += c;
9415             repeat = c - ' ' + 3;       /* Compute repeat count.  */
9416
9417             /* The character before ``*'' is repeated.  */
9418
9419             if (repeat > 0 && repeat <= 255 && bc > 0)
9420               {
9421                 if (bc + repeat - 1 >= buf_p->size () - 1)
9422                   {
9423                     /* Make some more room in the buffer.  */
9424                     buf_p->resize (buf_p->size () + repeat);
9425                     buf = buf_p->data ();
9426                   }
9427
9428                 memset (&buf[bc], buf[bc - 1], repeat);
9429                 bc += repeat;
9430                 continue;
9431               }
9432
9433             buf[bc] = '\0';
9434             printf_filtered (_("Invalid run length encoding: %s\n"), buf);
9435             return -1;
9436           }
9437         default:
9438           if (bc >= buf_p->size () - 1)
9439             {
9440               /* Make some more room in the buffer.  */
9441               buf_p->resize (buf_p->size () * 2);
9442               buf = buf_p->data ();
9443             }
9444
9445           buf[bc++] = c;
9446           csum += c;
9447           continue;
9448         }
9449     }
9450 }
9451
9452 /* Set this to the maximum number of seconds to wait instead of waiting forever
9453    in target_wait().  If this timer times out, then it generates an error and
9454    the command is aborted.  This replaces most of the need for timeouts in the
9455    GDB test suite, and makes it possible to distinguish between a hung target
9456    and one with slow communications.  */
9457
9458 static int watchdog = 0;
9459 static void
9460 show_watchdog (struct ui_file *file, int from_tty,
9461                struct cmd_list_element *c, const char *value)
9462 {
9463   fprintf_filtered (file, _("Watchdog timer is %s.\n"), value);
9464 }
9465
9466 /* Read a packet from the remote machine, with error checking, and
9467    store it in *BUF.  Resize *BUF if necessary to hold the result.  If
9468    FOREVER, wait forever rather than timing out; this is used (in
9469    synchronous mode) to wait for a target that is is executing user
9470    code to stop.  */
9471 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9472    don't have to change all the calls to getpkt to deal with the
9473    return value, because at the moment I don't know what the right
9474    thing to do it for those.  */
9475
9476 void
9477 remote_target::getpkt (gdb::char_vector *buf, int forever)
9478 {
9479   getpkt_sane (buf, forever);
9480 }
9481
9482
9483 /* Read a packet from the remote machine, with error checking, and
9484    store it in *BUF.  Resize *BUF if necessary to hold the result.  If
9485    FOREVER, wait forever rather than timing out; this is used (in
9486    synchronous mode) to wait for a target that is is executing user
9487    code to stop.  If FOREVER == 0, this function is allowed to time
9488    out gracefully and return an indication of this to the caller.
9489    Otherwise return the number of bytes read.  If EXPECTING_NOTIF,
9490    consider receiving a notification enough reason to return to the
9491    caller.  *IS_NOTIF is an output boolean that indicates whether *BUF
9492    holds a notification or not (a regular packet).  */
9493
9494 int
9495 remote_target::getpkt_or_notif_sane_1 (gdb::char_vector *buf,
9496                                        int forever, int expecting_notif,
9497                                        int *is_notif)
9498 {
9499   struct remote_state *rs = get_remote_state ();
9500   int c;
9501   int tries;
9502   int timeout;
9503   int val = -1;
9504
9505   /* We're reading a new response.  Make sure we don't look at a
9506      previously cached response.  */
9507   rs->cached_wait_status = 0;
9508
9509   strcpy (buf->data (), "timeout");
9510
9511   if (forever)
9512     timeout = watchdog > 0 ? watchdog : -1;
9513   else if (expecting_notif)
9514     timeout = 0; /* There should already be a char in the buffer.  If
9515                     not, bail out.  */
9516   else
9517     timeout = remote_timeout;
9518
9519 #define MAX_TRIES 3
9520
9521   /* Process any number of notifications, and then return when
9522      we get a packet.  */
9523   for (;;)
9524     {
9525       /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9526          times.  */
9527       for (tries = 1; tries <= MAX_TRIES; tries++)
9528         {
9529           /* This can loop forever if the remote side sends us
9530              characters continuously, but if it pauses, we'll get
9531              SERIAL_TIMEOUT from readchar because of timeout.  Then
9532              we'll count that as a retry.
9533
9534              Note that even when forever is set, we will only wait
9535              forever prior to the start of a packet.  After that, we
9536              expect characters to arrive at a brisk pace.  They should
9537              show up within remote_timeout intervals.  */
9538           do
9539             c = readchar (timeout);
9540           while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
9541
9542           if (c == SERIAL_TIMEOUT)
9543             {
9544               if (expecting_notif)
9545                 return -1; /* Don't complain, it's normal to not get
9546                               anything in this case.  */
9547
9548               if (forever)      /* Watchdog went off?  Kill the target.  */
9549                 {
9550                   remote_unpush_target ();
9551                   throw_error (TARGET_CLOSE_ERROR,
9552                                _("Watchdog timeout has expired.  "
9553                                  "Target detached."));
9554                 }
9555               if (remote_debug)
9556                 fputs_filtered ("Timed out.\n", gdb_stdlog);
9557             }
9558           else
9559             {
9560               /* We've found the start of a packet or notification.
9561                  Now collect the data.  */
9562               val = read_frame (buf);
9563               if (val >= 0)
9564                 break;
9565             }
9566
9567           remote_serial_write ("-", 1);
9568         }
9569
9570       if (tries > MAX_TRIES)
9571         {
9572           /* We have tried hard enough, and just can't receive the
9573              packet/notification.  Give up.  */
9574           printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9575
9576           /* Skip the ack char if we're in no-ack mode.  */
9577           if (!rs->noack_mode)
9578             remote_serial_write ("+", 1);
9579           return -1;
9580         }
9581
9582       /* If we got an ordinary packet, return that to our caller.  */
9583       if (c == '$')
9584         {
9585           if (remote_debug)
9586             {
9587               std::string str
9588                 = escape_buffer (buf->data (),
9589                                  std::min (val, REMOTE_DEBUG_MAX_CHAR));
9590
9591               fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
9592                                   str.c_str ());
9593
9594               if (val > REMOTE_DEBUG_MAX_CHAR)
9595                 fprintf_unfiltered (gdb_stdlog, "[%d bytes omitted]",
9596                                     val - REMOTE_DEBUG_MAX_CHAR);
9597
9598               fprintf_unfiltered (gdb_stdlog, "\n");
9599             }
9600
9601           /* Skip the ack char if we're in no-ack mode.  */
9602           if (!rs->noack_mode)
9603             remote_serial_write ("+", 1);
9604           if (is_notif != NULL)
9605             *is_notif = 0;
9606           return val;
9607         }
9608
9609        /* If we got a notification, handle it, and go back to looking
9610          for a packet.  */
9611       else
9612         {
9613           gdb_assert (c == '%');
9614
9615           if (remote_debug)
9616             {
9617               std::string str = escape_buffer (buf->data (), val);
9618
9619               fprintf_unfiltered (gdb_stdlog,
9620                                   "  Notification received: %s\n",
9621                                   str.c_str ());
9622             }
9623           if (is_notif != NULL)
9624             *is_notif = 1;
9625
9626           handle_notification (rs->notif_state, buf->data ());
9627
9628           /* Notifications require no acknowledgement.  */
9629
9630           if (expecting_notif)
9631             return val;
9632         }
9633     }
9634 }
9635
9636 int
9637 remote_target::getpkt_sane (gdb::char_vector *buf, int forever)
9638 {
9639   return getpkt_or_notif_sane_1 (buf, forever, 0, NULL);
9640 }
9641
9642 int
9643 remote_target::getpkt_or_notif_sane (gdb::char_vector *buf, int forever,
9644                                      int *is_notif)
9645 {
9646   return getpkt_or_notif_sane_1 (buf, forever, 1, is_notif);
9647 }
9648
9649 /* Kill any new fork children of process PID that haven't been
9650    processed by follow_fork.  */
9651
9652 void
9653 remote_target::kill_new_fork_children (int pid)
9654 {
9655   remote_state *rs = get_remote_state ();
9656   struct notif_client *notif = &notif_client_stop;
9657
9658   /* Kill the fork child threads of any threads in process PID
9659      that are stopped at a fork event.  */
9660   for (thread_info *thread : all_non_exited_threads ())
9661     {
9662       struct target_waitstatus *ws = &thread->pending_follow;
9663
9664       if (is_pending_fork_parent (ws, pid, thread->ptid))
9665         {
9666           int child_pid = ws->value.related_pid.pid ();
9667           int res;
9668
9669           res = remote_vkill (child_pid);
9670           if (res != 0)
9671             error (_("Can't kill fork child process %d"), child_pid);
9672         }
9673     }
9674
9675   /* Check for any pending fork events (not reported or processed yet)
9676      in process PID and kill those fork child threads as well.  */
9677   remote_notif_get_pending_events (notif);
9678   for (auto &event : rs->stop_reply_queue)
9679     if (is_pending_fork_parent (&event->ws, pid, event->ptid))
9680       {
9681         int child_pid = event->ws.value.related_pid.pid ();
9682         int res;
9683
9684         res = remote_vkill (child_pid);
9685         if (res != 0)
9686           error (_("Can't kill fork child process %d"), child_pid);
9687       }
9688 }
9689
9690 \f
9691 /* Target hook to kill the current inferior.  */
9692
9693 void
9694 remote_target::kill ()
9695 {
9696   int res = -1;
9697   int pid = inferior_ptid.pid ();
9698   struct remote_state *rs = get_remote_state ();
9699
9700   if (packet_support (PACKET_vKill) != PACKET_DISABLE)
9701     {
9702       /* If we're stopped while forking and we haven't followed yet,
9703          kill the child task.  We need to do this before killing the
9704          parent task because if this is a vfork then the parent will
9705          be sleeping.  */
9706       kill_new_fork_children (pid);
9707
9708       res = remote_vkill (pid);
9709       if (res == 0)
9710         {
9711           target_mourn_inferior (inferior_ptid);
9712           return;
9713         }
9714     }
9715
9716   /* If we are in 'target remote' mode and we are killing the only
9717      inferior, then we will tell gdbserver to exit and unpush the
9718      target.  */
9719   if (res == -1 && !remote_multi_process_p (rs)
9720       && number_of_live_inferiors () == 1)
9721     {
9722       remote_kill_k ();
9723
9724       /* We've killed the remote end, we get to mourn it.  If we are
9725          not in extended mode, mourning the inferior also unpushes
9726          remote_ops from the target stack, which closes the remote
9727          connection.  */
9728       target_mourn_inferior (inferior_ptid);
9729
9730       return;
9731     }
9732
9733   error (_("Can't kill process"));
9734 }
9735
9736 /* Send a kill request to the target using the 'vKill' packet.  */
9737
9738 int
9739 remote_target::remote_vkill (int pid)
9740 {
9741   if (packet_support (PACKET_vKill) == PACKET_DISABLE)
9742     return -1;
9743
9744   remote_state *rs = get_remote_state ();
9745
9746   /* Tell the remote target to detach.  */
9747   xsnprintf (rs->buf.data (), get_remote_packet_size (), "vKill;%x", pid);
9748   putpkt (rs->buf);
9749   getpkt (&rs->buf, 0);
9750
9751   switch (packet_ok (rs->buf,
9752                      &remote_protocol_packets[PACKET_vKill]))
9753     {
9754     case PACKET_OK:
9755       return 0;
9756     case PACKET_ERROR:
9757       return 1;
9758     case PACKET_UNKNOWN:
9759       return -1;
9760     default:
9761       internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
9762     }
9763 }
9764
9765 /* Send a kill request to the target using the 'k' packet.  */
9766
9767 void
9768 remote_target::remote_kill_k ()
9769 {
9770   /* Catch errors so the user can quit from gdb even when we
9771      aren't on speaking terms with the remote system.  */
9772   try
9773     {
9774       putpkt ("k");
9775     }
9776   catch (const gdb_exception_error &ex)
9777     {
9778       if (ex.error == TARGET_CLOSE_ERROR)
9779         {
9780           /* If we got an (EOF) error that caused the target
9781              to go away, then we're done, that's what we wanted.
9782              "k" is susceptible to cause a premature EOF, given
9783              that the remote server isn't actually required to
9784              reply to "k", and it can happen that it doesn't
9785              even get to reply ACK to the "k".  */
9786           return;
9787         }
9788
9789       /* Otherwise, something went wrong.  We didn't actually kill
9790          the target.  Just propagate the exception, and let the
9791          user or higher layers decide what to do.  */
9792       throw;
9793     }
9794 }
9795
9796 void
9797 remote_target::mourn_inferior ()
9798 {
9799   struct remote_state *rs = get_remote_state ();
9800
9801   /* We're no longer interested in notification events of an inferior
9802      that exited or was killed/detached.  */
9803   discard_pending_stop_replies (current_inferior ());
9804
9805   /* In 'target remote' mode with one inferior, we close the connection.  */
9806   if (!rs->extended && number_of_live_inferiors () <= 1)
9807     {
9808       unpush_target (this);
9809
9810       /* remote_close takes care of doing most of the clean up.  */
9811       generic_mourn_inferior ();
9812       return;
9813     }
9814
9815   /* In case we got here due to an error, but we're going to stay
9816      connected.  */
9817   rs->waiting_for_stop_reply = 0;
9818
9819   /* If the current general thread belonged to the process we just
9820      detached from or has exited, the remote side current general
9821      thread becomes undefined.  Considering a case like this:
9822
9823      - We just got here due to a detach.
9824      - The process that we're detaching from happens to immediately
9825        report a global breakpoint being hit in non-stop mode, in the
9826        same thread we had selected before.
9827      - GDB attaches to this process again.
9828      - This event happens to be the next event we handle.
9829
9830      GDB would consider that the current general thread didn't need to
9831      be set on the stub side (with Hg), since for all it knew,
9832      GENERAL_THREAD hadn't changed.
9833
9834      Notice that although in all-stop mode, the remote server always
9835      sets the current thread to the thread reporting the stop event,
9836      that doesn't happen in non-stop mode; in non-stop, the stub *must
9837      not* change the current thread when reporting a breakpoint hit,
9838      due to the decoupling of event reporting and event handling.
9839
9840      To keep things simple, we always invalidate our notion of the
9841      current thread.  */
9842   record_currthread (rs, minus_one_ptid);
9843
9844   /* Call common code to mark the inferior as not running.  */
9845   generic_mourn_inferior ();
9846
9847   if (!have_inferiors ())
9848     {
9849       if (!remote_multi_process_p (rs))
9850         {
9851           /* Check whether the target is running now - some remote stubs
9852              automatically restart after kill.  */
9853           putpkt ("?");
9854           getpkt (&rs->buf, 0);
9855
9856           if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
9857             {
9858               /* Assume that the target has been restarted.  Set
9859                  inferior_ptid so that bits of core GDB realizes
9860                  there's something here, e.g., so that the user can
9861                  say "kill" again.  */
9862               inferior_ptid = magic_null_ptid;
9863             }
9864         }
9865     }
9866 }
9867
9868 bool
9869 extended_remote_target::supports_disable_randomization ()
9870 {
9871   return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
9872 }
9873
9874 void
9875 remote_target::extended_remote_disable_randomization (int val)
9876 {
9877   struct remote_state *rs = get_remote_state ();
9878   char *reply;
9879
9880   xsnprintf (rs->buf.data (), get_remote_packet_size (),
9881              "QDisableRandomization:%x", val);
9882   putpkt (rs->buf);
9883   reply = remote_get_noisy_reply ();
9884   if (*reply == '\0')
9885     error (_("Target does not support QDisableRandomization."));
9886   if (strcmp (reply, "OK") != 0)
9887     error (_("Bogus QDisableRandomization reply from target: %s"), reply);
9888 }
9889
9890 int
9891 remote_target::extended_remote_run (const std::string &args)
9892 {
9893   struct remote_state *rs = get_remote_state ();
9894   int len;
9895   const char *remote_exec_file = get_remote_exec_file ();
9896
9897   /* If the user has disabled vRun support, or we have detected that
9898      support is not available, do not try it.  */
9899   if (packet_support (PACKET_vRun) == PACKET_DISABLE)
9900     return -1;
9901
9902   strcpy (rs->buf.data (), "vRun;");
9903   len = strlen (rs->buf.data ());
9904
9905   if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
9906     error (_("Remote file name too long for run packet"));
9907   len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf.data () + len,
9908                       strlen (remote_exec_file));
9909
9910   if (!args.empty ())
9911     {
9912       int i;
9913
9914       gdb_argv argv (args.c_str ());
9915       for (i = 0; argv[i] != NULL; i++)
9916         {
9917           if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
9918             error (_("Argument list too long for run packet"));
9919           rs->buf[len++] = ';';
9920           len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf.data () + len,
9921                               strlen (argv[i]));
9922         }
9923     }
9924
9925   rs->buf[len++] = '\0';
9926
9927   putpkt (rs->buf);
9928   getpkt (&rs->buf, 0);
9929
9930   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
9931     {
9932     case PACKET_OK:
9933       /* We have a wait response.  All is well.  */
9934       return 0;
9935     case PACKET_UNKNOWN:
9936       return -1;
9937     case PACKET_ERROR:
9938       if (remote_exec_file[0] == '\0')
9939         error (_("Running the default executable on the remote target failed; "
9940                  "try \"set remote exec-file\"?"));
9941       else
9942         error (_("Running \"%s\" on the remote target failed"),
9943                remote_exec_file);
9944     default:
9945       gdb_assert_not_reached (_("bad switch"));
9946     }
9947 }
9948
9949 /* Helper function to send set/unset environment packets.  ACTION is
9950    either "set" or "unset".  PACKET is either "QEnvironmentHexEncoded"
9951    or "QEnvironmentUnsetVariable".  VALUE is the variable to be
9952    sent.  */
9953
9954 void
9955 remote_target::send_environment_packet (const char *action,
9956                                         const char *packet,
9957                                         const char *value)
9958 {
9959   remote_state *rs = get_remote_state ();
9960
9961   /* Convert the environment variable to an hex string, which
9962      is the best format to be transmitted over the wire.  */
9963   std::string encoded_value = bin2hex ((const gdb_byte *) value,
9964                                          strlen (value));
9965
9966   xsnprintf (rs->buf.data (), get_remote_packet_size (),
9967              "%s:%s", packet, encoded_value.c_str ());
9968
9969   putpkt (rs->buf);
9970   getpkt (&rs->buf, 0);
9971   if (strcmp (rs->buf.data (), "OK") != 0)
9972     warning (_("Unable to %s environment variable '%s' on remote."),
9973              action, value);
9974 }
9975
9976 /* Helper function to handle the QEnvironment* packets.  */
9977
9978 void
9979 remote_target::extended_remote_environment_support ()
9980 {
9981   remote_state *rs = get_remote_state ();
9982
9983   if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
9984     {
9985       putpkt ("QEnvironmentReset");
9986       getpkt (&rs->buf, 0);
9987       if (strcmp (rs->buf.data (), "OK") != 0)
9988         warning (_("Unable to reset environment on remote."));
9989     }
9990
9991   gdb_environ *e = &current_inferior ()->environment;
9992
9993   if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
9994     for (const std::string &el : e->user_set_env ())
9995       send_environment_packet ("set", "QEnvironmentHexEncoded",
9996                                el.c_str ());
9997
9998   if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
9999     for (const std::string &el : e->user_unset_env ())
10000       send_environment_packet ("unset", "QEnvironmentUnset", el.c_str ());
10001 }
10002
10003 /* Helper function to set the current working directory for the
10004    inferior in the remote target.  */
10005
10006 void
10007 remote_target::extended_remote_set_inferior_cwd ()
10008 {
10009   if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
10010     {
10011       const char *inferior_cwd = get_inferior_cwd ();
10012       remote_state *rs = get_remote_state ();
10013
10014       if (inferior_cwd != NULL)
10015         {
10016           std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
10017                                          strlen (inferior_cwd));
10018
10019           xsnprintf (rs->buf.data (), get_remote_packet_size (),
10020                      "QSetWorkingDir:%s", hexpath.c_str ());
10021         }
10022       else
10023         {
10024           /* An empty inferior_cwd means that the user wants us to
10025              reset the remote server's inferior's cwd.  */
10026           xsnprintf (rs->buf.data (), get_remote_packet_size (),
10027                      "QSetWorkingDir:");
10028         }
10029
10030       putpkt (rs->buf);
10031       getpkt (&rs->buf, 0);
10032       if (packet_ok (rs->buf,
10033                      &remote_protocol_packets[PACKET_QSetWorkingDir])
10034           != PACKET_OK)
10035         error (_("\
10036 Remote replied unexpectedly while setting the inferior's working\n\
10037 directory: %s"),
10038                rs->buf.data ());
10039
10040     }
10041 }
10042
10043 /* In the extended protocol we want to be able to do things like
10044    "run" and have them basically work as expected.  So we need
10045    a special create_inferior function.  We support changing the
10046    executable file and the command line arguments, but not the
10047    environment.  */
10048
10049 void
10050 extended_remote_target::create_inferior (const char *exec_file,
10051                                          const std::string &args,
10052                                          char **env, int from_tty)
10053 {
10054   int run_worked;
10055   char *stop_reply;
10056   struct remote_state *rs = get_remote_state ();
10057   const char *remote_exec_file = get_remote_exec_file ();
10058
10059   /* If running asynchronously, register the target file descriptor
10060      with the event loop.  */
10061   if (target_can_async_p ())
10062     target_async (1);
10063
10064   /* Disable address space randomization if requested (and supported).  */
10065   if (supports_disable_randomization ())
10066     extended_remote_disable_randomization (disable_randomization);
10067
10068   /* If startup-with-shell is on, we inform gdbserver to start the
10069      remote inferior using a shell.  */
10070   if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
10071     {
10072       xsnprintf (rs->buf.data (), get_remote_packet_size (),
10073                  "QStartupWithShell:%d", startup_with_shell ? 1 : 0);
10074       putpkt (rs->buf);
10075       getpkt (&rs->buf, 0);
10076       if (strcmp (rs->buf.data (), "OK") != 0)
10077         error (_("\
10078 Remote replied unexpectedly while setting startup-with-shell: %s"),
10079                rs->buf.data ());
10080     }
10081
10082   extended_remote_environment_support ();
10083
10084   extended_remote_set_inferior_cwd ();
10085
10086   /* Now restart the remote server.  */
10087   run_worked = extended_remote_run (args) != -1;
10088   if (!run_worked)
10089     {
10090       /* vRun was not supported.  Fail if we need it to do what the
10091          user requested.  */
10092       if (remote_exec_file[0])
10093         error (_("Remote target does not support \"set remote exec-file\""));
10094       if (!args.empty ())
10095         error (_("Remote target does not support \"set args\" or run ARGS"));
10096
10097       /* Fall back to "R".  */
10098       extended_remote_restart ();
10099     }
10100
10101   /* vRun's success return is a stop reply.  */
10102   stop_reply = run_worked ? rs->buf.data () : NULL;
10103   add_current_inferior_and_thread (stop_reply);
10104
10105   /* Get updated offsets, if the stub uses qOffsets.  */
10106   get_offsets ();
10107 }
10108 \f
10109
10110 /* Given a location's target info BP_TGT and the packet buffer BUF,  output
10111    the list of conditions (in agent expression bytecode format), if any, the
10112    target needs to evaluate.  The output is placed into the packet buffer
10113    started from BUF and ended at BUF_END.  */
10114
10115 static int
10116 remote_add_target_side_condition (struct gdbarch *gdbarch,
10117                                   struct bp_target_info *bp_tgt, char *buf,
10118                                   char *buf_end)
10119 {
10120   if (bp_tgt->conditions.empty ())
10121     return 0;
10122
10123   buf += strlen (buf);
10124   xsnprintf (buf, buf_end - buf, "%s", ";");
10125   buf++;
10126
10127   /* Send conditions to the target.  */
10128   for (agent_expr *aexpr : bp_tgt->conditions)
10129     {
10130       xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
10131       buf += strlen (buf);
10132       for (int i = 0; i < aexpr->len; ++i)
10133         buf = pack_hex_byte (buf, aexpr->buf[i]);
10134       *buf = '\0';
10135     }
10136   return 0;
10137 }
10138
10139 static void
10140 remote_add_target_side_commands (struct gdbarch *gdbarch,
10141                                  struct bp_target_info *bp_tgt, char *buf)
10142 {
10143   if (bp_tgt->tcommands.empty ())
10144     return;
10145
10146   buf += strlen (buf);
10147
10148   sprintf (buf, ";cmds:%x,", bp_tgt->persist);
10149   buf += strlen (buf);
10150
10151   /* Concatenate all the agent expressions that are commands into the
10152      cmds parameter.  */
10153   for (agent_expr *aexpr : bp_tgt->tcommands)
10154     {
10155       sprintf (buf, "X%x,", aexpr->len);
10156       buf += strlen (buf);
10157       for (int i = 0; i < aexpr->len; ++i)
10158         buf = pack_hex_byte (buf, aexpr->buf[i]);
10159       *buf = '\0';
10160     }
10161 }
10162
10163 /* Insert a breakpoint.  On targets that have software breakpoint
10164    support, we ask the remote target to do the work; on targets
10165    which don't, we insert a traditional memory breakpoint.  */
10166
10167 int
10168 remote_target::insert_breakpoint (struct gdbarch *gdbarch,
10169                                   struct bp_target_info *bp_tgt)
10170 {
10171   /* Try the "Z" s/w breakpoint packet if it is not already disabled.
10172      If it succeeds, then set the support to PACKET_ENABLE.  If it
10173      fails, and the user has explicitly requested the Z support then
10174      report an error, otherwise, mark it disabled and go on.  */
10175
10176   if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10177     {
10178       CORE_ADDR addr = bp_tgt->reqstd_address;
10179       struct remote_state *rs;
10180       char *p, *endbuf;
10181
10182       /* Make sure the remote is pointing at the right process, if
10183          necessary.  */
10184       if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10185         set_general_process ();
10186
10187       rs = get_remote_state ();
10188       p = rs->buf.data ();
10189       endbuf = p + get_remote_packet_size ();
10190
10191       *(p++) = 'Z';
10192       *(p++) = '0';
10193       *(p++) = ',';
10194       addr = (ULONGEST) remote_address_masked (addr);
10195       p += hexnumstr (p, addr);
10196       xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10197
10198       if (supports_evaluation_of_breakpoint_conditions ())
10199         remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10200
10201       if (can_run_breakpoint_commands ())
10202         remote_add_target_side_commands (gdbarch, bp_tgt, p);
10203
10204       putpkt (rs->buf);
10205       getpkt (&rs->buf, 0);
10206
10207       switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
10208         {
10209         case PACKET_ERROR:
10210           return -1;
10211         case PACKET_OK:
10212           return 0;
10213         case PACKET_UNKNOWN:
10214           break;
10215         }
10216     }
10217
10218   /* If this breakpoint has target-side commands but this stub doesn't
10219      support Z0 packets, throw error.  */
10220   if (!bp_tgt->tcommands.empty ())
10221     throw_error (NOT_SUPPORTED_ERROR, _("\
10222 Target doesn't support breakpoints that have target side commands."));
10223
10224   return memory_insert_breakpoint (this, gdbarch, bp_tgt);
10225 }
10226
10227 int
10228 remote_target::remove_breakpoint (struct gdbarch *gdbarch,
10229                                   struct bp_target_info *bp_tgt,
10230                                   enum remove_bp_reason reason)
10231 {
10232   CORE_ADDR addr = bp_tgt->placed_address;
10233   struct remote_state *rs = get_remote_state ();
10234
10235   if (packet_support (PACKET_Z0) != PACKET_DISABLE)
10236     {
10237       char *p = rs->buf.data ();
10238       char *endbuf = p + get_remote_packet_size ();
10239
10240       /* Make sure the remote is pointing at the right process, if
10241          necessary.  */
10242       if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10243         set_general_process ();
10244
10245       *(p++) = 'z';
10246       *(p++) = '0';
10247       *(p++) = ',';
10248
10249       addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
10250       p += hexnumstr (p, addr);
10251       xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
10252
10253       putpkt (rs->buf);
10254       getpkt (&rs->buf, 0);
10255
10256       return (rs->buf[0] == 'E');
10257     }
10258
10259   return memory_remove_breakpoint (this, gdbarch, bp_tgt, reason);
10260 }
10261
10262 static enum Z_packet_type
10263 watchpoint_to_Z_packet (int type)
10264 {
10265   switch (type)
10266     {
10267     case hw_write:
10268       return Z_PACKET_WRITE_WP;
10269       break;
10270     case hw_read:
10271       return Z_PACKET_READ_WP;
10272       break;
10273     case hw_access:
10274       return Z_PACKET_ACCESS_WP;
10275       break;
10276     default:
10277       internal_error (__FILE__, __LINE__,
10278                       _("hw_bp_to_z: bad watchpoint type %d"), type);
10279     }
10280 }
10281
10282 int
10283 remote_target::insert_watchpoint (CORE_ADDR addr, int len,
10284                                   enum target_hw_bp_type type, struct expression *cond)
10285 {
10286   struct remote_state *rs = get_remote_state ();
10287   char *endbuf = rs->buf.data () + get_remote_packet_size ();
10288   char *p;
10289   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10290
10291   if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10292     return 1;
10293
10294   /* Make sure the remote is pointing at the right process, if
10295      necessary.  */
10296   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10297     set_general_process ();
10298
10299   xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "Z%x,", packet);
10300   p = strchr (rs->buf.data (), '\0');
10301   addr = remote_address_masked (addr);
10302   p += hexnumstr (p, (ULONGEST) addr);
10303   xsnprintf (p, endbuf - p, ",%x", len);
10304
10305   putpkt (rs->buf);
10306   getpkt (&rs->buf, 0);
10307
10308   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10309     {
10310     case PACKET_ERROR:
10311       return -1;
10312     case PACKET_UNKNOWN:
10313       return 1;
10314     case PACKET_OK:
10315       return 0;
10316     }
10317   internal_error (__FILE__, __LINE__,
10318                   _("remote_insert_watchpoint: reached end of function"));
10319 }
10320
10321 bool
10322 remote_target::watchpoint_addr_within_range (CORE_ADDR addr,
10323                                              CORE_ADDR start, int length)
10324 {
10325   CORE_ADDR diff = remote_address_masked (addr - start);
10326
10327   return diff < length;
10328 }
10329
10330
10331 int
10332 remote_target::remove_watchpoint (CORE_ADDR addr, int len,
10333                                   enum target_hw_bp_type type, struct expression *cond)
10334 {
10335   struct remote_state *rs = get_remote_state ();
10336   char *endbuf = rs->buf.data () + get_remote_packet_size ();
10337   char *p;
10338   enum Z_packet_type packet = watchpoint_to_Z_packet (type);
10339
10340   if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
10341     return -1;
10342
10343   /* Make sure the remote is pointing at the right process, if
10344      necessary.  */
10345   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10346     set_general_process ();
10347
10348   xsnprintf (rs->buf.data (), endbuf - rs->buf.data (), "z%x,", packet);
10349   p = strchr (rs->buf.data (), '\0');
10350   addr = remote_address_masked (addr);
10351   p += hexnumstr (p, (ULONGEST) addr);
10352   xsnprintf (p, endbuf - p, ",%x", len);
10353   putpkt (rs->buf);
10354   getpkt (&rs->buf, 0);
10355
10356   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10357     {
10358     case PACKET_ERROR:
10359     case PACKET_UNKNOWN:
10360       return -1;
10361     case PACKET_OK:
10362       return 0;
10363     }
10364   internal_error (__FILE__, __LINE__,
10365                   _("remote_remove_watchpoint: reached end of function"));
10366 }
10367
10368
10369 static int remote_hw_watchpoint_limit = -1;
10370 static int remote_hw_watchpoint_length_limit = -1;
10371 static int remote_hw_breakpoint_limit = -1;
10372
10373 int
10374 remote_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
10375 {
10376   if (remote_hw_watchpoint_length_limit == 0)
10377     return 0;
10378   else if (remote_hw_watchpoint_length_limit < 0)
10379     return 1;
10380   else if (len <= remote_hw_watchpoint_length_limit)
10381     return 1;
10382   else
10383     return 0;
10384 }
10385
10386 int
10387 remote_target::can_use_hw_breakpoint (enum bptype type, int cnt, int ot)
10388 {
10389   if (type == bp_hardware_breakpoint)
10390     {
10391       if (remote_hw_breakpoint_limit == 0)
10392         return 0;
10393       else if (remote_hw_breakpoint_limit < 0)
10394         return 1;
10395       else if (cnt <= remote_hw_breakpoint_limit)
10396         return 1;
10397     }
10398   else
10399     {
10400       if (remote_hw_watchpoint_limit == 0)
10401         return 0;
10402       else if (remote_hw_watchpoint_limit < 0)
10403         return 1;
10404       else if (ot)
10405         return -1;
10406       else if (cnt <= remote_hw_watchpoint_limit)
10407         return 1;
10408     }
10409   return -1;
10410 }
10411
10412 /* The to_stopped_by_sw_breakpoint method of target remote.  */
10413
10414 bool
10415 remote_target::stopped_by_sw_breakpoint ()
10416 {
10417   struct thread_info *thread = inferior_thread ();
10418
10419   return (thread->priv != NULL
10420           && (get_remote_thread_info (thread)->stop_reason
10421               == TARGET_STOPPED_BY_SW_BREAKPOINT));
10422 }
10423
10424 /* The to_supports_stopped_by_sw_breakpoint method of target
10425    remote.  */
10426
10427 bool
10428 remote_target::supports_stopped_by_sw_breakpoint ()
10429 {
10430   return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
10431 }
10432
10433 /* The to_stopped_by_hw_breakpoint method of target remote.  */
10434
10435 bool
10436 remote_target::stopped_by_hw_breakpoint ()
10437 {
10438   struct thread_info *thread = inferior_thread ();
10439
10440   return (thread->priv != NULL
10441           && (get_remote_thread_info (thread)->stop_reason
10442               == TARGET_STOPPED_BY_HW_BREAKPOINT));
10443 }
10444
10445 /* The to_supports_stopped_by_hw_breakpoint method of target
10446    remote.  */
10447
10448 bool
10449 remote_target::supports_stopped_by_hw_breakpoint ()
10450 {
10451   return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
10452 }
10453
10454 bool
10455 remote_target::stopped_by_watchpoint ()
10456 {
10457   struct thread_info *thread = inferior_thread ();
10458
10459   return (thread->priv != NULL
10460           && (get_remote_thread_info (thread)->stop_reason
10461               == TARGET_STOPPED_BY_WATCHPOINT));
10462 }
10463
10464 bool
10465 remote_target::stopped_data_address (CORE_ADDR *addr_p)
10466 {
10467   struct thread_info *thread = inferior_thread ();
10468
10469   if (thread->priv != NULL
10470       && (get_remote_thread_info (thread)->stop_reason
10471           == TARGET_STOPPED_BY_WATCHPOINT))
10472     {
10473       *addr_p = get_remote_thread_info (thread)->watch_data_address;
10474       return true;
10475     }
10476
10477   return false;
10478 }
10479
10480
10481 int
10482 remote_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
10483                                      struct bp_target_info *bp_tgt)
10484 {
10485   CORE_ADDR addr = bp_tgt->reqstd_address;
10486   struct remote_state *rs;
10487   char *p, *endbuf;
10488   char *message;
10489
10490   if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10491     return -1;
10492
10493   /* Make sure the remote is pointing at the right process, if
10494      necessary.  */
10495   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10496     set_general_process ();
10497
10498   rs = get_remote_state ();
10499   p = rs->buf.data ();
10500   endbuf = p + get_remote_packet_size ();
10501
10502   *(p++) = 'Z';
10503   *(p++) = '1';
10504   *(p++) = ',';
10505
10506   addr = remote_address_masked (addr);
10507   p += hexnumstr (p, (ULONGEST) addr);
10508   xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10509
10510   if (supports_evaluation_of_breakpoint_conditions ())
10511     remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10512
10513   if (can_run_breakpoint_commands ())
10514     remote_add_target_side_commands (gdbarch, bp_tgt, p);
10515
10516   putpkt (rs->buf);
10517   getpkt (&rs->buf, 0);
10518
10519   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10520     {
10521     case PACKET_ERROR:
10522       if (rs->buf[1] == '.')
10523         {
10524           message = strchr (&rs->buf[2], '.');
10525           if (message)
10526             error (_("Remote failure reply: %s"), message + 1);
10527         }
10528       return -1;
10529     case PACKET_UNKNOWN:
10530       return -1;
10531     case PACKET_OK:
10532       return 0;
10533     }
10534   internal_error (__FILE__, __LINE__,
10535                   _("remote_insert_hw_breakpoint: reached end of function"));
10536 }
10537
10538
10539 int
10540 remote_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
10541                                      struct bp_target_info *bp_tgt)
10542 {
10543   CORE_ADDR addr;
10544   struct remote_state *rs = get_remote_state ();
10545   char *p = rs->buf.data ();
10546   char *endbuf = p + get_remote_packet_size ();
10547
10548   if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10549     return -1;
10550
10551   /* Make sure the remote is pointing at the right process, if
10552      necessary.  */
10553   if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10554     set_general_process ();
10555
10556   *(p++) = 'z';
10557   *(p++) = '1';
10558   *(p++) = ',';
10559
10560   addr = remote_address_masked (bp_tgt->placed_address);
10561   p += hexnumstr (p, (ULONGEST) addr);
10562   xsnprintf (p, endbuf  - p, ",%x", bp_tgt->kind);
10563
10564   putpkt (rs->buf);
10565   getpkt (&rs->buf, 0);
10566
10567   switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10568     {
10569     case PACKET_ERROR:
10570     case PACKET_UNKNOWN:
10571       return -1;
10572     case PACKET_OK:
10573       return 0;
10574     }
10575   internal_error (__FILE__, __LINE__,
10576                   _("remote_remove_hw_breakpoint: reached end of function"));
10577 }
10578
10579 /* Verify memory using the "qCRC:" request.  */
10580
10581 int
10582 remote_target::verify_memory (const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
10583 {
10584   struct remote_state *rs = get_remote_state ();
10585   unsigned long host_crc, target_crc;
10586   char *tmp;
10587
10588   /* It doesn't make sense to use qCRC if the remote target is
10589      connected but not running.  */
10590   if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
10591     {
10592       enum packet_result result;
10593
10594       /* Make sure the remote is pointing at the right process.  */
10595       set_general_process ();
10596
10597       /* FIXME: assumes lma can fit into long.  */
10598       xsnprintf (rs->buf.data (), get_remote_packet_size (), "qCRC:%lx,%lx",
10599                  (long) lma, (long) size);
10600       putpkt (rs->buf);
10601
10602       /* Be clever; compute the host_crc before waiting for target
10603          reply.  */
10604       host_crc = xcrc32 (data, size, 0xffffffff);
10605
10606       getpkt (&rs->buf, 0);
10607
10608       result = packet_ok (rs->buf,
10609                           &remote_protocol_packets[PACKET_qCRC]);
10610       if (result == PACKET_ERROR)
10611         return -1;
10612       else if (result == PACKET_OK)
10613         {
10614           for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
10615             target_crc = target_crc * 16 + fromhex (*tmp);
10616
10617           return (host_crc == target_crc);
10618         }
10619     }
10620
10621   return simple_verify_memory (this, data, lma, size);
10622 }
10623
10624 /* compare-sections command
10625
10626    With no arguments, compares each loadable section in the exec bfd
10627    with the same memory range on the target, and reports mismatches.
10628    Useful for verifying the image on the target against the exec file.  */
10629
10630 static void
10631 compare_sections_command (const char *args, int from_tty)
10632 {
10633   asection *s;
10634   const char *sectname;
10635   bfd_size_type size;
10636   bfd_vma lma;
10637   int matched = 0;
10638   int mismatched = 0;
10639   int res;
10640   int read_only = 0;
10641
10642   if (!exec_bfd)
10643     error (_("command cannot be used without an exec file"));
10644
10645   if (args != NULL && strcmp (args, "-r") == 0)
10646     {
10647       read_only = 1;
10648       args = NULL;
10649     }
10650
10651   for (s = exec_bfd->sections; s; s = s->next)
10652     {
10653       if (!(s->flags & SEC_LOAD))
10654         continue;               /* Skip non-loadable section.  */
10655
10656       if (read_only && (s->flags & SEC_READONLY) == 0)
10657         continue;               /* Skip writeable sections */
10658
10659       size = bfd_get_section_size (s);
10660       if (size == 0)
10661         continue;               /* Skip zero-length section.  */
10662
10663       sectname = bfd_get_section_name (exec_bfd, s);
10664       if (args && strcmp (args, sectname) != 0)
10665         continue;               /* Not the section selected by user.  */
10666
10667       matched = 1;              /* Do this section.  */
10668       lma = s->lma;
10669
10670       gdb::byte_vector sectdata (size);
10671       bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
10672
10673       res = target_verify_memory (sectdata.data (), lma, size);
10674
10675       if (res == -1)
10676         error (_("target memory fault, section %s, range %s -- %s"), sectname,
10677                paddress (target_gdbarch (), lma),
10678                paddress (target_gdbarch (), lma + size));
10679
10680       printf_filtered ("Section %s, range %s -- %s: ", sectname,
10681                        paddress (target_gdbarch (), lma),
10682                        paddress (target_gdbarch (), lma + size));
10683       if (res)
10684         printf_filtered ("matched.\n");
10685       else
10686         {
10687           printf_filtered ("MIS-MATCHED!\n");
10688           mismatched++;
10689         }
10690     }
10691   if (mismatched > 0)
10692     warning (_("One or more sections of the target image does not match\n\
10693 the loaded file\n"));
10694   if (args && !matched)
10695     printf_filtered (_("No loaded section named '%s'.\n"), args);
10696 }
10697
10698 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10699    into remote target.  The number of bytes written to the remote
10700    target is returned, or -1 for error.  */
10701
10702 target_xfer_status
10703 remote_target::remote_write_qxfer (const char *object_name,
10704                                    const char *annex, const gdb_byte *writebuf,
10705                                    ULONGEST offset, LONGEST len,
10706                                    ULONGEST *xfered_len,
10707                                    struct packet_config *packet)
10708 {
10709   int i, buf_len;
10710   ULONGEST n;
10711   struct remote_state *rs = get_remote_state ();
10712   int max_size = get_memory_write_packet_size (); 
10713
10714   if (packet_config_support (packet) == PACKET_DISABLE)
10715     return TARGET_XFER_E_IO;
10716
10717   /* Insert header.  */
10718   i = snprintf (rs->buf.data (), max_size, 
10719                 "qXfer:%s:write:%s:%s:",
10720                 object_name, annex ? annex : "",
10721                 phex_nz (offset, sizeof offset));
10722   max_size -= (i + 1);
10723
10724   /* Escape as much data as fits into rs->buf.  */
10725   buf_len = remote_escape_output 
10726     (writebuf, len, 1, (gdb_byte *) rs->buf.data () + i, &max_size, max_size);
10727
10728   if (putpkt_binary (rs->buf.data (), i + buf_len) < 0
10729       || getpkt_sane (&rs->buf, 0) < 0
10730       || packet_ok (rs->buf, packet) != PACKET_OK)
10731     return TARGET_XFER_E_IO;
10732
10733   unpack_varlen_hex (rs->buf.data (), &n);
10734
10735   *xfered_len = n;
10736   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
10737 }
10738
10739 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10740    Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10741    number of bytes read is returned, or 0 for EOF, or -1 for error.
10742    The number of bytes read may be less than LEN without indicating an
10743    EOF.  PACKET is checked and updated to indicate whether the remote
10744    target supports this object.  */
10745
10746 target_xfer_status
10747 remote_target::remote_read_qxfer (const char *object_name,
10748                                   const char *annex,
10749                                   gdb_byte *readbuf, ULONGEST offset,
10750                                   LONGEST len,
10751                                   ULONGEST *xfered_len,
10752                                   struct packet_config *packet)
10753 {
10754   struct remote_state *rs = get_remote_state ();
10755   LONGEST i, n, packet_len;
10756
10757   if (packet_config_support (packet) == PACKET_DISABLE)
10758     return TARGET_XFER_E_IO;
10759
10760   /* Check whether we've cached an end-of-object packet that matches
10761      this request.  */
10762   if (rs->finished_object)
10763     {
10764       if (strcmp (object_name, rs->finished_object) == 0
10765           && strcmp (annex ? annex : "", rs->finished_annex) == 0
10766           && offset == rs->finished_offset)
10767         return TARGET_XFER_EOF;
10768
10769
10770       /* Otherwise, we're now reading something different.  Discard
10771          the cache.  */
10772       xfree (rs->finished_object);
10773       xfree (rs->finished_annex);
10774       rs->finished_object = NULL;
10775       rs->finished_annex = NULL;
10776     }
10777
10778   /* Request only enough to fit in a single packet.  The actual data
10779      may not, since we don't know how much of it will need to be escaped;
10780      the target is free to respond with slightly less data.  We subtract
10781      five to account for the response type and the protocol frame.  */
10782   n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
10783   snprintf (rs->buf.data (), get_remote_packet_size () - 4,
10784             "qXfer:%s:read:%s:%s,%s",
10785             object_name, annex ? annex : "",
10786             phex_nz (offset, sizeof offset),
10787             phex_nz (n, sizeof n));
10788   i = putpkt (rs->buf);
10789   if (i < 0)
10790     return TARGET_XFER_E_IO;
10791
10792   rs->buf[0] = '\0';
10793   packet_len = getpkt_sane (&rs->buf, 0);
10794   if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
10795     return TARGET_XFER_E_IO;
10796
10797   if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
10798     error (_("Unknown remote qXfer reply: %s"), rs->buf.data ());
10799
10800   /* 'm' means there is (or at least might be) more data after this
10801      batch.  That does not make sense unless there's at least one byte
10802      of data in this reply.  */
10803   if (rs->buf[0] == 'm' && packet_len == 1)
10804     error (_("Remote qXfer reply contained no data."));
10805
10806   /* Got some data.  */
10807   i = remote_unescape_input ((gdb_byte *) rs->buf.data () + 1,
10808                              packet_len - 1, readbuf, n);
10809
10810   /* 'l' is an EOF marker, possibly including a final block of data,
10811      or possibly empty.  If we have the final block of a non-empty
10812      object, record this fact to bypass a subsequent partial read.  */
10813   if (rs->buf[0] == 'l' && offset + i > 0)
10814     {
10815       rs->finished_object = xstrdup (object_name);
10816       rs->finished_annex = xstrdup (annex ? annex : "");
10817       rs->finished_offset = offset + i;
10818     }
10819
10820   if (i == 0)
10821     return TARGET_XFER_EOF;
10822   else
10823     {
10824       *xfered_len = i;
10825       return TARGET_XFER_OK;
10826     }
10827 }
10828
10829 enum target_xfer_status
10830 remote_target::xfer_partial (enum target_object object,
10831                              const char *annex, gdb_byte *readbuf,
10832                              const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
10833                              ULONGEST *xfered_len)
10834 {
10835   struct remote_state *rs;
10836   int i;
10837   char *p2;
10838   char query_type;
10839   int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
10840
10841   set_remote_traceframe ();
10842   set_general_thread (inferior_ptid);
10843
10844   rs = get_remote_state ();
10845
10846   /* Handle memory using the standard memory routines.  */
10847   if (object == TARGET_OBJECT_MEMORY)
10848     {
10849       /* If the remote target is connected but not running, we should
10850          pass this request down to a lower stratum (e.g. the executable
10851          file).  */
10852       if (!target_has_execution)
10853         return TARGET_XFER_EOF;
10854
10855       if (writebuf != NULL)
10856         return remote_write_bytes (offset, writebuf, len, unit_size,
10857                                    xfered_len);
10858       else
10859         return remote_read_bytes (offset, readbuf, len, unit_size,
10860                                   xfered_len);
10861     }
10862
10863   /* Handle SPU memory using qxfer packets.  */
10864   if (object == TARGET_OBJECT_SPU)
10865     {
10866       if (readbuf)
10867         return remote_read_qxfer ("spu", annex, readbuf, offset, len,
10868                                   xfered_len, &remote_protocol_packets
10869                                   [PACKET_qXfer_spu_read]);
10870       else
10871         return remote_write_qxfer ("spu", annex, writebuf, offset, len,
10872                                    xfered_len, &remote_protocol_packets
10873                                    [PACKET_qXfer_spu_write]);
10874     }
10875
10876   /* Handle extra signal info using qxfer packets.  */
10877   if (object == TARGET_OBJECT_SIGNAL_INFO)
10878     {
10879       if (readbuf)
10880         return remote_read_qxfer ("siginfo", annex, readbuf, offset, len,
10881                                   xfered_len, &remote_protocol_packets
10882                                   [PACKET_qXfer_siginfo_read]);
10883       else
10884         return remote_write_qxfer ("siginfo", annex,
10885                                    writebuf, offset, len, xfered_len,
10886                                    &remote_protocol_packets
10887                                    [PACKET_qXfer_siginfo_write]);
10888     }
10889
10890   if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
10891     {
10892       if (readbuf)
10893         return remote_read_qxfer ("statictrace", annex,
10894                                   readbuf, offset, len, xfered_len,
10895                                   &remote_protocol_packets
10896                                   [PACKET_qXfer_statictrace_read]);
10897       else
10898         return TARGET_XFER_E_IO;
10899     }
10900
10901   /* Only handle flash writes.  */
10902   if (writebuf != NULL)
10903     {
10904       switch (object)
10905         {
10906         case TARGET_OBJECT_FLASH:
10907           return remote_flash_write (offset, len, xfered_len,
10908                                      writebuf);
10909
10910         default:
10911           return TARGET_XFER_E_IO;
10912         }
10913     }
10914
10915   /* Map pre-existing objects onto letters.  DO NOT do this for new
10916      objects!!!  Instead specify new query packets.  */
10917   switch (object)
10918     {
10919     case TARGET_OBJECT_AVR:
10920       query_type = 'R';
10921       break;
10922
10923     case TARGET_OBJECT_AUXV:
10924       gdb_assert (annex == NULL);
10925       return remote_read_qxfer ("auxv", annex, readbuf, offset, len,
10926                                 xfered_len,
10927                                 &remote_protocol_packets[PACKET_qXfer_auxv]);
10928
10929     case TARGET_OBJECT_AVAILABLE_FEATURES:
10930       return remote_read_qxfer
10931         ("features", annex, readbuf, offset, len, xfered_len,
10932          &remote_protocol_packets[PACKET_qXfer_features]);
10933
10934     case TARGET_OBJECT_LIBRARIES:
10935       return remote_read_qxfer
10936         ("libraries", annex, readbuf, offset, len, xfered_len,
10937          &remote_protocol_packets[PACKET_qXfer_libraries]);
10938
10939     case TARGET_OBJECT_LIBRARIES_SVR4:
10940       return remote_read_qxfer
10941         ("libraries-svr4", annex, readbuf, offset, len, xfered_len,
10942          &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
10943
10944     case TARGET_OBJECT_MEMORY_MAP:
10945       gdb_assert (annex == NULL);
10946       return remote_read_qxfer ("memory-map", annex, readbuf, offset, len,
10947                                  xfered_len,
10948                                 &remote_protocol_packets[PACKET_qXfer_memory_map]);
10949
10950     case TARGET_OBJECT_OSDATA:
10951       /* Should only get here if we're connected.  */
10952       gdb_assert (rs->remote_desc);
10953       return remote_read_qxfer
10954         ("osdata", annex, readbuf, offset, len, xfered_len,
10955         &remote_protocol_packets[PACKET_qXfer_osdata]);
10956
10957     case TARGET_OBJECT_THREADS:
10958       gdb_assert (annex == NULL);
10959       return remote_read_qxfer ("threads", annex, readbuf, offset, len,
10960                                 xfered_len,
10961                                 &remote_protocol_packets[PACKET_qXfer_threads]);
10962
10963     case TARGET_OBJECT_TRACEFRAME_INFO:
10964       gdb_assert (annex == NULL);
10965       return remote_read_qxfer
10966         ("traceframe-info", annex, readbuf, offset, len, xfered_len,
10967          &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
10968
10969     case TARGET_OBJECT_FDPIC:
10970       return remote_read_qxfer ("fdpic", annex, readbuf, offset, len,
10971                                 xfered_len,
10972                                 &remote_protocol_packets[PACKET_qXfer_fdpic]);
10973
10974     case TARGET_OBJECT_OPENVMS_UIB:
10975       return remote_read_qxfer ("uib", annex, readbuf, offset, len,
10976                                 xfered_len,
10977                                 &remote_protocol_packets[PACKET_qXfer_uib]);
10978
10979     case TARGET_OBJECT_BTRACE:
10980       return remote_read_qxfer ("btrace", annex, readbuf, offset, len,
10981                                 xfered_len,
10982         &remote_protocol_packets[PACKET_qXfer_btrace]);
10983
10984     case TARGET_OBJECT_BTRACE_CONF:
10985       return remote_read_qxfer ("btrace-conf", annex, readbuf, offset,
10986                                 len, xfered_len,
10987         &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
10988
10989     case TARGET_OBJECT_EXEC_FILE:
10990       return remote_read_qxfer ("exec-file", annex, readbuf, offset,
10991                                 len, xfered_len,
10992         &remote_protocol_packets[PACKET_qXfer_exec_file]);
10993
10994     default:
10995       return TARGET_XFER_E_IO;
10996     }
10997
10998   /* Minimum outbuf size is get_remote_packet_size ().  If LEN is not
10999      large enough let the caller deal with it.  */
11000   if (len < get_remote_packet_size ())
11001     return TARGET_XFER_E_IO;
11002   len = get_remote_packet_size ();
11003
11004   /* Except for querying the minimum buffer size, target must be open.  */
11005   if (!rs->remote_desc)
11006     error (_("remote query is only available after target open"));
11007
11008   gdb_assert (annex != NULL);
11009   gdb_assert (readbuf != NULL);
11010
11011   p2 = rs->buf.data ();
11012   *p2++ = 'q';
11013   *p2++ = query_type;
11014
11015   /* We used one buffer char for the remote protocol q command and
11016      another for the query type.  As the remote protocol encapsulation
11017      uses 4 chars plus one extra in case we are debugging
11018      (remote_debug), we have PBUFZIZ - 7 left to pack the query
11019      string.  */
11020   i = 0;
11021   while (annex[i] && (i < (get_remote_packet_size () - 8)))
11022     {
11023       /* Bad caller may have sent forbidden characters.  */
11024       gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
11025       *p2++ = annex[i];
11026       i++;
11027     }
11028   *p2 = '\0';
11029   gdb_assert (annex[i] == '\0');
11030
11031   i = putpkt (rs->buf);
11032   if (i < 0)
11033     return TARGET_XFER_E_IO;
11034
11035   getpkt (&rs->buf, 0);
11036   strcpy ((char *) readbuf, rs->buf.data ());
11037
11038   *xfered_len = strlen ((char *) readbuf);
11039   return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
11040 }
11041
11042 /* Implementation of to_get_memory_xfer_limit.  */
11043
11044 ULONGEST
11045 remote_target::get_memory_xfer_limit ()
11046 {
11047   return get_memory_write_packet_size ();
11048 }
11049
11050 int
11051 remote_target::search_memory (CORE_ADDR start_addr, ULONGEST search_space_len,
11052                               const gdb_byte *pattern, ULONGEST pattern_len,
11053                               CORE_ADDR *found_addrp)
11054 {
11055   int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
11056   struct remote_state *rs = get_remote_state ();
11057   int max_size = get_memory_write_packet_size ();
11058   struct packet_config *packet =
11059     &remote_protocol_packets[PACKET_qSearch_memory];
11060   /* Number of packet bytes used to encode the pattern;
11061      this could be more than PATTERN_LEN due to escape characters.  */
11062   int escaped_pattern_len;
11063   /* Amount of pattern that was encodable in the packet.  */
11064   int used_pattern_len;
11065   int i;
11066   int found;
11067   ULONGEST found_addr;
11068
11069   /* Don't go to the target if we don't have to.  This is done before
11070      checking packet_config_support to avoid the possibility that a
11071      success for this edge case means the facility works in
11072      general.  */
11073   if (pattern_len > search_space_len)
11074     return 0;
11075   if (pattern_len == 0)
11076     {
11077       *found_addrp = start_addr;
11078       return 1;
11079     }
11080
11081   /* If we already know the packet isn't supported, fall back to the simple
11082      way of searching memory.  */
11083
11084   if (packet_config_support (packet) == PACKET_DISABLE)
11085     {
11086       /* Target doesn't provided special support, fall back and use the
11087          standard support (copy memory and do the search here).  */
11088       return simple_search_memory (this, start_addr, search_space_len,
11089                                    pattern, pattern_len, found_addrp);
11090     }
11091
11092   /* Make sure the remote is pointing at the right process.  */
11093   set_general_process ();
11094
11095   /* Insert header.  */
11096   i = snprintf (rs->buf.data (), max_size, 
11097                 "qSearch:memory:%s;%s;",
11098                 phex_nz (start_addr, addr_size),
11099                 phex_nz (search_space_len, sizeof (search_space_len)));
11100   max_size -= (i + 1);
11101
11102   /* Escape as much data as fits into rs->buf.  */
11103   escaped_pattern_len =
11104     remote_escape_output (pattern, pattern_len, 1,
11105                           (gdb_byte *) rs->buf.data () + i,
11106                           &used_pattern_len, max_size);
11107
11108   /* Bail if the pattern is too large.  */
11109   if (used_pattern_len != pattern_len)
11110     error (_("Pattern is too large to transmit to remote target."));
11111
11112   if (putpkt_binary (rs->buf.data (), i + escaped_pattern_len) < 0
11113       || getpkt_sane (&rs->buf, 0) < 0
11114       || packet_ok (rs->buf, packet) != PACKET_OK)
11115     {
11116       /* The request may not have worked because the command is not
11117          supported.  If so, fall back to the simple way.  */
11118       if (packet_config_support (packet) == PACKET_DISABLE)
11119         {
11120           return simple_search_memory (this, start_addr, search_space_len,
11121                                        pattern, pattern_len, found_addrp);
11122         }
11123       return -1;
11124     }
11125
11126   if (rs->buf[0] == '0')
11127     found = 0;
11128   else if (rs->buf[0] == '1')
11129     {
11130       found = 1;
11131       if (rs->buf[1] != ',')
11132         error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
11133       unpack_varlen_hex (&rs->buf[2], &found_addr);
11134       *found_addrp = found_addr;
11135     }
11136   else
11137     error (_("Unknown qSearch:memory reply: %s"), rs->buf.data ());
11138
11139   return found;
11140 }
11141
11142 void
11143 remote_target::rcmd (const char *command, struct ui_file *outbuf)
11144 {
11145   struct remote_state *rs = get_remote_state ();
11146   char *p = rs->buf.data ();
11147
11148   if (!rs->remote_desc)
11149     error (_("remote rcmd is only available after target open"));
11150
11151   /* Send a NULL command across as an empty command.  */
11152   if (command == NULL)
11153     command = "";
11154
11155   /* The query prefix.  */
11156   strcpy (rs->buf.data (), "qRcmd,");
11157   p = strchr (rs->buf.data (), '\0');
11158
11159   if ((strlen (rs->buf.data ()) + strlen (command) * 2 + 8/*misc*/)
11160       > get_remote_packet_size ())
11161     error (_("\"monitor\" command ``%s'' is too long."), command);
11162
11163   /* Encode the actual command.  */
11164   bin2hex ((const gdb_byte *) command, p, strlen (command));
11165
11166   if (putpkt (rs->buf) < 0)
11167     error (_("Communication problem with target."));
11168
11169   /* get/display the response */
11170   while (1)
11171     {
11172       char *buf;
11173
11174       /* XXX - see also remote_get_noisy_reply().  */
11175       QUIT;                     /* Allow user to bail out with ^C.  */
11176       rs->buf[0] = '\0';
11177       if (getpkt_sane (&rs->buf, 0) == -1)
11178         { 
11179           /* Timeout.  Continue to (try to) read responses.
11180              This is better than stopping with an error, assuming the stub
11181              is still executing the (long) monitor command.
11182              If needed, the user can interrupt gdb using C-c, obtaining
11183              an effect similar to stop on timeout.  */
11184           continue;
11185         }
11186       buf = rs->buf.data ();
11187       if (buf[0] == '\0')
11188         error (_("Target does not support this command."));
11189       if (buf[0] == 'O' && buf[1] != 'K')
11190         {
11191           remote_console_output (buf + 1); /* 'O' message from stub.  */
11192           continue;
11193         }
11194       if (strcmp (buf, "OK") == 0)
11195         break;
11196       if (strlen (buf) == 3 && buf[0] == 'E'
11197           && isdigit (buf[1]) && isdigit (buf[2]))
11198         {
11199           error (_("Protocol error with Rcmd"));
11200         }
11201       for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
11202         {
11203           char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
11204
11205           fputc_unfiltered (c, outbuf);
11206         }
11207       break;
11208     }
11209 }
11210
11211 std::vector<mem_region>
11212 remote_target::memory_map ()
11213 {
11214   std::vector<mem_region> result;
11215   gdb::optional<gdb::char_vector> text
11216     = target_read_stralloc (current_top_target (), TARGET_OBJECT_MEMORY_MAP, NULL);
11217
11218   if (text)
11219     result = parse_memory_map (text->data ());
11220
11221   return result;
11222 }
11223
11224 static void
11225 packet_command (const char *args, int from_tty)
11226 {
11227   remote_target *remote = get_current_remote_target ();
11228
11229   if (remote == nullptr)
11230     error (_("command can only be used with remote target"));
11231
11232   remote->packet_command (args, from_tty);
11233 }
11234
11235 void
11236 remote_target::packet_command (const char *args, int from_tty)
11237 {
11238   if (!args)
11239     error (_("remote-packet command requires packet text as argument"));
11240
11241   puts_filtered ("sending: ");
11242   print_packet (args);
11243   puts_filtered ("\n");
11244   putpkt (args);
11245
11246   remote_state *rs = get_remote_state ();
11247
11248   getpkt (&rs->buf, 0);
11249   puts_filtered ("received: ");
11250   print_packet (rs->buf.data ());
11251   puts_filtered ("\n");
11252 }
11253
11254 #if 0
11255 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
11256
11257 static void display_thread_info (struct gdb_ext_thread_info *info);
11258
11259 static void threadset_test_cmd (char *cmd, int tty);
11260
11261 static void threadalive_test (char *cmd, int tty);
11262
11263 static void threadlist_test_cmd (char *cmd, int tty);
11264
11265 int get_and_display_threadinfo (threadref *ref);
11266
11267 static void threadinfo_test_cmd (char *cmd, int tty);
11268
11269 static int thread_display_step (threadref *ref, void *context);
11270
11271 static void threadlist_update_test_cmd (char *cmd, int tty);
11272
11273 static void init_remote_threadtests (void);
11274
11275 #define SAMPLE_THREAD  0x05060708       /* Truncated 64 bit threadid.  */
11276
11277 static void
11278 threadset_test_cmd (const char *cmd, int tty)
11279 {
11280   int sample_thread = SAMPLE_THREAD;
11281
11282   printf_filtered (_("Remote threadset test\n"));
11283   set_general_thread (sample_thread);
11284 }
11285
11286
11287 static void
11288 threadalive_test (const char *cmd, int tty)
11289 {
11290   int sample_thread = SAMPLE_THREAD;
11291   int pid = inferior_ptid.pid ();
11292   ptid_t ptid = ptid_t (pid, sample_thread, 0);
11293
11294   if (remote_thread_alive (ptid))
11295     printf_filtered ("PASS: Thread alive test\n");
11296   else
11297     printf_filtered ("FAIL: Thread alive test\n");
11298 }
11299
11300 void output_threadid (char *title, threadref *ref);
11301
11302 void
11303 output_threadid (char *title, threadref *ref)
11304 {
11305   char hexid[20];
11306
11307   pack_threadid (&hexid[0], ref);       /* Convert threead id into hex.  */
11308   hexid[16] = 0;
11309   printf_filtered ("%s  %s\n", title, (&hexid[0]));
11310 }
11311
11312 static void
11313 threadlist_test_cmd (const char *cmd, int tty)
11314 {
11315   int startflag = 1;
11316   threadref nextthread;
11317   int done, result_count;
11318   threadref threadlist[3];
11319
11320   printf_filtered ("Remote Threadlist test\n");
11321   if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
11322                               &result_count, &threadlist[0]))
11323     printf_filtered ("FAIL: threadlist test\n");
11324   else
11325     {
11326       threadref *scan = threadlist;
11327       threadref *limit = scan + result_count;
11328
11329       while (scan < limit)
11330         output_threadid (" thread ", scan++);
11331     }
11332 }
11333
11334 void
11335 display_thread_info (struct gdb_ext_thread_info *info)
11336 {
11337   output_threadid ("Threadid: ", &info->threadid);
11338   printf_filtered ("Name: %s\n ", info->shortname);
11339   printf_filtered ("State: %s\n", info->display);
11340   printf_filtered ("other: %s\n\n", info->more_display);
11341 }
11342
11343 int
11344 get_and_display_threadinfo (threadref *ref)
11345 {
11346   int result;
11347   int set;
11348   struct gdb_ext_thread_info threadinfo;
11349
11350   set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
11351     | TAG_MOREDISPLAY | TAG_DISPLAY;
11352   if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
11353     display_thread_info (&threadinfo);
11354   return result;
11355 }
11356
11357 static void
11358 threadinfo_test_cmd (const char *cmd, int tty)
11359 {
11360   int athread = SAMPLE_THREAD;
11361   threadref thread;
11362   int set;
11363
11364   int_to_threadref (&thread, athread);
11365   printf_filtered ("Remote Threadinfo test\n");
11366   if (!get_and_display_threadinfo (&thread))
11367     printf_filtered ("FAIL cannot get thread info\n");
11368 }
11369
11370 static int
11371 thread_display_step (threadref *ref, void *context)
11372 {
11373   /* output_threadid(" threadstep ",ref); *//* simple test */
11374   return get_and_display_threadinfo (ref);
11375 }
11376
11377 static void
11378 threadlist_update_test_cmd (const char *cmd, int tty)
11379 {
11380   printf_filtered ("Remote Threadlist update test\n");
11381   remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
11382 }
11383
11384 static void
11385 init_remote_threadtests (void)
11386 {
11387   add_com ("tlist", class_obscure, threadlist_test_cmd,
11388            _("Fetch and print the remote list of "
11389              "thread identifiers, one pkt only."));
11390   add_com ("tinfo", class_obscure, threadinfo_test_cmd,
11391            _("Fetch and display info about one thread."));
11392   add_com ("tset", class_obscure, threadset_test_cmd,
11393            _("Test setting to a different thread."));
11394   add_com ("tupd", class_obscure, threadlist_update_test_cmd,
11395            _("Iterate through updating all remote thread info."));
11396   add_com ("talive", class_obscure, threadalive_test,
11397            _("Remote thread alive test."));
11398 }
11399
11400 #endif /* 0 */
11401
11402 /* Convert a thread ID to a string.  */
11403
11404 std::string
11405 remote_target::pid_to_str (ptid_t ptid)
11406 {
11407   struct remote_state *rs = get_remote_state ();
11408
11409   if (ptid == null_ptid)
11410     return normal_pid_to_str (ptid);
11411   else if (ptid.is_pid ())
11412     {
11413       /* Printing an inferior target id.  */
11414
11415       /* When multi-process extensions are off, there's no way in the
11416          remote protocol to know the remote process id, if there's any
11417          at all.  There's one exception --- when we're connected with
11418          target extended-remote, and we manually attached to a process
11419          with "attach PID".  We don't record anywhere a flag that
11420          allows us to distinguish that case from the case of
11421          connecting with extended-remote and the stub already being
11422          attached to a process, and reporting yes to qAttached, hence
11423          no smart special casing here.  */
11424       if (!remote_multi_process_p (rs))
11425         return "Remote target";
11426
11427       return normal_pid_to_str (ptid);
11428     }
11429   else
11430     {
11431       if (magic_null_ptid == ptid)
11432         return "Thread <main>";
11433       else if (remote_multi_process_p (rs))
11434         if (ptid.lwp () == 0)
11435           return normal_pid_to_str (ptid);
11436         else
11437           return string_printf ("Thread %d.%ld",
11438                                 ptid.pid (), ptid.lwp ());
11439       else
11440         return string_printf ("Thread %ld", ptid.lwp ());
11441     }
11442 }
11443
11444 /* Get the address of the thread local variable in OBJFILE which is
11445    stored at OFFSET within the thread local storage for thread PTID.  */
11446
11447 CORE_ADDR
11448 remote_target::get_thread_local_address (ptid_t ptid, CORE_ADDR lm,
11449                                          CORE_ADDR offset)
11450 {
11451   if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
11452     {
11453       struct remote_state *rs = get_remote_state ();
11454       char *p = rs->buf.data ();
11455       char *endp = p + get_remote_packet_size ();
11456       enum packet_result result;
11457
11458       strcpy (p, "qGetTLSAddr:");
11459       p += strlen (p);
11460       p = write_ptid (p, endp, ptid);
11461       *p++ = ',';
11462       p += hexnumstr (p, offset);
11463       *p++ = ',';
11464       p += hexnumstr (p, lm);
11465       *p++ = '\0';
11466
11467       putpkt (rs->buf);
11468       getpkt (&rs->buf, 0);
11469       result = packet_ok (rs->buf,
11470                           &remote_protocol_packets[PACKET_qGetTLSAddr]);
11471       if (result == PACKET_OK)
11472         {
11473           ULONGEST addr;
11474
11475           unpack_varlen_hex (rs->buf.data (), &addr);
11476           return addr;
11477         }
11478       else if (result == PACKET_UNKNOWN)
11479         throw_error (TLS_GENERIC_ERROR,
11480                      _("Remote target doesn't support qGetTLSAddr packet"));
11481       else
11482         throw_error (TLS_GENERIC_ERROR,
11483                      _("Remote target failed to process qGetTLSAddr request"));
11484     }
11485   else
11486     throw_error (TLS_GENERIC_ERROR,
11487                  _("TLS not supported or disabled on this target"));
11488   /* Not reached.  */
11489   return 0;
11490 }
11491
11492 /* Provide thread local base, i.e. Thread Information Block address.
11493    Returns 1 if ptid is found and thread_local_base is non zero.  */
11494
11495 bool
11496 remote_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
11497 {
11498   if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
11499     {
11500       struct remote_state *rs = get_remote_state ();
11501       char *p = rs->buf.data ();
11502       char *endp = p + get_remote_packet_size ();
11503       enum packet_result result;
11504
11505       strcpy (p, "qGetTIBAddr:");
11506       p += strlen (p);
11507       p = write_ptid (p, endp, ptid);
11508       *p++ = '\0';
11509
11510       putpkt (rs->buf);
11511       getpkt (&rs->buf, 0);
11512       result = packet_ok (rs->buf,
11513                           &remote_protocol_packets[PACKET_qGetTIBAddr]);
11514       if (result == PACKET_OK)
11515         {
11516           ULONGEST val;
11517           unpack_varlen_hex (rs->buf.data (), &val);
11518           if (addr)
11519             *addr = (CORE_ADDR) val;
11520           return true;
11521         }
11522       else if (result == PACKET_UNKNOWN)
11523         error (_("Remote target doesn't support qGetTIBAddr packet"));
11524       else
11525         error (_("Remote target failed to process qGetTIBAddr request"));
11526     }
11527   else
11528     error (_("qGetTIBAddr not supported or disabled on this target"));
11529   /* Not reached.  */
11530   return false;
11531 }
11532
11533 /* Support for inferring a target description based on the current
11534    architecture and the size of a 'g' packet.  While the 'g' packet
11535    can have any size (since optional registers can be left off the
11536    end), some sizes are easily recognizable given knowledge of the
11537    approximate architecture.  */
11538
11539 struct remote_g_packet_guess
11540 {
11541   remote_g_packet_guess (int bytes_, const struct target_desc *tdesc_)
11542     : bytes (bytes_),
11543       tdesc (tdesc_)
11544   {
11545   }
11546
11547   int bytes;
11548   const struct target_desc *tdesc;
11549 };
11550
11551 struct remote_g_packet_data : public allocate_on_obstack
11552 {
11553   std::vector<remote_g_packet_guess> guesses;
11554 };
11555
11556 static struct gdbarch_data *remote_g_packet_data_handle;
11557
11558 static void *
11559 remote_g_packet_data_init (struct obstack *obstack)
11560 {
11561   return new (obstack) remote_g_packet_data;
11562 }
11563
11564 void
11565 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
11566                                 const struct target_desc *tdesc)
11567 {
11568   struct remote_g_packet_data *data
11569     = ((struct remote_g_packet_data *)
11570        gdbarch_data (gdbarch, remote_g_packet_data_handle));
11571
11572   gdb_assert (tdesc != NULL);
11573
11574   for (const remote_g_packet_guess &guess : data->guesses)
11575     if (guess.bytes == bytes)
11576       internal_error (__FILE__, __LINE__,
11577                       _("Duplicate g packet description added for size %d"),
11578                       bytes);
11579
11580   data->guesses.emplace_back (bytes, tdesc);
11581 }
11582
11583 /* Return true if remote_read_description would do anything on this target
11584    and architecture, false otherwise.  */
11585
11586 static bool
11587 remote_read_description_p (struct target_ops *target)
11588 {
11589   struct remote_g_packet_data *data
11590     = ((struct remote_g_packet_data *)
11591        gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11592
11593   return !data->guesses.empty ();
11594 }
11595
11596 const struct target_desc *
11597 remote_target::read_description ()
11598 {
11599   struct remote_g_packet_data *data
11600     = ((struct remote_g_packet_data *)
11601        gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11602
11603   /* Do not try this during initial connection, when we do not know
11604      whether there is a running but stopped thread.  */
11605   if (!target_has_execution || inferior_ptid == null_ptid)
11606     return beneath ()->read_description ();
11607
11608   if (!data->guesses.empty ())
11609     {
11610       int bytes = send_g_packet ();
11611
11612       for (const remote_g_packet_guess &guess : data->guesses)
11613         if (guess.bytes == bytes)
11614           return guess.tdesc;
11615
11616       /* We discard the g packet.  A minor optimization would be to
11617          hold on to it, and fill the register cache once we have selected
11618          an architecture, but it's too tricky to do safely.  */
11619     }
11620
11621   return beneath ()->read_description ();
11622 }
11623
11624 /* Remote file transfer support.  This is host-initiated I/O, not
11625    target-initiated; for target-initiated, see remote-fileio.c.  */
11626
11627 /* If *LEFT is at least the length of STRING, copy STRING to
11628    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11629    decrease *LEFT.  Otherwise raise an error.  */
11630
11631 static void
11632 remote_buffer_add_string (char **buffer, int *left, const char *string)
11633 {
11634   int len = strlen (string);
11635
11636   if (len > *left)
11637     error (_("Packet too long for target."));
11638
11639   memcpy (*buffer, string, len);
11640   *buffer += len;
11641   *left -= len;
11642
11643   /* NUL-terminate the buffer as a convenience, if there is
11644      room.  */
11645   if (*left)
11646     **buffer = '\0';
11647 }
11648
11649 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11650    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11651    decrease *LEFT.  Otherwise raise an error.  */
11652
11653 static void
11654 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
11655                          int len)
11656 {
11657   if (2 * len > *left)
11658     error (_("Packet too long for target."));
11659
11660   bin2hex (bytes, *buffer, len);
11661   *buffer += 2 * len;
11662   *left -= 2 * len;
11663
11664   /* NUL-terminate the buffer as a convenience, if there is
11665      room.  */
11666   if (*left)
11667     **buffer = '\0';
11668 }
11669
11670 /* If *LEFT is large enough, convert VALUE to hex and add it to
11671    *BUFFER, update *BUFFER to point to the new end of the buffer, and
11672    decrease *LEFT.  Otherwise raise an error.  */
11673
11674 static void
11675 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
11676 {
11677   int len = hexnumlen (value);
11678
11679   if (len > *left)
11680     error (_("Packet too long for target."));
11681
11682   hexnumstr (*buffer, value);
11683   *buffer += len;
11684   *left -= len;
11685
11686   /* NUL-terminate the buffer as a convenience, if there is
11687      room.  */
11688   if (*left)
11689     **buffer = '\0';
11690 }
11691
11692 /* Parse an I/O result packet from BUFFER.  Set RETCODE to the return
11693    value, *REMOTE_ERRNO to the remote error number or zero if none
11694    was included, and *ATTACHMENT to point to the start of the annex
11695    if any.  The length of the packet isn't needed here; there may
11696    be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11697
11698    Return 0 if the packet could be parsed, -1 if it could not.  If
11699    -1 is returned, the other variables may not be initialized.  */
11700
11701 static int
11702 remote_hostio_parse_result (char *buffer, int *retcode,
11703                             int *remote_errno, char **attachment)
11704 {
11705   char *p, *p2;
11706
11707   *remote_errno = 0;
11708   *attachment = NULL;
11709
11710   if (buffer[0] != 'F')
11711     return -1;
11712
11713   errno = 0;
11714   *retcode = strtol (&buffer[1], &p, 16);
11715   if (errno != 0 || p == &buffer[1])
11716     return -1;
11717
11718   /* Check for ",errno".  */
11719   if (*p == ',')
11720     {
11721       errno = 0;
11722       *remote_errno = strtol (p + 1, &p2, 16);
11723       if (errno != 0 || p + 1 == p2)
11724         return -1;
11725       p = p2;
11726     }
11727
11728   /* Check for ";attachment".  If there is no attachment, the
11729      packet should end here.  */
11730   if (*p == ';')
11731     {
11732       *attachment = p + 1;
11733       return 0;
11734     }
11735   else if (*p == '\0')
11736     return 0;
11737   else
11738     return -1;
11739 }
11740
11741 /* Send a prepared I/O packet to the target and read its response.
11742    The prepared packet is in the global RS->BUF before this function
11743    is called, and the answer is there when we return.
11744
11745    COMMAND_BYTES is the length of the request to send, which may include
11746    binary data.  WHICH_PACKET is the packet configuration to check
11747    before attempting a packet.  If an error occurs, *REMOTE_ERRNO
11748    is set to the error number and -1 is returned.  Otherwise the value
11749    returned by the function is returned.
11750
11751    ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11752    attachment is expected; an error will be reported if there's a
11753    mismatch.  If one is found, *ATTACHMENT will be set to point into
11754    the packet buffer and *ATTACHMENT_LEN will be set to the
11755    attachment's length.  */
11756
11757 int
11758 remote_target::remote_hostio_send_command (int command_bytes, int which_packet,
11759                                            int *remote_errno, char **attachment,
11760                                            int *attachment_len)
11761 {
11762   struct remote_state *rs = get_remote_state ();
11763   int ret, bytes_read;
11764   char *attachment_tmp;
11765
11766   if (packet_support (which_packet) == PACKET_DISABLE)
11767     {
11768       *remote_errno = FILEIO_ENOSYS;
11769       return -1;
11770     }
11771
11772   putpkt_binary (rs->buf.data (), command_bytes);
11773   bytes_read = getpkt_sane (&rs->buf, 0);
11774
11775   /* If it timed out, something is wrong.  Don't try to parse the
11776      buffer.  */
11777   if (bytes_read < 0)
11778     {
11779       *remote_errno = FILEIO_EINVAL;
11780       return -1;
11781     }
11782
11783   switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
11784     {
11785     case PACKET_ERROR:
11786       *remote_errno = FILEIO_EINVAL;
11787       return -1;
11788     case PACKET_UNKNOWN:
11789       *remote_errno = FILEIO_ENOSYS;
11790       return -1;
11791     case PACKET_OK:
11792       break;
11793     }
11794
11795   if (remote_hostio_parse_result (rs->buf.data (), &ret, remote_errno,
11796                                   &attachment_tmp))
11797     {
11798       *remote_errno = FILEIO_EINVAL;
11799       return -1;
11800     }
11801
11802   /* Make sure we saw an attachment if and only if we expected one.  */
11803   if ((attachment_tmp == NULL && attachment != NULL)
11804       || (attachment_tmp != NULL && attachment == NULL))
11805     {
11806       *remote_errno = FILEIO_EINVAL;
11807       return -1;
11808     }
11809
11810   /* If an attachment was found, it must point into the packet buffer;
11811      work out how many bytes there were.  */
11812   if (attachment_tmp != NULL)
11813     {
11814       *attachment = attachment_tmp;
11815       *attachment_len = bytes_read - (*attachment - rs->buf.data ());
11816     }
11817
11818   return ret;
11819 }
11820
11821 /* See declaration.h.  */
11822
11823 void
11824 readahead_cache::invalidate ()
11825 {
11826   this->fd = -1;
11827 }
11828
11829 /* See declaration.h.  */
11830
11831 void
11832 readahead_cache::invalidate_fd (int fd)
11833 {
11834   if (this->fd == fd)
11835     this->fd = -1;
11836 }
11837
11838 /* Set the filesystem remote_hostio functions that take FILENAME
11839    arguments will use.  Return 0 on success, or -1 if an error
11840    occurs (and set *REMOTE_ERRNO).  */
11841
11842 int
11843 remote_target::remote_hostio_set_filesystem (struct inferior *inf,
11844                                              int *remote_errno)
11845 {
11846   struct remote_state *rs = get_remote_state ();
11847   int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
11848   char *p = rs->buf.data ();
11849   int left = get_remote_packet_size () - 1;
11850   char arg[9];
11851   int ret;
11852
11853   if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11854     return 0;
11855
11856   if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
11857     return 0;
11858
11859   remote_buffer_add_string (&p, &left, "vFile:setfs:");
11860
11861   xsnprintf (arg, sizeof (arg), "%x", required_pid);
11862   remote_buffer_add_string (&p, &left, arg);
11863
11864   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_setfs,
11865                                     remote_errno, NULL, NULL);
11866
11867   if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11868     return 0;
11869
11870   if (ret == 0)
11871     rs->fs_pid = required_pid;
11872
11873   return ret;
11874 }
11875
11876 /* Implementation of to_fileio_open.  */
11877
11878 int
11879 remote_target::remote_hostio_open (inferior *inf, const char *filename,
11880                                    int flags, int mode, int warn_if_slow,
11881                                    int *remote_errno)
11882 {
11883   struct remote_state *rs = get_remote_state ();
11884   char *p = rs->buf.data ();
11885   int left = get_remote_packet_size () - 1;
11886
11887   if (warn_if_slow)
11888     {
11889       static int warning_issued = 0;
11890
11891       printf_unfiltered (_("Reading %s from remote target...\n"),
11892                          filename);
11893
11894       if (!warning_issued)
11895         {
11896           warning (_("File transfers from remote targets can be slow."
11897                      " Use \"set sysroot\" to access files locally"
11898                      " instead."));
11899           warning_issued = 1;
11900         }
11901     }
11902
11903   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11904     return -1;
11905
11906   remote_buffer_add_string (&p, &left, "vFile:open:");
11907
11908   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11909                            strlen (filename));
11910   remote_buffer_add_string (&p, &left, ",");
11911
11912   remote_buffer_add_int (&p, &left, flags);
11913   remote_buffer_add_string (&p, &left, ",");
11914
11915   remote_buffer_add_int (&p, &left, mode);
11916
11917   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_open,
11918                                      remote_errno, NULL, NULL);
11919 }
11920
11921 int
11922 remote_target::fileio_open (struct inferior *inf, const char *filename,
11923                             int flags, int mode, int warn_if_slow,
11924                             int *remote_errno)
11925 {
11926   return remote_hostio_open (inf, filename, flags, mode, warn_if_slow,
11927                              remote_errno);
11928 }
11929
11930 /* Implementation of to_fileio_pwrite.  */
11931
11932 int
11933 remote_target::remote_hostio_pwrite (int fd, const gdb_byte *write_buf, int len,
11934                                      ULONGEST offset, int *remote_errno)
11935 {
11936   struct remote_state *rs = get_remote_state ();
11937   char *p = rs->buf.data ();
11938   int left = get_remote_packet_size ();
11939   int out_len;
11940
11941   rs->readahead_cache.invalidate_fd (fd);
11942
11943   remote_buffer_add_string (&p, &left, "vFile:pwrite:");
11944
11945   remote_buffer_add_int (&p, &left, fd);
11946   remote_buffer_add_string (&p, &left, ",");
11947
11948   remote_buffer_add_int (&p, &left, offset);
11949   remote_buffer_add_string (&p, &left, ",");
11950
11951   p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
11952                              (get_remote_packet_size ()
11953                               - (p - rs->buf.data ())));
11954
11955   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pwrite,
11956                                      remote_errno, NULL, NULL);
11957 }
11958
11959 int
11960 remote_target::fileio_pwrite (int fd, const gdb_byte *write_buf, int len,
11961                               ULONGEST offset, int *remote_errno)
11962 {
11963   return remote_hostio_pwrite (fd, write_buf, len, offset, remote_errno);
11964 }
11965
11966 /* Helper for the implementation of to_fileio_pread.  Read the file
11967    from the remote side with vFile:pread.  */
11968
11969 int
11970 remote_target::remote_hostio_pread_vFile (int fd, gdb_byte *read_buf, int len,
11971                                           ULONGEST offset, int *remote_errno)
11972 {
11973   struct remote_state *rs = get_remote_state ();
11974   char *p = rs->buf.data ();
11975   char *attachment;
11976   int left = get_remote_packet_size ();
11977   int ret, attachment_len;
11978   int read_len;
11979
11980   remote_buffer_add_string (&p, &left, "vFile:pread:");
11981
11982   remote_buffer_add_int (&p, &left, fd);
11983   remote_buffer_add_string (&p, &left, ",");
11984
11985   remote_buffer_add_int (&p, &left, len);
11986   remote_buffer_add_string (&p, &left, ",");
11987
11988   remote_buffer_add_int (&p, &left, offset);
11989
11990   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_pread,
11991                                     remote_errno, &attachment,
11992                                     &attachment_len);
11993
11994   if (ret < 0)
11995     return ret;
11996
11997   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
11998                                     read_buf, len);
11999   if (read_len != ret)
12000     error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
12001
12002   return ret;
12003 }
12004
12005 /* See declaration.h.  */
12006
12007 int
12008 readahead_cache::pread (int fd, gdb_byte *read_buf, size_t len,
12009                         ULONGEST offset)
12010 {
12011   if (this->fd == fd
12012       && this->offset <= offset
12013       && offset < this->offset + this->bufsize)
12014     {
12015       ULONGEST max = this->offset + this->bufsize;
12016
12017       if (offset + len > max)
12018         len = max - offset;
12019
12020       memcpy (read_buf, this->buf + offset - this->offset, len);
12021       return len;
12022     }
12023
12024   return 0;
12025 }
12026
12027 /* Implementation of to_fileio_pread.  */
12028
12029 int
12030 remote_target::remote_hostio_pread (int fd, gdb_byte *read_buf, int len,
12031                                     ULONGEST offset, int *remote_errno)
12032 {
12033   int ret;
12034   struct remote_state *rs = get_remote_state ();
12035   readahead_cache *cache = &rs->readahead_cache;
12036
12037   ret = cache->pread (fd, read_buf, len, offset);
12038   if (ret > 0)
12039     {
12040       cache->hit_count++;
12041
12042       if (remote_debug)
12043         fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
12044                             pulongest (cache->hit_count));
12045       return ret;
12046     }
12047
12048   cache->miss_count++;
12049   if (remote_debug)
12050     fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
12051                         pulongest (cache->miss_count));
12052
12053   cache->fd = fd;
12054   cache->offset = offset;
12055   cache->bufsize = get_remote_packet_size ();
12056   cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
12057
12058   ret = remote_hostio_pread_vFile (cache->fd, cache->buf, cache->bufsize,
12059                                    cache->offset, remote_errno);
12060   if (ret <= 0)
12061     {
12062       cache->invalidate_fd (fd);
12063       return ret;
12064     }
12065
12066   cache->bufsize = ret;
12067   return cache->pread (fd, read_buf, len, offset);
12068 }
12069
12070 int
12071 remote_target::fileio_pread (int fd, gdb_byte *read_buf, int len,
12072                              ULONGEST offset, int *remote_errno)
12073 {
12074   return remote_hostio_pread (fd, read_buf, len, offset, remote_errno);
12075 }
12076
12077 /* Implementation of to_fileio_close.  */
12078
12079 int
12080 remote_target::remote_hostio_close (int fd, int *remote_errno)
12081 {
12082   struct remote_state *rs = get_remote_state ();
12083   char *p = rs->buf.data ();
12084   int left = get_remote_packet_size () - 1;
12085
12086   rs->readahead_cache.invalidate_fd (fd);
12087
12088   remote_buffer_add_string (&p, &left, "vFile:close:");
12089
12090   remote_buffer_add_int (&p, &left, fd);
12091
12092   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_close,
12093                                      remote_errno, NULL, NULL);
12094 }
12095
12096 int
12097 remote_target::fileio_close (int fd, int *remote_errno)
12098 {
12099   return remote_hostio_close (fd, remote_errno);
12100 }
12101
12102 /* Implementation of to_fileio_unlink.  */
12103
12104 int
12105 remote_target::remote_hostio_unlink (inferior *inf, const char *filename,
12106                                      int *remote_errno)
12107 {
12108   struct remote_state *rs = get_remote_state ();
12109   char *p = rs->buf.data ();
12110   int left = get_remote_packet_size () - 1;
12111
12112   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12113     return -1;
12114
12115   remote_buffer_add_string (&p, &left, "vFile:unlink:");
12116
12117   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12118                            strlen (filename));
12119
12120   return remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_unlink,
12121                                      remote_errno, NULL, NULL);
12122 }
12123
12124 int
12125 remote_target::fileio_unlink (struct inferior *inf, const char *filename,
12126                               int *remote_errno)
12127 {
12128   return remote_hostio_unlink (inf, filename, remote_errno);
12129 }
12130
12131 /* Implementation of to_fileio_readlink.  */
12132
12133 gdb::optional<std::string>
12134 remote_target::fileio_readlink (struct inferior *inf, const char *filename,
12135                                 int *remote_errno)
12136 {
12137   struct remote_state *rs = get_remote_state ();
12138   char *p = rs->buf.data ();
12139   char *attachment;
12140   int left = get_remote_packet_size ();
12141   int len, attachment_len;
12142   int read_len;
12143
12144   if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
12145     return {};
12146
12147   remote_buffer_add_string (&p, &left, "vFile:readlink:");
12148
12149   remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
12150                            strlen (filename));
12151
12152   len = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_readlink,
12153                                     remote_errno, &attachment,
12154                                     &attachment_len);
12155
12156   if (len < 0)
12157     return {};
12158
12159   std::string ret (len, '\0');
12160
12161   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12162                                     (gdb_byte *) &ret[0], len);
12163   if (read_len != len)
12164     error (_("Readlink returned %d, but %d bytes."), len, read_len);
12165
12166   return ret;
12167 }
12168
12169 /* Implementation of to_fileio_fstat.  */
12170
12171 int
12172 remote_target::fileio_fstat (int fd, struct stat *st, int *remote_errno)
12173 {
12174   struct remote_state *rs = get_remote_state ();
12175   char *p = rs->buf.data ();
12176   int left = get_remote_packet_size ();
12177   int attachment_len, ret;
12178   char *attachment;
12179   struct fio_stat fst;
12180   int read_len;
12181
12182   remote_buffer_add_string (&p, &left, "vFile:fstat:");
12183
12184   remote_buffer_add_int (&p, &left, fd);
12185
12186   ret = remote_hostio_send_command (p - rs->buf.data (), PACKET_vFile_fstat,
12187                                     remote_errno, &attachment,
12188                                     &attachment_len);
12189   if (ret < 0)
12190     {
12191       if (*remote_errno != FILEIO_ENOSYS)
12192         return ret;
12193
12194       /* Strictly we should return -1, ENOSYS here, but when
12195          "set sysroot remote:" was implemented in August 2008
12196          BFD's need for a stat function was sidestepped with
12197          this hack.  This was not remedied until March 2015
12198          so we retain the previous behavior to avoid breaking
12199          compatibility.
12200
12201          Note that the memset is a March 2015 addition; older
12202          GDBs set st_size *and nothing else* so the structure
12203          would have garbage in all other fields.  This might
12204          break something but retaining the previous behavior
12205          here would be just too wrong.  */
12206
12207       memset (st, 0, sizeof (struct stat));
12208       st->st_size = INT_MAX;
12209       return 0;
12210     }
12211
12212   read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
12213                                     (gdb_byte *) &fst, sizeof (fst));
12214
12215   if (read_len != ret)
12216     error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len);
12217
12218   if (read_len != sizeof (fst))
12219     error (_("vFile:fstat returned %d bytes, but expecting %d."),
12220            read_len, (int) sizeof (fst));
12221
12222   remote_fileio_to_host_stat (&fst, st);
12223
12224   return 0;
12225 }
12226
12227 /* Implementation of to_filesystem_is_local.  */
12228
12229 bool
12230 remote_target::filesystem_is_local ()
12231 {
12232   /* Valgrind GDB presents itself as a remote target but works
12233      on the local filesystem: it does not implement remote get
12234      and users are not expected to set a sysroot.  To handle
12235      this case we treat the remote filesystem as local if the
12236      sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
12237      does not support vFile:open.  */
12238   if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
12239     {
12240       enum packet_support ps = packet_support (PACKET_vFile_open);
12241
12242       if (ps == PACKET_SUPPORT_UNKNOWN)
12243         {
12244           int fd, remote_errno;
12245
12246           /* Try opening a file to probe support.  The supplied
12247              filename is irrelevant, we only care about whether
12248              the stub recognizes the packet or not.  */
12249           fd = remote_hostio_open (NULL, "just probing",
12250                                    FILEIO_O_RDONLY, 0700, 0,
12251                                    &remote_errno);
12252
12253           if (fd >= 0)
12254             remote_hostio_close (fd, &remote_errno);
12255
12256           ps = packet_support (PACKET_vFile_open);
12257         }
12258
12259       if (ps == PACKET_DISABLE)
12260         {
12261           static int warning_issued = 0;
12262
12263           if (!warning_issued)
12264             {
12265               warning (_("remote target does not support file"
12266                          " transfer, attempting to access files"
12267                          " from local filesystem."));
12268               warning_issued = 1;
12269             }
12270
12271           return true;
12272         }
12273     }
12274
12275   return false;
12276 }
12277
12278 static int
12279 remote_fileio_errno_to_host (int errnum)
12280 {
12281   switch (errnum)
12282     {
12283       case FILEIO_EPERM:
12284         return EPERM;
12285       case FILEIO_ENOENT:
12286         return ENOENT;
12287       case FILEIO_EINTR:
12288         return EINTR;
12289       case FILEIO_EIO:
12290         return EIO;
12291       case FILEIO_EBADF:
12292         return EBADF;
12293       case FILEIO_EACCES:
12294         return EACCES;
12295       case FILEIO_EFAULT:
12296         return EFAULT;
12297       case FILEIO_EBUSY:
12298         return EBUSY;
12299       case FILEIO_EEXIST:
12300         return EEXIST;
12301       case FILEIO_ENODEV:
12302         return ENODEV;
12303       case FILEIO_ENOTDIR:
12304         return ENOTDIR;
12305       case FILEIO_EISDIR:
12306         return EISDIR;
12307       case FILEIO_EINVAL:
12308         return EINVAL;
12309       case FILEIO_ENFILE:
12310         return ENFILE;
12311       case FILEIO_EMFILE:
12312         return EMFILE;
12313       case FILEIO_EFBIG:
12314         return EFBIG;
12315       case FILEIO_ENOSPC:
12316         return ENOSPC;
12317       case FILEIO_ESPIPE:
12318         return ESPIPE;
12319       case FILEIO_EROFS:
12320         return EROFS;
12321       case FILEIO_ENOSYS:
12322         return ENOSYS;
12323       case FILEIO_ENAMETOOLONG:
12324         return ENAMETOOLONG;
12325     }
12326   return -1;
12327 }
12328
12329 static char *
12330 remote_hostio_error (int errnum)
12331 {
12332   int host_error = remote_fileio_errno_to_host (errnum);
12333
12334   if (host_error == -1)
12335     error (_("Unknown remote I/O error %d"), errnum);
12336   else
12337     error (_("Remote I/O error: %s"), safe_strerror (host_error));
12338 }
12339
12340 /* A RAII wrapper around a remote file descriptor.  */
12341
12342 class scoped_remote_fd
12343 {
12344 public:
12345   scoped_remote_fd (remote_target *remote, int fd)
12346     : m_remote (remote), m_fd (fd)
12347   {
12348   }
12349
12350   ~scoped_remote_fd ()
12351   {
12352     if (m_fd != -1)
12353       {
12354         try
12355           {
12356             int remote_errno;
12357             m_remote->remote_hostio_close (m_fd, &remote_errno);
12358           }
12359         catch (...)
12360           {
12361             /* Swallow exception before it escapes the dtor.  If
12362                something goes wrong, likely the connection is gone,
12363                and there's nothing else that can be done.  */
12364           }
12365       }
12366   }
12367
12368   DISABLE_COPY_AND_ASSIGN (scoped_remote_fd);
12369
12370   /* Release ownership of the file descriptor, and return it.  */
12371   ATTRIBUTE_UNUSED_RESULT int release () noexcept
12372   {
12373     int fd = m_fd;
12374     m_fd = -1;
12375     return fd;
12376   }
12377
12378   /* Return the owned file descriptor.  */
12379   int get () const noexcept
12380   {
12381     return m_fd;
12382   }
12383
12384 private:
12385   /* The remote target.  */
12386   remote_target *m_remote;
12387
12388   /* The owned remote I/O file descriptor.  */
12389   int m_fd;
12390 };
12391
12392 void
12393 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
12394 {
12395   remote_target *remote = get_current_remote_target ();
12396
12397   if (remote == nullptr)
12398     error (_("command can only be used with remote target"));
12399
12400   remote->remote_file_put (local_file, remote_file, from_tty);
12401 }
12402
12403 void
12404 remote_target::remote_file_put (const char *local_file, const char *remote_file,
12405                                 int from_tty)
12406 {
12407   int retcode, remote_errno, bytes, io_size;
12408   int bytes_in_buffer;
12409   int saw_eof;
12410   ULONGEST offset;
12411
12412   gdb_file_up file = gdb_fopen_cloexec (local_file, "rb");
12413   if (file == NULL)
12414     perror_with_name (local_file);
12415
12416   scoped_remote_fd fd
12417     (this, remote_hostio_open (NULL,
12418                                remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
12419                                              | FILEIO_O_TRUNC),
12420                                0700, 0, &remote_errno));
12421   if (fd.get () == -1)
12422     remote_hostio_error (remote_errno);
12423
12424   /* Send up to this many bytes at once.  They won't all fit in the
12425      remote packet limit, so we'll transfer slightly fewer.  */
12426   io_size = get_remote_packet_size ();
12427   gdb::byte_vector buffer (io_size);
12428
12429   bytes_in_buffer = 0;
12430   saw_eof = 0;
12431   offset = 0;
12432   while (bytes_in_buffer || !saw_eof)
12433     {
12434       if (!saw_eof)
12435         {
12436           bytes = fread (buffer.data () + bytes_in_buffer, 1,
12437                          io_size - bytes_in_buffer,
12438                          file.get ());
12439           if (bytes == 0)
12440             {
12441               if (ferror (file.get ()))
12442                 error (_("Error reading %s."), local_file);
12443               else
12444                 {
12445                   /* EOF.  Unless there is something still in the
12446                      buffer from the last iteration, we are done.  */
12447                   saw_eof = 1;
12448                   if (bytes_in_buffer == 0)
12449                     break;
12450                 }
12451             }
12452         }
12453       else
12454         bytes = 0;
12455
12456       bytes += bytes_in_buffer;
12457       bytes_in_buffer = 0;
12458
12459       retcode = remote_hostio_pwrite (fd.get (), buffer.data (), bytes,
12460                                       offset, &remote_errno);
12461
12462       if (retcode < 0)
12463         remote_hostio_error (remote_errno);
12464       else if (retcode == 0)
12465         error (_("Remote write of %d bytes returned 0!"), bytes);
12466       else if (retcode < bytes)
12467         {
12468           /* Short write.  Save the rest of the read data for the next
12469              write.  */
12470           bytes_in_buffer = bytes - retcode;
12471           memmove (buffer.data (), buffer.data () + retcode, bytes_in_buffer);
12472         }
12473
12474       offset += retcode;
12475     }
12476
12477   if (remote_hostio_close (fd.release (), &remote_errno))
12478     remote_hostio_error (remote_errno);
12479
12480   if (from_tty)
12481     printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
12482 }
12483
12484 void
12485 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
12486 {
12487   remote_target *remote = get_current_remote_target ();
12488
12489   if (remote == nullptr)
12490     error (_("command can only be used with remote target"));
12491
12492   remote->remote_file_get (remote_file, local_file, from_tty);
12493 }
12494
12495 void
12496 remote_target::remote_file_get (const char *remote_file, const char *local_file,
12497                                 int from_tty)
12498 {
12499   int remote_errno, bytes, io_size;
12500   ULONGEST offset;
12501
12502   scoped_remote_fd fd
12503     (this, remote_hostio_open (NULL,
12504                                remote_file, FILEIO_O_RDONLY, 0, 0,
12505                                &remote_errno));
12506   if (fd.get () == -1)
12507     remote_hostio_error (remote_errno);
12508
12509   gdb_file_up file = gdb_fopen_cloexec (local_file, "wb");
12510   if (file == NULL)
12511     perror_with_name (local_file);
12512
12513   /* Send up to this many bytes at once.  They won't all fit in the
12514      remote packet limit, so we'll transfer slightly fewer.  */
12515   io_size = get_remote_packet_size ();
12516   gdb::byte_vector buffer (io_size);
12517
12518   offset = 0;
12519   while (1)
12520     {
12521       bytes = remote_hostio_pread (fd.get (), buffer.data (), io_size, offset,
12522                                    &remote_errno);
12523       if (bytes == 0)
12524         /* Success, but no bytes, means end-of-file.  */
12525         break;
12526       if (bytes == -1)
12527         remote_hostio_error (remote_errno);
12528
12529       offset += bytes;
12530
12531       bytes = fwrite (buffer.data (), 1, bytes, file.get ());
12532       if (bytes == 0)
12533         perror_with_name (local_file);
12534     }
12535
12536   if (remote_hostio_close (fd.release (), &remote_errno))
12537     remote_hostio_error (remote_errno);
12538
12539   if (from_tty)
12540     printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
12541 }
12542
12543 void
12544 remote_file_delete (const char *remote_file, int from_tty)
12545 {
12546   remote_target *remote = get_current_remote_target ();
12547
12548   if (remote == nullptr)
12549     error (_("command can only be used with remote target"));
12550
12551   remote->remote_file_delete (remote_file, from_tty);
12552 }
12553
12554 void
12555 remote_target::remote_file_delete (const char *remote_file, int from_tty)
12556 {
12557   int retcode, remote_errno;
12558
12559   retcode = remote_hostio_unlink (NULL, remote_file, &remote_errno);
12560   if (retcode == -1)
12561     remote_hostio_error (remote_errno);
12562
12563   if (from_tty)
12564     printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
12565 }
12566
12567 static void
12568 remote_put_command (const char *args, int from_tty)
12569 {
12570   if (args == NULL)
12571     error_no_arg (_("file to put"));
12572
12573   gdb_argv argv (args);
12574   if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12575     error (_("Invalid parameters to remote put"));
12576
12577   remote_file_put (argv[0], argv[1], from_tty);
12578 }
12579
12580 static void
12581 remote_get_command (const char *args, int from_tty)
12582 {
12583   if (args == NULL)
12584     error_no_arg (_("file to get"));
12585
12586   gdb_argv argv (args);
12587   if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12588     error (_("Invalid parameters to remote get"));
12589
12590   remote_file_get (argv[0], argv[1], from_tty);
12591 }
12592
12593 static void
12594 remote_delete_command (const char *args, int from_tty)
12595 {
12596   if (args == NULL)
12597     error_no_arg (_("file to delete"));
12598
12599   gdb_argv argv (args);
12600   if (argv[0] == NULL || argv[1] != NULL)
12601     error (_("Invalid parameters to remote delete"));
12602
12603   remote_file_delete (argv[0], from_tty);
12604 }
12605
12606 static void
12607 remote_command (const char *args, int from_tty)
12608 {
12609   help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
12610 }
12611
12612 bool
12613 remote_target::can_execute_reverse ()
12614 {
12615   if (packet_support (PACKET_bs) == PACKET_ENABLE
12616       || packet_support (PACKET_bc) == PACKET_ENABLE)
12617     return true;
12618   else
12619     return false;
12620 }
12621
12622 bool
12623 remote_target::supports_non_stop ()
12624 {
12625   return true;
12626 }
12627
12628 bool
12629 remote_target::supports_disable_randomization ()
12630 {
12631   /* Only supported in extended mode.  */
12632   return false;
12633 }
12634
12635 bool
12636 remote_target::supports_multi_process ()
12637 {
12638   struct remote_state *rs = get_remote_state ();
12639
12640   return remote_multi_process_p (rs);
12641 }
12642
12643 static int
12644 remote_supports_cond_tracepoints ()
12645 {
12646   return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
12647 }
12648
12649 bool
12650 remote_target::supports_evaluation_of_breakpoint_conditions ()
12651 {
12652   return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
12653 }
12654
12655 static int
12656 remote_supports_fast_tracepoints ()
12657 {
12658   return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
12659 }
12660
12661 static int
12662 remote_supports_static_tracepoints ()
12663 {
12664   return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
12665 }
12666
12667 static int
12668 remote_supports_install_in_trace ()
12669 {
12670   return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
12671 }
12672
12673 bool
12674 remote_target::supports_enable_disable_tracepoint ()
12675 {
12676   return (packet_support (PACKET_EnableDisableTracepoints_feature)
12677           == PACKET_ENABLE);
12678 }
12679
12680 bool
12681 remote_target::supports_string_tracing ()
12682 {
12683   return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
12684 }
12685
12686 bool
12687 remote_target::can_run_breakpoint_commands ()
12688 {
12689   return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
12690 }
12691
12692 void
12693 remote_target::trace_init ()
12694 {
12695   struct remote_state *rs = get_remote_state ();
12696
12697   putpkt ("QTinit");
12698   remote_get_noisy_reply ();
12699   if (strcmp (rs->buf.data (), "OK") != 0)
12700     error (_("Target does not support this command."));
12701 }
12702
12703 /* Recursive routine to walk through command list including loops, and
12704    download packets for each command.  */
12705
12706 void
12707 remote_target::remote_download_command_source (int num, ULONGEST addr,
12708                                                struct command_line *cmds)
12709 {
12710   struct remote_state *rs = get_remote_state ();
12711   struct command_line *cmd;
12712
12713   for (cmd = cmds; cmd; cmd = cmd->next)
12714     {
12715       QUIT;     /* Allow user to bail out with ^C.  */
12716       strcpy (rs->buf.data (), "QTDPsrc:");
12717       encode_source_string (num, addr, "cmd", cmd->line,
12718                             rs->buf.data () + strlen (rs->buf.data ()),
12719                             rs->buf.size () - strlen (rs->buf.data ()));
12720       putpkt (rs->buf);
12721       remote_get_noisy_reply ();
12722       if (strcmp (rs->buf.data (), "OK"))
12723         warning (_("Target does not support source download."));
12724
12725       if (cmd->control_type == while_control
12726           || cmd->control_type == while_stepping_control)
12727         {
12728           remote_download_command_source (num, addr, cmd->body_list_0.get ());
12729
12730           QUIT; /* Allow user to bail out with ^C.  */
12731           strcpy (rs->buf.data (), "QTDPsrc:");
12732           encode_source_string (num, addr, "cmd", "end",
12733                                 rs->buf.data () + strlen (rs->buf.data ()),
12734                                 rs->buf.size () - strlen (rs->buf.data ()));
12735           putpkt (rs->buf);
12736           remote_get_noisy_reply ();
12737           if (strcmp (rs->buf.data (), "OK"))
12738             warning (_("Target does not support source download."));
12739         }
12740     }
12741 }
12742
12743 void
12744 remote_target::download_tracepoint (struct bp_location *loc)
12745 {
12746   CORE_ADDR tpaddr;
12747   char addrbuf[40];
12748   std::vector<std::string> tdp_actions;
12749   std::vector<std::string> stepping_actions;
12750   char *pkt;
12751   struct breakpoint *b = loc->owner;
12752   struct tracepoint *t = (struct tracepoint *) b;
12753   struct remote_state *rs = get_remote_state ();
12754   int ret;
12755   const char *err_msg = _("Tracepoint packet too large for target.");
12756   size_t size_left;
12757
12758   /* We use a buffer other than rs->buf because we'll build strings
12759      across multiple statements, and other statements in between could
12760      modify rs->buf.  */
12761   gdb::char_vector buf (get_remote_packet_size ());
12762
12763   encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
12764
12765   tpaddr = loc->address;
12766   sprintf_vma (addrbuf, tpaddr);
12767   ret = snprintf (buf.data (), buf.size (), "QTDP:%x:%s:%c:%lx:%x",
12768                   b->number, addrbuf, /* address */
12769                   (b->enable_state == bp_enabled ? 'E' : 'D'),
12770                   t->step_count, t->pass_count);
12771
12772   if (ret < 0 || ret >= buf.size ())
12773     error ("%s", err_msg);
12774
12775   /* Fast tracepoints are mostly handled by the target, but we can
12776      tell the target how big of an instruction block should be moved
12777      around.  */
12778   if (b->type == bp_fast_tracepoint)
12779     {
12780       /* Only test for support at download time; we may not know
12781          target capabilities at definition time.  */
12782       if (remote_supports_fast_tracepoints ())
12783         {
12784           if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr,
12785                                                 NULL))
12786             {
12787               size_left = buf.size () - strlen (buf.data ());
12788               ret = snprintf (buf.data () + strlen (buf.data ()),
12789                               size_left, ":F%x",
12790                               gdb_insn_length (loc->gdbarch, tpaddr));
12791
12792               if (ret < 0 || ret >= size_left)
12793                 error ("%s", err_msg);
12794             }
12795           else
12796             /* If it passed validation at definition but fails now,
12797                something is very wrong.  */
12798             internal_error (__FILE__, __LINE__,
12799                             _("Fast tracepoint not "
12800                               "valid during download"));
12801         }
12802       else
12803         /* Fast tracepoints are functionally identical to regular
12804            tracepoints, so don't take lack of support as a reason to
12805            give up on the trace run.  */
12806         warning (_("Target does not support fast tracepoints, "
12807                    "downloading %d as regular tracepoint"), b->number);
12808     }
12809   else if (b->type == bp_static_tracepoint)
12810     {
12811       /* Only test for support at download time; we may not know
12812          target capabilities at definition time.  */
12813       if (remote_supports_static_tracepoints ())
12814         {
12815           struct static_tracepoint_marker marker;
12816
12817           if (target_static_tracepoint_marker_at (tpaddr, &marker))
12818             {
12819               size_left = buf.size () - strlen (buf.data ());
12820               ret = snprintf (buf.data () + strlen (buf.data ()),
12821                               size_left, ":S");
12822
12823               if (ret < 0 || ret >= size_left)
12824                 error ("%s", err_msg);
12825             }
12826           else
12827             error (_("Static tracepoint not valid during download"));
12828         }
12829       else
12830         /* Fast tracepoints are functionally identical to regular
12831            tracepoints, so don't take lack of support as a reason
12832            to give up on the trace run.  */
12833         error (_("Target does not support static tracepoints"));
12834     }
12835   /* If the tracepoint has a conditional, make it into an agent
12836      expression and append to the definition.  */
12837   if (loc->cond)
12838     {
12839       /* Only test support at download time, we may not know target
12840          capabilities at definition time.  */
12841       if (remote_supports_cond_tracepoints ())
12842         {
12843           agent_expr_up aexpr = gen_eval_for_expr (tpaddr,
12844                                                    loc->cond.get ());
12845
12846           size_left = buf.size () - strlen (buf.data ());
12847
12848           ret = snprintf (buf.data () + strlen (buf.data ()),
12849                           size_left, ":X%x,", aexpr->len);
12850
12851           if (ret < 0 || ret >= size_left)
12852             error ("%s", err_msg);
12853
12854           size_left = buf.size () - strlen (buf.data ());
12855
12856           /* Two bytes to encode each aexpr byte, plus the terminating
12857              null byte.  */
12858           if (aexpr->len * 2 + 1 > size_left)
12859             error ("%s", err_msg);
12860
12861           pkt = buf.data () + strlen (buf.data ());
12862
12863           for (int ndx = 0; ndx < aexpr->len; ++ndx)
12864             pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
12865           *pkt = '\0';
12866         }
12867       else
12868         warning (_("Target does not support conditional tracepoints, "
12869                    "ignoring tp %d cond"), b->number);
12870     }
12871
12872   if (b->commands || *default_collect)
12873     {
12874       size_left = buf.size () - strlen (buf.data ());
12875
12876       ret = snprintf (buf.data () + strlen (buf.data ()),
12877                       size_left, "-");
12878
12879       if (ret < 0 || ret >= size_left)
12880         error ("%s", err_msg);
12881     }
12882
12883   putpkt (buf.data ());
12884   remote_get_noisy_reply ();
12885   if (strcmp (rs->buf.data (), "OK"))
12886     error (_("Target does not support tracepoints."));
12887
12888   /* do_single_steps (t); */
12889   for (auto action_it = tdp_actions.begin ();
12890        action_it != tdp_actions.end (); action_it++)
12891     {
12892       QUIT;     /* Allow user to bail out with ^C.  */
12893
12894       bool has_more = ((action_it + 1) != tdp_actions.end ()
12895                        || !stepping_actions.empty ());
12896
12897       ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%c",
12898                       b->number, addrbuf, /* address */
12899                       action_it->c_str (),
12900                       has_more ? '-' : 0);
12901
12902       if (ret < 0 || ret >= buf.size ())
12903         error ("%s", err_msg);
12904
12905       putpkt (buf.data ());
12906       remote_get_noisy_reply ();
12907       if (strcmp (rs->buf.data (), "OK"))
12908         error (_("Error on target while setting tracepoints."));
12909     }
12910
12911   for (auto action_it = stepping_actions.begin ();
12912        action_it != stepping_actions.end (); action_it++)
12913     {
12914       QUIT;     /* Allow user to bail out with ^C.  */
12915
12916       bool is_first = action_it == stepping_actions.begin ();
12917       bool has_more = (action_it + 1) != stepping_actions.end ();
12918
12919       ret = snprintf (buf.data (), buf.size (), "QTDP:-%x:%s:%s%s%s",
12920                       b->number, addrbuf, /* address */
12921                       is_first ? "S" : "",
12922                       action_it->c_str (),
12923                       has_more ? "-" : "");
12924
12925       if (ret < 0 || ret >= buf.size ())
12926         error ("%s", err_msg);
12927
12928       putpkt (buf.data ());
12929       remote_get_noisy_reply ();
12930       if (strcmp (rs->buf.data (), "OK"))
12931         error (_("Error on target while setting tracepoints."));
12932     }
12933
12934   if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
12935     {
12936       if (b->location != NULL)
12937         {
12938           ret = snprintf (buf.data (), buf.size (), "QTDPsrc:");
12939
12940           if (ret < 0 || ret >= buf.size ())
12941             error ("%s", err_msg);
12942
12943           encode_source_string (b->number, loc->address, "at",
12944                                 event_location_to_string (b->location.get ()),
12945                                 buf.data () + strlen (buf.data ()),
12946                                 buf.size () - strlen (buf.data ()));
12947           putpkt (buf.data ());
12948           remote_get_noisy_reply ();
12949           if (strcmp (rs->buf.data (), "OK"))
12950             warning (_("Target does not support source download."));
12951         }
12952       if (b->cond_string)
12953         {
12954           ret = snprintf (buf.data (), buf.size (), "QTDPsrc:");
12955
12956           if (ret < 0 || ret >= buf.size ())
12957             error ("%s", err_msg);
12958
12959           encode_source_string (b->number, loc->address,
12960                                 "cond", b->cond_string,
12961                                 buf.data () + strlen (buf.data ()),
12962                                 buf.size () - strlen (buf.data ()));
12963           putpkt (buf.data ());
12964           remote_get_noisy_reply ();
12965           if (strcmp (rs->buf.data (), "OK"))
12966             warning (_("Target does not support source download."));
12967         }
12968       remote_download_command_source (b->number, loc->address,
12969                                       breakpoint_commands (b));
12970     }
12971 }
12972
12973 bool
12974 remote_target::can_download_tracepoint ()
12975 {
12976   struct remote_state *rs = get_remote_state ();
12977   struct trace_status *ts;
12978   int status;
12979
12980   /* Don't try to install tracepoints until we've relocated our
12981      symbols, and fetched and merged the target's tracepoint list with
12982      ours.  */
12983   if (rs->starting_up)
12984     return false;
12985
12986   ts = current_trace_status ();
12987   status = get_trace_status (ts);
12988
12989   if (status == -1 || !ts->running_known || !ts->running)
12990     return false;
12991
12992   /* If we are in a tracing experiment, but remote stub doesn't support
12993      installing tracepoint in trace, we have to return.  */
12994   if (!remote_supports_install_in_trace ())
12995     return false;
12996
12997   return true;
12998 }
12999
13000
13001 void
13002 remote_target::download_trace_state_variable (const trace_state_variable &tsv)
13003 {
13004   struct remote_state *rs = get_remote_state ();
13005   char *p;
13006
13007   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDV:%x:%s:%x:",
13008              tsv.number, phex ((ULONGEST) tsv.initial_value, 8),
13009              tsv.builtin);
13010   p = rs->buf.data () + strlen (rs->buf.data ());
13011   if ((p - rs->buf.data ()) + tsv.name.length () * 2
13012       >= get_remote_packet_size ())
13013     error (_("Trace state variable name too long for tsv definition packet"));
13014   p += 2 * bin2hex ((gdb_byte *) (tsv.name.data ()), p, tsv.name.length ());
13015   *p++ = '\0';
13016   putpkt (rs->buf);
13017   remote_get_noisy_reply ();
13018   if (rs->buf[0] == '\0')
13019     error (_("Target does not support this command."));
13020   if (strcmp (rs->buf.data (), "OK") != 0)
13021     error (_("Error on target while downloading trace state variable."));
13022 }
13023
13024 void
13025 remote_target::enable_tracepoint (struct bp_location *location)
13026 {
13027   struct remote_state *rs = get_remote_state ();
13028   char addr_buf[40];
13029
13030   sprintf_vma (addr_buf, location->address);
13031   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTEnable:%x:%s",
13032              location->owner->number, addr_buf);
13033   putpkt (rs->buf);
13034   remote_get_noisy_reply ();
13035   if (rs->buf[0] == '\0')
13036     error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
13037   if (strcmp (rs->buf.data (), "OK") != 0)
13038     error (_("Error on target while enabling tracepoint."));
13039 }
13040
13041 void
13042 remote_target::disable_tracepoint (struct bp_location *location)
13043 {
13044   struct remote_state *rs = get_remote_state ();
13045   char addr_buf[40];
13046
13047   sprintf_vma (addr_buf, location->address);
13048   xsnprintf (rs->buf.data (), get_remote_packet_size (), "QTDisable:%x:%s",
13049              location->owner->number, addr_buf);
13050   putpkt (rs->buf);
13051   remote_get_noisy_reply ();
13052   if (rs->buf[0] == '\0')
13053     error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
13054   if (strcmp (rs->buf.data (), "OK") != 0)
13055     error (_("Error on target while disabling tracepoint."));
13056 }
13057
13058 void
13059 remote_target::trace_set_readonly_regions ()
13060 {
13061   asection *s;
13062   bfd *abfd = NULL;
13063   bfd_size_type size;
13064   bfd_vma vma;
13065   int anysecs = 0;
13066   int offset = 0;
13067
13068   if (!exec_bfd)
13069     return;                     /* No information to give.  */
13070
13071   struct remote_state *rs = get_remote_state ();
13072
13073   strcpy (rs->buf.data (), "QTro");
13074   offset = strlen (rs->buf.data ());
13075   for (s = exec_bfd->sections; s; s = s->next)
13076     {
13077       char tmp1[40], tmp2[40];
13078       int sec_length;
13079
13080       if ((s->flags & SEC_LOAD) == 0 ||
13081       /*  (s->flags & SEC_CODE) == 0 || */
13082           (s->flags & SEC_READONLY) == 0)
13083         continue;
13084
13085       anysecs = 1;
13086       vma = bfd_get_section_vma (abfd, s);
13087       size = bfd_get_section_size (s);
13088       sprintf_vma (tmp1, vma);
13089       sprintf_vma (tmp2, vma + size);
13090       sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
13091       if (offset + sec_length + 1 > rs->buf.size ())
13092         {
13093           if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
13094             warning (_("\
13095 Too many sections for read-only sections definition packet."));
13096           break;
13097         }
13098       xsnprintf (rs->buf.data () + offset, rs->buf.size () - offset, ":%s,%s",
13099                  tmp1, tmp2);
13100       offset += sec_length;
13101     }
13102   if (anysecs)
13103     {
13104       putpkt (rs->buf);
13105       getpkt (&rs->buf, 0);
13106     }
13107 }
13108
13109 void
13110 remote_target::trace_start ()
13111 {
13112   struct remote_state *rs = get_remote_state ();
13113
13114   putpkt ("QTStart");
13115   remote_get_noisy_reply ();
13116   if (rs->buf[0] == '\0')
13117     error (_("Target does not support this command."));
13118   if (strcmp (rs->buf.data (), "OK") != 0)
13119     error (_("Bogus reply from target: %s"), rs->buf.data ());
13120 }
13121
13122 int
13123 remote_target::get_trace_status (struct trace_status *ts)
13124 {
13125   /* Initialize it just to avoid a GCC false warning.  */
13126   char *p = NULL;
13127   /* FIXME we need to get register block size some other way.  */
13128   extern int trace_regblock_size;
13129   enum packet_result result;
13130   struct remote_state *rs = get_remote_state ();
13131
13132   if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
13133     return -1;
13134
13135   trace_regblock_size
13136     = rs->get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
13137
13138   putpkt ("qTStatus");
13139
13140   try
13141     {
13142       p = remote_get_noisy_reply ();
13143     }
13144   catch (const gdb_exception_error &ex)
13145     {
13146       if (ex.error != TARGET_CLOSE_ERROR)
13147         {
13148           exception_fprintf (gdb_stderr, ex, "qTStatus: ");
13149           return -1;
13150         }
13151       throw;
13152     }
13153
13154   result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
13155
13156   /* If the remote target doesn't do tracing, flag it.  */
13157   if (result == PACKET_UNKNOWN)
13158     return -1;
13159
13160   /* We're working with a live target.  */
13161   ts->filename = NULL;
13162
13163   if (*p++ != 'T')
13164     error (_("Bogus trace status reply from target: %s"), rs->buf.data ());
13165
13166   /* Function 'parse_trace_status' sets default value of each field of
13167      'ts' at first, so we don't have to do it here.  */
13168   parse_trace_status (p, ts);
13169
13170   return ts->running;
13171 }
13172
13173 void
13174 remote_target::get_tracepoint_status (struct breakpoint *bp,
13175                                       struct uploaded_tp *utp)
13176 {
13177   struct remote_state *rs = get_remote_state ();
13178   char *reply;
13179   struct bp_location *loc;
13180   struct tracepoint *tp = (struct tracepoint *) bp;
13181   size_t size = get_remote_packet_size ();
13182
13183   if (tp)
13184     {
13185       tp->hit_count = 0;
13186       tp->traceframe_usage = 0;
13187       for (loc = tp->loc; loc; loc = loc->next)
13188         {
13189           /* If the tracepoint was never downloaded, don't go asking for
13190              any status.  */
13191           if (tp->number_on_target == 0)
13192             continue;
13193           xsnprintf (rs->buf.data (), size, "qTP:%x:%s", tp->number_on_target,
13194                      phex_nz (loc->address, 0));
13195           putpkt (rs->buf);
13196           reply = remote_get_noisy_reply ();
13197           if (reply && *reply)
13198             {
13199               if (*reply == 'V')
13200                 parse_tracepoint_status (reply + 1, bp, utp);
13201             }
13202         }
13203     }
13204   else if (utp)
13205     {
13206       utp->hit_count = 0;
13207       utp->traceframe_usage = 0;
13208       xsnprintf (rs->buf.data (), size, "qTP:%x:%s", utp->number,
13209                  phex_nz (utp->addr, 0));
13210       putpkt (rs->buf);
13211       reply = remote_get_noisy_reply ();
13212       if (reply && *reply)
13213         {
13214           if (*reply == 'V')
13215             parse_tracepoint_status (reply + 1, bp, utp);
13216         }
13217     }
13218 }
13219
13220 void
13221 remote_target::trace_stop ()
13222 {
13223   struct remote_state *rs = get_remote_state ();
13224
13225   putpkt ("QTStop");
13226   remote_get_noisy_reply ();
13227   if (rs->buf[0] == '\0')
13228     error (_("Target does not support this command."));
13229   if (strcmp (rs->buf.data (), "OK") != 0)
13230     error (_("Bogus reply from target: %s"), rs->buf.data ());
13231 }
13232
13233 int
13234 remote_target::trace_find (enum trace_find_type type, int num,
13235                            CORE_ADDR addr1, CORE_ADDR addr2,
13236                            int *tpp)
13237 {
13238   struct remote_state *rs = get_remote_state ();
13239   char *endbuf = rs->buf.data () + get_remote_packet_size ();
13240   char *p, *reply;
13241   int target_frameno = -1, target_tracept = -1;
13242
13243   /* Lookups other than by absolute frame number depend on the current
13244      trace selected, so make sure it is correct on the remote end
13245      first.  */
13246   if (type != tfind_number)
13247     set_remote_traceframe ();
13248
13249   p = rs->buf.data ();
13250   strcpy (p, "QTFrame:");
13251   p = strchr (p, '\0');
13252   switch (type)
13253     {
13254     case tfind_number:
13255       xsnprintf (p, endbuf - p, "%x", num);
13256       break;
13257     case tfind_pc:
13258       xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
13259       break;
13260     case tfind_tp:
13261       xsnprintf (p, endbuf - p, "tdp:%x", num);
13262       break;
13263     case tfind_range:
13264       xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
13265                  phex_nz (addr2, 0));
13266       break;
13267     case tfind_outside:
13268       xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
13269                  phex_nz (addr2, 0));
13270       break;
13271     default:
13272       error (_("Unknown trace find type %d"), type);
13273     }
13274
13275   putpkt (rs->buf);
13276   reply = remote_get_noisy_reply ();
13277   if (*reply == '\0')
13278     error (_("Target does not support this command."));
13279
13280   while (reply && *reply)
13281     switch (*reply)
13282       {
13283       case 'F':
13284         p = ++reply;
13285         target_frameno = (int) strtol (p, &reply, 16);
13286         if (reply == p)
13287           error (_("Unable to parse trace frame number"));
13288         /* Don't update our remote traceframe number cache on failure
13289            to select a remote traceframe.  */
13290         if (target_frameno == -1)
13291           return -1;
13292         break;
13293       case 'T':
13294         p = ++reply;
13295         target_tracept = (int) strtol (p, &reply, 16);
13296         if (reply == p)
13297           error (_("Unable to parse tracepoint number"));
13298         break;
13299       case 'O':         /* "OK"? */
13300         if (reply[1] == 'K' && reply[2] == '\0')
13301           reply += 2;
13302         else
13303           error (_("Bogus reply from target: %s"), reply);
13304         break;
13305       default:
13306         error (_("Bogus reply from target: %s"), reply);
13307       }
13308   if (tpp)
13309     *tpp = target_tracept;
13310
13311   rs->remote_traceframe_number = target_frameno;
13312   return target_frameno;
13313 }
13314
13315 bool
13316 remote_target::get_trace_state_variable_value (int tsvnum, LONGEST *val)
13317 {
13318   struct remote_state *rs = get_remote_state ();
13319   char *reply;
13320   ULONGEST uval;
13321
13322   set_remote_traceframe ();
13323
13324   xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTV:%x", tsvnum);
13325   putpkt (rs->buf);
13326   reply = remote_get_noisy_reply ();
13327   if (reply && *reply)
13328     {
13329       if (*reply == 'V')
13330         {
13331           unpack_varlen_hex (reply + 1, &uval);
13332           *val = (LONGEST) uval;
13333           return true;
13334         }
13335     }
13336   return false;
13337 }
13338
13339 int
13340 remote_target::save_trace_data (const char *filename)
13341 {
13342   struct remote_state *rs = get_remote_state ();
13343   char *p, *reply;
13344
13345   p = rs->buf.data ();
13346   strcpy (p, "QTSave:");
13347   p += strlen (p);
13348   if ((p - rs->buf.data ()) + strlen (filename) * 2
13349       >= get_remote_packet_size ())
13350     error (_("Remote file name too long for trace save packet"));
13351   p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
13352   *p++ = '\0';
13353   putpkt (rs->buf);
13354   reply = remote_get_noisy_reply ();
13355   if (*reply == '\0')
13356     error (_("Target does not support this command."));
13357   if (strcmp (reply, "OK") != 0)
13358     error (_("Bogus reply from target: %s"), reply);
13359   return 0;
13360 }
13361
13362 /* This is basically a memory transfer, but needs to be its own packet
13363    because we don't know how the target actually organizes its trace
13364    memory, plus we want to be able to ask for as much as possible, but
13365    not be unhappy if we don't get as much as we ask for.  */
13366
13367 LONGEST
13368 remote_target::get_raw_trace_data (gdb_byte *buf, ULONGEST offset, LONGEST len)
13369 {
13370   struct remote_state *rs = get_remote_state ();
13371   char *reply;
13372   char *p;
13373   int rslt;
13374
13375   p = rs->buf.data ();
13376   strcpy (p, "qTBuffer:");
13377   p += strlen (p);
13378   p += hexnumstr (p, offset);
13379   *p++ = ',';
13380   p += hexnumstr (p, len);
13381   *p++ = '\0';
13382
13383   putpkt (rs->buf);
13384   reply = remote_get_noisy_reply ();
13385   if (reply && *reply)
13386     {
13387       /* 'l' by itself means we're at the end of the buffer and
13388          there is nothing more to get.  */
13389       if (*reply == 'l')
13390         return 0;
13391
13392       /* Convert the reply into binary.  Limit the number of bytes to
13393          convert according to our passed-in buffer size, rather than
13394          what was returned in the packet; if the target is
13395          unexpectedly generous and gives us a bigger reply than we
13396          asked for, we don't want to crash.  */
13397       rslt = hex2bin (reply, buf, len);
13398       return rslt;
13399     }
13400
13401   /* Something went wrong, flag as an error.  */
13402   return -1;
13403 }
13404
13405 void
13406 remote_target::set_disconnected_tracing (int val)
13407 {
13408   struct remote_state *rs = get_remote_state ();
13409
13410   if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
13411     {
13412       char *reply;
13413
13414       xsnprintf (rs->buf.data (), get_remote_packet_size (),
13415                  "QTDisconnected:%x", val);
13416       putpkt (rs->buf);
13417       reply = remote_get_noisy_reply ();
13418       if (*reply == '\0')
13419         error (_("Target does not support this command."));
13420       if (strcmp (reply, "OK") != 0)
13421         error (_("Bogus reply from target: %s"), reply);
13422     }
13423   else if (val)
13424     warning (_("Target does not support disconnected tracing."));
13425 }
13426
13427 int
13428 remote_target::core_of_thread (ptid_t ptid)
13429 {
13430   struct thread_info *info = find_thread_ptid (ptid);
13431
13432   if (info != NULL && info->priv != NULL)
13433     return get_remote_thread_info (info)->core;
13434
13435   return -1;
13436 }
13437
13438 void
13439 remote_target::set_circular_trace_buffer (int val)
13440 {
13441   struct remote_state *rs = get_remote_state ();
13442   char *reply;
13443
13444   xsnprintf (rs->buf.data (), get_remote_packet_size (),
13445              "QTBuffer:circular:%x", val);
13446   putpkt (rs->buf);
13447   reply = remote_get_noisy_reply ();
13448   if (*reply == '\0')
13449     error (_("Target does not support this command."));
13450   if (strcmp (reply, "OK") != 0)
13451     error (_("Bogus reply from target: %s"), reply);
13452 }
13453
13454 traceframe_info_up
13455 remote_target::traceframe_info ()
13456 {
13457   gdb::optional<gdb::char_vector> text
13458     = target_read_stralloc (current_top_target (), TARGET_OBJECT_TRACEFRAME_INFO,
13459                             NULL);
13460   if (text)
13461     return parse_traceframe_info (text->data ());
13462
13463   return NULL;
13464 }
13465
13466 /* Handle the qTMinFTPILen packet.  Returns the minimum length of
13467    instruction on which a fast tracepoint may be placed.  Returns -1
13468    if the packet is not supported, and 0 if the minimum instruction
13469    length is unknown.  */
13470
13471 int
13472 remote_target::get_min_fast_tracepoint_insn_len ()
13473 {
13474   struct remote_state *rs = get_remote_state ();
13475   char *reply;
13476
13477   /* If we're not debugging a process yet, the IPA can't be
13478      loaded.  */
13479   if (!target_has_execution)
13480     return 0;
13481
13482   /* Make sure the remote is pointing at the right process.  */
13483   set_general_process ();
13484
13485   xsnprintf (rs->buf.data (), get_remote_packet_size (), "qTMinFTPILen");
13486   putpkt (rs->buf);
13487   reply = remote_get_noisy_reply ();
13488   if (*reply == '\0')
13489     return -1;
13490   else
13491     {
13492       ULONGEST min_insn_len;
13493
13494       unpack_varlen_hex (reply, &min_insn_len);
13495
13496       return (int) min_insn_len;
13497     }
13498 }
13499
13500 void
13501 remote_target::set_trace_buffer_size (LONGEST val)
13502 {
13503   if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
13504     {
13505       struct remote_state *rs = get_remote_state ();
13506       char *buf = rs->buf.data ();
13507       char *endbuf = buf + get_remote_packet_size ();
13508       enum packet_result result;
13509
13510       gdb_assert (val >= 0 || val == -1);
13511       buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
13512       /* Send -1 as literal "-1" to avoid host size dependency.  */
13513       if (val < 0)
13514         {
13515           *buf++ = '-';
13516           buf += hexnumstr (buf, (ULONGEST) -val);
13517         }
13518       else
13519         buf += hexnumstr (buf, (ULONGEST) val);
13520
13521       putpkt (rs->buf);
13522       remote_get_noisy_reply ();
13523       result = packet_ok (rs->buf,
13524                   &remote_protocol_packets[PACKET_QTBuffer_size]);
13525
13526       if (result != PACKET_OK)
13527         warning (_("Bogus reply from target: %s"), rs->buf.data ());
13528     }
13529 }
13530
13531 bool
13532 remote_target::set_trace_notes (const char *user, const char *notes,
13533                                 const char *stop_notes)
13534 {
13535   struct remote_state *rs = get_remote_state ();
13536   char *reply;
13537   char *buf = rs->buf.data ();
13538   char *endbuf = buf + get_remote_packet_size ();
13539   int nbytes;
13540
13541   buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
13542   if (user)
13543     {
13544       buf += xsnprintf (buf, endbuf - buf, "user:");
13545       nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));
13546       buf += 2 * nbytes;
13547       *buf++ = ';';
13548     }
13549   if (notes)
13550     {
13551       buf += xsnprintf (buf, endbuf - buf, "notes:");
13552       nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));
13553       buf += 2 * nbytes;
13554       *buf++ = ';';
13555     }
13556   if (stop_notes)
13557     {
13558       buf += xsnprintf (buf, endbuf - buf, "tstop:");
13559       nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));
13560       buf += 2 * nbytes;
13561       *buf++ = ';';
13562     }
13563   /* Ensure the buffer is terminated.  */
13564   *buf = '\0';
13565
13566   putpkt (rs->buf);
13567   reply = remote_get_noisy_reply ();
13568   if (*reply == '\0')
13569     return false;
13570
13571   if (strcmp (reply, "OK") != 0)
13572     error (_("Bogus reply from target: %s"), reply);
13573
13574   return true;
13575 }
13576
13577 bool
13578 remote_target::use_agent (bool use)
13579 {
13580   if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
13581     {
13582       struct remote_state *rs = get_remote_state ();
13583
13584       /* If the stub supports QAgent.  */
13585       xsnprintf (rs->buf.data (), get_remote_packet_size (), "QAgent:%d", use);
13586       putpkt (rs->buf);
13587       getpkt (&rs->buf, 0);
13588
13589       if (strcmp (rs->buf.data (), "OK") == 0)
13590         {
13591           ::use_agent = use;
13592           return true;
13593         }
13594     }
13595
13596   return false;
13597 }
13598
13599 bool
13600 remote_target::can_use_agent ()
13601 {
13602   return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
13603 }
13604
13605 struct btrace_target_info
13606 {
13607   /* The ptid of the traced thread.  */
13608   ptid_t ptid;
13609
13610   /* The obtained branch trace configuration.  */
13611   struct btrace_config conf;
13612 };
13613
13614 /* Reset our idea of our target's btrace configuration.  */
13615
13616 static void
13617 remote_btrace_reset (remote_state *rs)
13618 {
13619   memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
13620 }
13621
13622 /* Synchronize the configuration with the target.  */
13623
13624 void
13625 remote_target::btrace_sync_conf (const btrace_config *conf)
13626 {
13627   struct packet_config *packet;
13628   struct remote_state *rs;
13629   char *buf, *pos, *endbuf;
13630
13631   rs = get_remote_state ();
13632   buf = rs->buf.data ();
13633   endbuf = buf + get_remote_packet_size ();
13634
13635   packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
13636   if (packet_config_support (packet) == PACKET_ENABLE
13637       && conf->bts.size != rs->btrace_config.bts.size)
13638     {
13639       pos = buf;
13640       pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13641                         conf->bts.size);
13642
13643       putpkt (buf);
13644       getpkt (&rs->buf, 0);
13645
13646       if (packet_ok (buf, packet) == PACKET_ERROR)
13647         {
13648           if (buf[0] == 'E' && buf[1] == '.')
13649             error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
13650           else
13651             error (_("Failed to configure the BTS buffer size."));
13652         }
13653
13654       rs->btrace_config.bts.size = conf->bts.size;
13655     }
13656
13657   packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
13658   if (packet_config_support (packet) == PACKET_ENABLE
13659       && conf->pt.size != rs->btrace_config.pt.size)
13660     {
13661       pos = buf;
13662       pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13663                         conf->pt.size);
13664
13665       putpkt (buf);
13666       getpkt (&rs->buf, 0);
13667
13668       if (packet_ok (buf, packet) == PACKET_ERROR)
13669         {
13670           if (buf[0] == 'E' && buf[1] == '.')
13671             error (_("Failed to configure the trace buffer size: %s"), buf + 2);
13672           else
13673             error (_("Failed to configure the trace buffer size."));
13674         }
13675
13676       rs->btrace_config.pt.size = conf->pt.size;
13677     }
13678 }
13679
13680 /* Read the current thread's btrace configuration from the target and
13681    store it into CONF.  */
13682
13683 static void
13684 btrace_read_config (struct btrace_config *conf)
13685 {
13686   gdb::optional<gdb::char_vector> xml
13687     = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE_CONF, "");
13688   if (xml)
13689     parse_xml_btrace_conf (conf, xml->data ());
13690 }
13691
13692 /* Maybe reopen target btrace.  */
13693
13694 void
13695 remote_target::remote_btrace_maybe_reopen ()
13696 {
13697   struct remote_state *rs = get_remote_state ();
13698   int btrace_target_pushed = 0;
13699 #if !defined (HAVE_LIBIPT)
13700   int warned = 0;
13701 #endif
13702
13703   scoped_restore_current_thread restore_thread;
13704
13705   for (thread_info *tp : all_non_exited_threads ())
13706     {
13707       set_general_thread (tp->ptid);
13708
13709       memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
13710       btrace_read_config (&rs->btrace_config);
13711
13712       if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
13713         continue;
13714
13715 #if !defined (HAVE_LIBIPT)
13716       if (rs->btrace_config.format == BTRACE_FORMAT_PT)
13717         {
13718           if (!warned)
13719             {
13720               warned = 1;
13721               warning (_("Target is recording using Intel Processor Trace "
13722                          "but support was disabled at compile time."));
13723             }
13724
13725           continue;
13726         }
13727 #endif /* !defined (HAVE_LIBIPT) */
13728
13729       /* Push target, once, but before anything else happens.  This way our
13730          changes to the threads will be cleaned up by unpushing the target
13731          in case btrace_read_config () throws.  */
13732       if (!btrace_target_pushed)
13733         {
13734           btrace_target_pushed = 1;
13735           record_btrace_push_target ();
13736           printf_filtered (_("Target is recording using %s.\n"),
13737                            btrace_format_string (rs->btrace_config.format));
13738         }
13739
13740       tp->btrace.target = XCNEW (struct btrace_target_info);
13741       tp->btrace.target->ptid = tp->ptid;
13742       tp->btrace.target->conf = rs->btrace_config;
13743     }
13744 }
13745
13746 /* Enable branch tracing.  */
13747
13748 struct btrace_target_info *
13749 remote_target::enable_btrace (ptid_t ptid, const struct btrace_config *conf)
13750 {
13751   struct btrace_target_info *tinfo = NULL;
13752   struct packet_config *packet = NULL;
13753   struct remote_state *rs = get_remote_state ();
13754   char *buf = rs->buf.data ();
13755   char *endbuf = buf + get_remote_packet_size ();
13756
13757   switch (conf->format)
13758     {
13759       case BTRACE_FORMAT_BTS:
13760         packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
13761         break;
13762
13763       case BTRACE_FORMAT_PT:
13764         packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
13765         break;
13766     }
13767
13768   if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
13769     error (_("Target does not support branch tracing."));
13770
13771   btrace_sync_conf (conf);
13772
13773   set_general_thread (ptid);
13774
13775   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13776   putpkt (rs->buf);
13777   getpkt (&rs->buf, 0);
13778
13779   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13780     {
13781       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13782         error (_("Could not enable branch tracing for %s: %s"),
13783                target_pid_to_str (ptid).c_str (), &rs->buf[2]);
13784       else
13785         error (_("Could not enable branch tracing for %s."),
13786                target_pid_to_str (ptid).c_str ());
13787     }
13788
13789   tinfo = XCNEW (struct btrace_target_info);
13790   tinfo->ptid = ptid;
13791
13792   /* If we fail to read the configuration, we lose some information, but the
13793      tracing itself is not impacted.  */
13794   try
13795     {
13796       btrace_read_config (&tinfo->conf);
13797     }
13798   catch (const gdb_exception_error &err)
13799     {
13800       if (err.message != NULL)
13801         warning ("%s", err.what ());
13802     }
13803
13804   return tinfo;
13805 }
13806
13807 /* Disable branch tracing.  */
13808
13809 void
13810 remote_target::disable_btrace (struct btrace_target_info *tinfo)
13811 {
13812   struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
13813   struct remote_state *rs = get_remote_state ();
13814   char *buf = rs->buf.data ();
13815   char *endbuf = buf + get_remote_packet_size ();
13816
13817   if (packet_config_support (packet) != PACKET_ENABLE)
13818     error (_("Target does not support branch tracing."));
13819
13820   set_general_thread (tinfo->ptid);
13821
13822   buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13823   putpkt (rs->buf);
13824   getpkt (&rs->buf, 0);
13825
13826   if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13827     {
13828       if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13829         error (_("Could not disable branch tracing for %s: %s"),
13830                target_pid_to_str (tinfo->ptid).c_str (), &rs->buf[2]);
13831       else
13832         error (_("Could not disable branch tracing for %s."),
13833                target_pid_to_str (tinfo->ptid).c_str ());
13834     }
13835
13836   xfree (tinfo);
13837 }
13838
13839 /* Teardown branch tracing.  */
13840
13841 void
13842 remote_target::teardown_btrace (struct btrace_target_info *tinfo)
13843 {
13844   /* We must not talk to the target during teardown.  */
13845   xfree (tinfo);
13846 }
13847
13848 /* Read the branch trace.  */
13849
13850 enum btrace_error
13851 remote_target::read_btrace (struct btrace_data *btrace,
13852                             struct btrace_target_info *tinfo,
13853                             enum btrace_read_type type)
13854 {
13855   struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
13856   const char *annex;
13857
13858   if (packet_config_support (packet) != PACKET_ENABLE)
13859     error (_("Target does not support branch tracing."));
13860
13861 #if !defined(HAVE_LIBEXPAT)
13862   error (_("Cannot process branch tracing result. XML parsing not supported."));
13863 #endif
13864
13865   switch (type)
13866     {
13867     case BTRACE_READ_ALL:
13868       annex = "all";
13869       break;
13870     case BTRACE_READ_NEW:
13871       annex = "new";
13872       break;
13873     case BTRACE_READ_DELTA:
13874       annex = "delta";
13875       break;
13876     default:
13877       internal_error (__FILE__, __LINE__,
13878                       _("Bad branch tracing read type: %u."),
13879                       (unsigned int) type);
13880     }
13881
13882   gdb::optional<gdb::char_vector> xml
13883     = target_read_stralloc (current_top_target (), TARGET_OBJECT_BTRACE, annex);
13884   if (!xml)
13885     return BTRACE_ERR_UNKNOWN;
13886
13887   parse_xml_btrace (btrace, xml->data ());
13888
13889   return BTRACE_ERR_NONE;
13890 }
13891
13892 const struct btrace_config *
13893 remote_target::btrace_conf (const struct btrace_target_info *tinfo)
13894 {
13895   return &tinfo->conf;
13896 }
13897
13898 bool
13899 remote_target::augmented_libraries_svr4_read ()
13900 {
13901   return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
13902           == PACKET_ENABLE);
13903 }
13904
13905 /* Implementation of to_load.  */
13906
13907 void
13908 remote_target::load (const char *name, int from_tty)
13909 {
13910   generic_load (name, from_tty);
13911 }
13912
13913 /* Accepts an integer PID; returns a string representing a file that
13914    can be opened on the remote side to get the symbols for the child
13915    process.  Returns NULL if the operation is not supported.  */
13916
13917 char *
13918 remote_target::pid_to_exec_file (int pid)
13919 {
13920   static gdb::optional<gdb::char_vector> filename;
13921   struct inferior *inf;
13922   char *annex = NULL;
13923
13924   if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
13925     return NULL;
13926
13927   inf = find_inferior_pid (pid);
13928   if (inf == NULL)
13929     internal_error (__FILE__, __LINE__,
13930                     _("not currently attached to process %d"), pid);
13931
13932   if (!inf->fake_pid_p)
13933     {
13934       const int annex_size = 9;
13935
13936       annex = (char *) alloca (annex_size);
13937       xsnprintf (annex, annex_size, "%x", pid);
13938     }
13939
13940   filename = target_read_stralloc (current_top_target (),
13941                                    TARGET_OBJECT_EXEC_FILE, annex);
13942
13943   return filename ? filename->data () : nullptr;
13944 }
13945
13946 /* Implement the to_can_do_single_step target_ops method.  */
13947
13948 int
13949 remote_target::can_do_single_step ()
13950 {
13951   /* We can only tell whether target supports single step or not by
13952      supported s and S vCont actions if the stub supports vContSupported
13953      feature.  If the stub doesn't support vContSupported feature,
13954      we have conservatively to think target doesn't supports single
13955      step.  */
13956   if (packet_support (PACKET_vContSupported) == PACKET_ENABLE)
13957     {
13958       struct remote_state *rs = get_remote_state ();
13959
13960       if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
13961         remote_vcont_probe ();
13962
13963       return rs->supports_vCont.s && rs->supports_vCont.S;
13964     }
13965   else
13966     return 0;
13967 }
13968
13969 /* Implementation of the to_execution_direction method for the remote
13970    target.  */
13971
13972 enum exec_direction_kind
13973 remote_target::execution_direction ()
13974 {
13975   struct remote_state *rs = get_remote_state ();
13976
13977   return rs->last_resume_exec_dir;
13978 }
13979
13980 /* Return pointer to the thread_info struct which corresponds to
13981    THREAD_HANDLE (having length HANDLE_LEN).  */
13982
13983 thread_info *
13984 remote_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
13985                                              int handle_len,
13986                                              inferior *inf)
13987 {
13988   for (thread_info *tp : all_non_exited_threads ())
13989     {
13990       remote_thread_info *priv = get_remote_thread_info (tp);
13991
13992       if (tp->inf == inf && priv != NULL)
13993         {
13994           if (handle_len != priv->thread_handle.size ())
13995             error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13996                    handle_len, priv->thread_handle.size ());
13997           if (memcmp (thread_handle, priv->thread_handle.data (),
13998                       handle_len) == 0)
13999             return tp;
14000         }
14001     }
14002
14003   return NULL;
14004 }
14005
14006 gdb::byte_vector
14007 remote_target::thread_info_to_thread_handle (struct thread_info *tp)
14008 {
14009   remote_thread_info *priv = get_remote_thread_info (tp);
14010   return priv->thread_handle;
14011 }
14012
14013 bool
14014 remote_target::can_async_p ()
14015 {
14016   struct remote_state *rs = get_remote_state ();
14017
14018   /* We don't go async if the user has explicitly prevented it with the
14019      "maint set target-async" command.  */
14020   if (!target_async_permitted)
14021     return false;
14022
14023   /* We're async whenever the serial device is.  */
14024   return serial_can_async_p (rs->remote_desc);
14025 }
14026
14027 bool
14028 remote_target::is_async_p ()
14029 {
14030   struct remote_state *rs = get_remote_state ();
14031
14032   if (!target_async_permitted)
14033     /* We only enable async when the user specifically asks for it.  */
14034     return false;
14035
14036   /* We're async whenever the serial device is.  */
14037   return serial_is_async_p (rs->remote_desc);
14038 }
14039
14040 /* Pass the SERIAL event on and up to the client.  One day this code
14041    will be able to delay notifying the client of an event until the
14042    point where an entire packet has been received.  */
14043
14044 static serial_event_ftype remote_async_serial_handler;
14045
14046 static void
14047 remote_async_serial_handler (struct serial *scb, void *context)
14048 {
14049   /* Don't propogate error information up to the client.  Instead let
14050      the client find out about the error by querying the target.  */
14051   inferior_event_handler (INF_REG_EVENT, NULL);
14052 }
14053
14054 static void
14055 remote_async_inferior_event_handler (gdb_client_data data)
14056 {
14057   inferior_event_handler (INF_REG_EVENT, data);
14058 }
14059
14060 void
14061 remote_target::async (int enable)
14062 {
14063   struct remote_state *rs = get_remote_state ();
14064
14065   if (enable)
14066     {
14067       serial_async (rs->remote_desc, remote_async_serial_handler, rs);
14068
14069       /* If there are pending events in the stop reply queue tell the
14070          event loop to process them.  */
14071       if (!rs->stop_reply_queue.empty ())
14072         mark_async_event_handler (rs->remote_async_inferior_event_token);
14073       /* For simplicity, below we clear the pending events token
14074          without remembering whether it is marked, so here we always
14075          mark it.  If there's actually no pending notification to
14076          process, this ends up being a no-op (other than a spurious
14077          event-loop wakeup).  */
14078       if (target_is_non_stop_p ())
14079         mark_async_event_handler (rs->notif_state->get_pending_events_token);
14080     }
14081   else
14082     {
14083       serial_async (rs->remote_desc, NULL, NULL);
14084       /* If the core is disabling async, it doesn't want to be
14085          disturbed with target events.  Clear all async event sources
14086          too.  */
14087       clear_async_event_handler (rs->remote_async_inferior_event_token);
14088       if (target_is_non_stop_p ())
14089         clear_async_event_handler (rs->notif_state->get_pending_events_token);
14090     }
14091 }
14092
14093 /* Implementation of the to_thread_events method.  */
14094
14095 void
14096 remote_target::thread_events (int enable)
14097 {
14098   struct remote_state *rs = get_remote_state ();
14099   size_t size = get_remote_packet_size ();
14100
14101   if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
14102     return;
14103
14104   xsnprintf (rs->buf.data (), size, "QThreadEvents:%x", enable ? 1 : 0);
14105   putpkt (rs->buf);
14106   getpkt (&rs->buf, 0);
14107
14108   switch (packet_ok (rs->buf,
14109                      &remote_protocol_packets[PACKET_QThreadEvents]))
14110     {
14111     case PACKET_OK:
14112       if (strcmp (rs->buf.data (), "OK") != 0)
14113         error (_("Remote refused setting thread events: %s"), rs->buf.data ());
14114       break;
14115     case PACKET_ERROR:
14116       warning (_("Remote failure reply: %s"), rs->buf.data ());
14117       break;
14118     case PACKET_UNKNOWN:
14119       break;
14120     }
14121 }
14122
14123 static void
14124 set_remote_cmd (const char *args, int from_tty)
14125 {
14126   help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
14127 }
14128
14129 static void
14130 show_remote_cmd (const char *args, int from_tty)
14131 {
14132   /* We can't just use cmd_show_list here, because we want to skip
14133      the redundant "show remote Z-packet" and the legacy aliases.  */
14134   struct cmd_list_element *list = remote_show_cmdlist;
14135   struct ui_out *uiout = current_uiout;
14136
14137   ui_out_emit_tuple tuple_emitter (uiout, "showlist");
14138   for (; list != NULL; list = list->next)
14139     if (strcmp (list->name, "Z-packet") == 0)
14140       continue;
14141     else if (list->type == not_set_cmd)
14142       /* Alias commands are exactly like the original, except they
14143          don't have the normal type.  */
14144       continue;
14145     else
14146       {
14147         ui_out_emit_tuple option_emitter (uiout, "option");
14148
14149         uiout->field_string ("name", list->name);
14150         uiout->text (":  ");
14151         if (list->type == show_cmd)
14152           do_show_command (NULL, from_tty, list);
14153         else
14154           cmd_func (list, NULL, from_tty);
14155       }
14156 }
14157
14158
14159 /* Function to be called whenever a new objfile (shlib) is detected.  */
14160 static void
14161 remote_new_objfile (struct objfile *objfile)
14162 {
14163   remote_target *remote = get_current_remote_target ();
14164
14165   if (remote != NULL)                   /* Have a remote connection.  */
14166     remote->remote_check_symbols ();
14167 }
14168
14169 /* Pull all the tracepoints defined on the target and create local
14170    data structures representing them.  We don't want to create real
14171    tracepoints yet, we don't want to mess up the user's existing
14172    collection.  */
14173   
14174 int
14175 remote_target::upload_tracepoints (struct uploaded_tp **utpp)
14176 {
14177   struct remote_state *rs = get_remote_state ();
14178   char *p;
14179
14180   /* Ask for a first packet of tracepoint definition.  */
14181   putpkt ("qTfP");
14182   getpkt (&rs->buf, 0);
14183   p = rs->buf.data ();
14184   while (*p && *p != 'l')
14185     {
14186       parse_tracepoint_definition (p, utpp);
14187       /* Ask for another packet of tracepoint definition.  */
14188       putpkt ("qTsP");
14189       getpkt (&rs->buf, 0);
14190       p = rs->buf.data ();
14191     }
14192   return 0;
14193 }
14194
14195 int
14196 remote_target::upload_trace_state_variables (struct uploaded_tsv **utsvp)
14197 {
14198   struct remote_state *rs = get_remote_state ();
14199   char *p;
14200
14201   /* Ask for a first packet of variable definition.  */
14202   putpkt ("qTfV");
14203   getpkt (&rs->buf, 0);
14204   p = rs->buf.data ();
14205   while (*p && *p != 'l')
14206     {
14207       parse_tsv_definition (p, utsvp);
14208       /* Ask for another packet of variable definition.  */
14209       putpkt ("qTsV");
14210       getpkt (&rs->buf, 0);
14211       p = rs->buf.data ();
14212     }
14213   return 0;
14214 }
14215
14216 /* The "set/show range-stepping" show hook.  */
14217
14218 static void
14219 show_range_stepping (struct ui_file *file, int from_tty,
14220                      struct cmd_list_element *c,
14221                      const char *value)
14222 {
14223   fprintf_filtered (file,
14224                     _("Debugger's willingness to use range stepping "
14225                       "is %s.\n"), value);
14226 }
14227
14228 /* Return true if the vCont;r action is supported by the remote
14229    stub.  */
14230
14231 bool
14232 remote_target::vcont_r_supported ()
14233 {
14234   if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
14235     remote_vcont_probe ();
14236
14237   return (packet_support (PACKET_vCont) == PACKET_ENABLE
14238           && get_remote_state ()->supports_vCont.r);
14239 }
14240
14241 /* The "set/show range-stepping" set hook.  */
14242
14243 static void
14244 set_range_stepping (const char *ignore_args, int from_tty,
14245                     struct cmd_list_element *c)
14246 {
14247   /* When enabling, check whether range stepping is actually supported
14248      by the target, and warn if not.  */
14249   if (use_range_stepping)
14250     {
14251       remote_target *remote = get_current_remote_target ();
14252       if (remote == NULL
14253           || !remote->vcont_r_supported ())
14254         warning (_("Range stepping is not supported by the current target"));
14255     }
14256 }
14257
14258 void
14259 _initialize_remote (void)
14260 {
14261   struct cmd_list_element *cmd;
14262   const char *cmd_name;
14263
14264   /* architecture specific data */
14265   remote_g_packet_data_handle =
14266     gdbarch_data_register_pre_init (remote_g_packet_data_init);
14267
14268   add_target (remote_target_info, remote_target::open);
14269   add_target (extended_remote_target_info, extended_remote_target::open);
14270
14271   /* Hook into new objfile notification.  */
14272   gdb::observers::new_objfile.attach (remote_new_objfile);
14273
14274 #if 0
14275   init_remote_threadtests ();
14276 #endif
14277
14278   /* set/show remote ...  */
14279
14280   add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
14281 Remote protocol specific variables.\n\
14282 Configure various remote-protocol specific variables such as\n\
14283 the packets being used."),
14284                   &remote_set_cmdlist, "set remote ",
14285                   0 /* allow-unknown */, &setlist);
14286   add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
14287 Remote protocol specific variables.\n\
14288 Configure various remote-protocol specific variables such as\n\
14289 the packets being used."),
14290                   &remote_show_cmdlist, "show remote ",
14291                   0 /* allow-unknown */, &showlist);
14292
14293   add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
14294 Compare section data on target to the exec file.\n\
14295 Argument is a single section name (default: all loaded sections).\n\
14296 To compare only read-only loaded sections, specify the -r option."),
14297            &cmdlist);
14298
14299   add_cmd ("packet", class_maintenance, packet_command, _("\
14300 Send an arbitrary packet to a remote target.\n\
14301    maintenance packet TEXT\n\
14302 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14303 this command sends the string TEXT to the inferior, and displays the\n\
14304 response packet.  GDB supplies the initial `$' character, and the\n\
14305 terminating `#' character and checksum."),
14306            &maintenancelist);
14307
14308   add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
14309 Set whether to send break if interrupted."), _("\
14310 Show whether to send break if interrupted."), _("\
14311 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14312                            set_remotebreak, show_remotebreak,
14313                            &setlist, &showlist);
14314   cmd_name = "remotebreak";
14315   cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
14316   deprecate_cmd (cmd, "set remote interrupt-sequence");
14317   cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
14318   cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
14319   deprecate_cmd (cmd, "show remote interrupt-sequence");
14320
14321   add_setshow_enum_cmd ("interrupt-sequence", class_support,
14322                         interrupt_sequence_modes, &interrupt_sequence_mode,
14323                         _("\
14324 Set interrupt sequence to remote target."), _("\
14325 Show interrupt sequence to remote target."), _("\
14326 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14327                         NULL, show_interrupt_sequence,
14328                         &remote_set_cmdlist,
14329                         &remote_show_cmdlist);
14330
14331   add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
14332                            &interrupt_on_connect, _("\
14333 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14334 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _("\
14335 If set, interrupt sequence is sent to remote target."),
14336                            NULL, NULL,
14337                            &remote_set_cmdlist, &remote_show_cmdlist);
14338
14339   /* Install commands for configuring memory read/write packets.  */
14340
14341   add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
14342 Set the maximum number of bytes per memory write packet (deprecated)."),
14343            &setlist);
14344   add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
14345 Show the maximum number of bytes per memory write packet (deprecated)."),
14346            &showlist);
14347   add_cmd ("memory-write-packet-size", no_class,
14348            set_memory_write_packet_size, _("\
14349 Set the maximum number of bytes per memory-write packet.\n\
14350 Specify the number of bytes in a packet or 0 (zero) for the\n\
14351 default packet size.  The actual limit is further reduced\n\
14352 dependent on the target.  Specify ``fixed'' to disable the\n\
14353 further restriction and ``limit'' to enable that restriction."),
14354            &remote_set_cmdlist);
14355   add_cmd ("memory-read-packet-size", no_class,
14356            set_memory_read_packet_size, _("\
14357 Set the maximum number of bytes per memory-read packet.\n\
14358 Specify the number of bytes in a packet or 0 (zero) for the\n\
14359 default packet size.  The actual limit is further reduced\n\
14360 dependent on the target.  Specify ``fixed'' to disable the\n\
14361 further restriction and ``limit'' to enable that restriction."),
14362            &remote_set_cmdlist);
14363   add_cmd ("memory-write-packet-size", no_class,
14364            show_memory_write_packet_size,
14365            _("Show the maximum number of bytes per memory-write packet."),
14366            &remote_show_cmdlist);
14367   add_cmd ("memory-read-packet-size", no_class,
14368            show_memory_read_packet_size,
14369            _("Show the maximum number of bytes per memory-read packet."),
14370            &remote_show_cmdlist);
14371
14372   add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-limit", no_class,
14373                             &remote_hw_watchpoint_limit, _("\
14374 Set the maximum number of target hardware watchpoints."), _("\
14375 Show the maximum number of target hardware watchpoints."), _("\
14376 Specify \"unlimited\" for unlimited hardware watchpoints."),
14377                             NULL, show_hardware_watchpoint_limit,
14378                             &remote_set_cmdlist,
14379                             &remote_show_cmdlist);
14380   add_setshow_zuinteger_unlimited_cmd ("hardware-watchpoint-length-limit",
14381                             no_class,
14382                             &remote_hw_watchpoint_length_limit, _("\
14383 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14384 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14385 Specify \"unlimited\" to allow watchpoints of unlimited size."),
14386                             NULL, show_hardware_watchpoint_length_limit,
14387                             &remote_set_cmdlist, &remote_show_cmdlist);
14388   add_setshow_zuinteger_unlimited_cmd ("hardware-breakpoint-limit", no_class,
14389                             &remote_hw_breakpoint_limit, _("\
14390 Set the maximum number of target hardware breakpoints."), _("\
14391 Show the maximum number of target hardware breakpoints."), _("\
14392 Specify \"unlimited\" for unlimited hardware breakpoints."),
14393                             NULL, show_hardware_breakpoint_limit,
14394                             &remote_set_cmdlist, &remote_show_cmdlist);
14395
14396   add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure,
14397                              &remote_address_size, _("\
14398 Set the maximum size of the address (in bits) in a memory packet."), _("\
14399 Show the maximum size of the address (in bits) in a memory packet."), NULL,
14400                              NULL,
14401                              NULL, /* FIXME: i18n: */
14402                              &setlist, &showlist);
14403
14404   init_all_packet_configs ();
14405
14406   add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
14407                          "X", "binary-download", 1);
14408
14409   add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
14410                          "vCont", "verbose-resume", 0);
14411
14412   add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
14413                          "QPassSignals", "pass-signals", 0);
14414
14415   add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls],
14416                          "QCatchSyscalls", "catch-syscalls", 0);
14417
14418   add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
14419                          "QProgramSignals", "program-signals", 0);
14420
14421   add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir],
14422                          "QSetWorkingDir", "set-working-dir", 0);
14423
14424   add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell],
14425                          "QStartupWithShell", "startup-with-shell", 0);
14426
14427   add_packet_config_cmd (&remote_protocol_packets
14428                          [PACKET_QEnvironmentHexEncoded],
14429                          "QEnvironmentHexEncoded", "environment-hex-encoded",
14430                          0);
14431
14432   add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset],
14433                          "QEnvironmentReset", "environment-reset",
14434                          0);
14435
14436   add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset],
14437                          "QEnvironmentUnset", "environment-unset",
14438                          0);
14439
14440   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
14441                          "qSymbol", "symbol-lookup", 0);
14442
14443   add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
14444                          "P", "set-register", 1);
14445
14446   add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
14447                          "p", "fetch-register", 1);
14448
14449   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
14450                          "Z0", "software-breakpoint", 0);
14451
14452   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
14453                          "Z1", "hardware-breakpoint", 0);
14454
14455   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
14456                          "Z2", "write-watchpoint", 0);
14457
14458   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
14459                          "Z3", "read-watchpoint", 0);
14460
14461   add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
14462                          "Z4", "access-watchpoint", 0);
14463
14464   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
14465                          "qXfer:auxv:read", "read-aux-vector", 0);
14466
14467   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
14468                          "qXfer:exec-file:read", "pid-to-exec-file", 0);
14469
14470   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
14471                          "qXfer:features:read", "target-features", 0);
14472
14473   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
14474                          "qXfer:libraries:read", "library-info", 0);
14475
14476   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
14477                          "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14478
14479   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
14480                          "qXfer:memory-map:read", "memory-map", 0);
14481
14482   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
14483                          "qXfer:spu:read", "read-spu-object", 0);
14484
14485   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
14486                          "qXfer:spu:write", "write-spu-object", 0);
14487
14488   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
14489                         "qXfer:osdata:read", "osdata", 0);
14490
14491   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
14492                          "qXfer:threads:read", "threads", 0);
14493
14494   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
14495                          "qXfer:siginfo:read", "read-siginfo-object", 0);
14496
14497   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
14498                          "qXfer:siginfo:write", "write-siginfo-object", 0);
14499
14500   add_packet_config_cmd
14501     (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
14502      "qXfer:traceframe-info:read", "traceframe-info", 0);
14503
14504   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
14505                          "qXfer:uib:read", "unwind-info-block", 0);
14506
14507   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
14508                          "qGetTLSAddr", "get-thread-local-storage-address",
14509                          0);
14510
14511   add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
14512                          "qGetTIBAddr", "get-thread-information-block-address",
14513                          0);
14514
14515   add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
14516                          "bc", "reverse-continue", 0);
14517
14518   add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
14519                          "bs", "reverse-step", 0);
14520
14521   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
14522                          "qSupported", "supported-packets", 0);
14523
14524   add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
14525                          "qSearch:memory", "search-memory", 0);
14526
14527   add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
14528                          "qTStatus", "trace-status", 0);
14529
14530   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
14531                          "vFile:setfs", "hostio-setfs", 0);
14532
14533   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
14534                          "vFile:open", "hostio-open", 0);
14535
14536   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
14537                          "vFile:pread", "hostio-pread", 0);
14538
14539   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
14540                          "vFile:pwrite", "hostio-pwrite", 0);
14541
14542   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
14543                          "vFile:close", "hostio-close", 0);
14544
14545   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
14546                          "vFile:unlink", "hostio-unlink", 0);
14547
14548   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
14549                          "vFile:readlink", "hostio-readlink", 0);
14550
14551   add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
14552                          "vFile:fstat", "hostio-fstat", 0);
14553
14554   add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
14555                          "vAttach", "attach", 0);
14556
14557   add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
14558                          "vRun", "run", 0);
14559
14560   add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
14561                          "QStartNoAckMode", "noack", 0);
14562
14563   add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
14564                          "vKill", "kill", 0);
14565
14566   add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
14567                          "qAttached", "query-attached", 0);
14568
14569   add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
14570                          "ConditionalTracepoints",
14571                          "conditional-tracepoints", 0);
14572
14573   add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
14574                          "ConditionalBreakpoints",
14575                          "conditional-breakpoints", 0);
14576
14577   add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
14578                          "BreakpointCommands",
14579                          "breakpoint-commands", 0);
14580
14581   add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
14582                          "FastTracepoints", "fast-tracepoints", 0);
14583
14584   add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
14585                          "TracepointSource", "TracepointSource", 0);
14586
14587   add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
14588                          "QAllow", "allow", 0);
14589
14590   add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
14591                          "StaticTracepoints", "static-tracepoints", 0);
14592
14593   add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
14594                          "InstallInTrace", "install-in-trace", 0);
14595
14596   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
14597                          "qXfer:statictrace:read", "read-sdata-object", 0);
14598
14599   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
14600                          "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14601
14602   add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
14603                          "QDisableRandomization", "disable-randomization", 0);
14604
14605   add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
14606                          "QAgent", "agent", 0);
14607
14608   add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
14609                          "QTBuffer:size", "trace-buffer-size", 0);
14610
14611   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
14612        "Qbtrace:off", "disable-btrace", 0);
14613
14614   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
14615        "Qbtrace:bts", "enable-btrace-bts", 0);
14616
14617   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
14618        "Qbtrace:pt", "enable-btrace-pt", 0);
14619
14620   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
14621        "qXfer:btrace", "read-btrace", 0);
14622
14623   add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
14624        "qXfer:btrace-conf", "read-btrace-conf", 0);
14625
14626   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
14627        "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14628
14629   add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature],
14630        "multiprocess-feature", "multiprocess-feature", 0);
14631
14632   add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
14633                          "swbreak-feature", "swbreak-feature", 0);
14634
14635   add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
14636                          "hwbreak-feature", "hwbreak-feature", 0);
14637
14638   add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
14639                          "fork-event-feature", "fork-event-feature", 0);
14640
14641   add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
14642                          "vfork-event-feature", "vfork-event-feature", 0);
14643
14644   add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
14645        "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14646
14647   add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported],
14648                          "vContSupported", "verbose-resume-supported", 0);
14649
14650   add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature],
14651                          "exec-event-feature", "exec-event-feature", 0);
14652
14653   add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC],
14654                          "vCtrlC", "ctrl-c", 0);
14655
14656   add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents],
14657                          "QThreadEvents", "thread-events", 0);
14658
14659   add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
14660                          "N stop reply", "no-resumed-stop-reply", 0);
14661
14662   /* Assert that we've registered "set remote foo-packet" commands
14663      for all packet configs.  */
14664   {
14665     int i;
14666
14667     for (i = 0; i < PACKET_MAX; i++)
14668       {
14669         /* Ideally all configs would have a command associated.  Some
14670            still don't though.  */
14671         int excepted;
14672
14673         switch (i)
14674           {
14675           case PACKET_QNonStop:
14676           case PACKET_EnableDisableTracepoints_feature:
14677           case PACKET_tracenz_feature:
14678           case PACKET_DisconnectedTracing_feature:
14679           case PACKET_augmented_libraries_svr4_read_feature:
14680           case PACKET_qCRC:
14681             /* Additions to this list need to be well justified:
14682                pre-existing packets are OK; new packets are not.  */
14683             excepted = 1;
14684             break;
14685           default:
14686             excepted = 0;
14687             break;
14688           }
14689
14690         /* This catches both forgetting to add a config command, and
14691            forgetting to remove a packet from the exception list.  */
14692         gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
14693       }
14694   }
14695
14696   /* Keep the old ``set remote Z-packet ...'' working.  Each individual
14697      Z sub-packet has its own set and show commands, but users may
14698      have sets to this variable in their .gdbinit files (or in their
14699      documentation).  */
14700   add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
14701                                 &remote_Z_packet_detect, _("\
14702 Set use of remote protocol `Z' packets."), _("\
14703 Show use of remote protocol `Z' packets."), _("\
14704 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14705 packets."),
14706                                 set_remote_protocol_Z_packet_cmd,
14707                                 show_remote_protocol_Z_packet_cmd,
14708                                 /* FIXME: i18n: Use of remote protocol
14709                                    `Z' packets is %s.  */
14710                                 &remote_set_cmdlist, &remote_show_cmdlist);
14711
14712   add_prefix_cmd ("remote", class_files, remote_command, _("\
14713 Manipulate files on the remote system.\n\
14714 Transfer files to and from the remote target system."),
14715                   &remote_cmdlist, "remote ",
14716                   0 /* allow-unknown */, &cmdlist);
14717
14718   add_cmd ("put", class_files, remote_put_command,
14719            _("Copy a local file to the remote system."),
14720            &remote_cmdlist);
14721
14722   add_cmd ("get", class_files, remote_get_command,
14723            _("Copy a remote file to the local system."),
14724            &remote_cmdlist);
14725
14726   add_cmd ("delete", class_files, remote_delete_command,
14727            _("Delete a remote file."),
14728            &remote_cmdlist);
14729
14730   add_setshow_string_noescape_cmd ("exec-file", class_files,
14731                                    &remote_exec_file_var, _("\
14732 Set the remote pathname for \"run\"."), _("\
14733 Show the remote pathname for \"run\"."), NULL,
14734                                    set_remote_exec_file,
14735                                    show_remote_exec_file,
14736                                    &remote_set_cmdlist,
14737                                    &remote_show_cmdlist);
14738
14739   add_setshow_boolean_cmd ("range-stepping", class_run,
14740                            &use_range_stepping, _("\
14741 Enable or disable range stepping."), _("\
14742 Show whether target-assisted range stepping is enabled."), _("\
14743 If on, and the target supports it, when stepping a source line, GDB\n\
14744 tells the target to step the corresponding range of addresses itself instead\n\
14745 of issuing multiple single-steps.  This speeds up source level\n\
14746 stepping.  If off, GDB always issues single-steps, even if range\n\
14747 stepping is supported by the target.  The default is on."),
14748                            set_range_stepping,
14749                            show_range_stepping,
14750                            &setlist,
14751                            &showlist);
14752
14753   add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\
14754 Set watchdog timer."), _("\
14755 Show watchdog timer."), _("\
14756 When non-zero, this timeout is used instead of waiting forever for a target\n\
14757 to finish a low-level step or continue operation.  If the specified amount\n\
14758 of time passes without a response from the target, an error occurs."),
14759                             NULL,
14760                             show_watchdog,
14761                             &setlist, &showlist);
14762
14763   /* Eventually initialize fileio.  See fileio.c */
14764   initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
14765 }