Document linespec/explicit locations & completion improvements (manual + NEWS)
[deliverable/binutils-gdb.git] / gdb / remote.c
1 /* Remote target communications for serial-line targets in custom GDB protocol
2
3 Copyright (C) 1988-2017 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 "terminal.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 "observer.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 "filestuff.h"
46 #include "rsp-low.h"
47 #include "disasm.h"
48 #include "location.h"
49
50 #include "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 "agent.h"
72 #include "btrace.h"
73 #include "record-btrace.h"
74 #include <algorithm>
75 #include "common/scoped_restore.h"
76 #include "environ.h"
77 #include "common/byte-vector.h"
78
79 /* Per-program-space data key. */
80 static const struct program_space_data *remote_pspace_data;
81
82 /* The variable registered as the control variable used by the
83 remote exec-file commands. While the remote exec-file setting is
84 per-program-space, the set/show machinery uses this as the
85 location of the remote exec-file value. */
86 static char *remote_exec_file_var;
87
88 /* The size to align memory write packets, when practical. The protocol
89 does not guarantee any alignment, and gdb will generate short
90 writes and unaligned writes, but even as a best-effort attempt this
91 can improve bulk transfers. For instance, if a write is misaligned
92 relative to the target's data bus, the stub may need to make an extra
93 round trip fetching data from the target. This doesn't make a
94 huge difference, but it's easy to do, so we try to be helpful.
95
96 The alignment chosen is arbitrary; usually data bus width is
97 important here, not the possibly larger cache line size. */
98 enum { REMOTE_ALIGN_WRITES = 16 };
99
100 /* Prototypes for local functions. */
101 static int getpkt_sane (char **buf, long *sizeof_buf, int forever);
102 static int getpkt_or_notif_sane (char **buf, long *sizeof_buf,
103 int forever, int *is_notif);
104
105 static void remote_files_info (struct target_ops *ignore);
106
107 static void remote_prepare_to_store (struct target_ops *self,
108 struct regcache *regcache);
109
110 static void remote_open_1 (const char *, int, struct target_ops *,
111 int extended_p);
112
113 static void remote_close (struct target_ops *self);
114
115 struct remote_state;
116
117 static int remote_vkill (int pid, struct remote_state *rs);
118
119 static void remote_kill_k (void);
120
121 static void remote_mourn (struct target_ops *ops);
122
123 static void extended_remote_restart (void);
124
125 static void remote_send (char **buf, long *sizeof_buf_p);
126
127 static int readchar (int timeout);
128
129 static void remote_serial_write (const char *str, int len);
130
131 static void remote_kill (struct target_ops *ops);
132
133 static int remote_can_async_p (struct target_ops *);
134
135 static int remote_is_async_p (struct target_ops *);
136
137 static void remote_async (struct target_ops *ops, int enable);
138
139 static void remote_thread_events (struct target_ops *ops, int enable);
140
141 static void interrupt_query (void);
142
143 static void set_general_thread (ptid_t ptid);
144 static void set_continue_thread (ptid_t ptid);
145
146 static void get_offsets (void);
147
148 static void skip_frame (void);
149
150 static long read_frame (char **buf_p, long *sizeof_buf);
151
152 static int hexnumlen (ULONGEST num);
153
154 static void init_remote_ops (void);
155
156 static void init_extended_remote_ops (void);
157
158 static void remote_stop (struct target_ops *self, ptid_t);
159
160 static int stubhex (int ch);
161
162 static int hexnumstr (char *, ULONGEST);
163
164 static int hexnumnstr (char *, ULONGEST, int);
165
166 static CORE_ADDR remote_address_masked (CORE_ADDR);
167
168 static void print_packet (const char *);
169
170 static int stub_unpack_int (char *buff, int fieldlength);
171
172 static ptid_t remote_current_thread (ptid_t oldptid);
173
174 static int putpkt_binary (const char *buf, int cnt);
175
176 static void check_binary_download (CORE_ADDR addr);
177
178 struct packet_config;
179
180 static void show_packet_config_cmd (struct packet_config *config);
181
182 static void show_remote_protocol_packet_cmd (struct ui_file *file,
183 int from_tty,
184 struct cmd_list_element *c,
185 const char *value);
186
187 static char *write_ptid (char *buf, const char *endbuf, ptid_t ptid);
188 static ptid_t read_ptid (const char *buf, const char **obuf);
189
190 static void remote_set_permissions (struct target_ops *self);
191
192 static int remote_get_trace_status (struct target_ops *self,
193 struct trace_status *ts);
194
195 static int remote_upload_tracepoints (struct target_ops *self,
196 struct uploaded_tp **utpp);
197
198 static int remote_upload_trace_state_variables (struct target_ops *self,
199 struct uploaded_tsv **utsvp);
200
201 static void remote_query_supported (void);
202
203 static void remote_check_symbols (void);
204
205 struct stop_reply;
206 static void stop_reply_xfree (struct stop_reply *);
207 static void remote_parse_stop_reply (char *, struct stop_reply *);
208 static void push_stop_reply (struct stop_reply *);
209 static void discard_pending_stop_replies_in_queue (struct remote_state *);
210 static int peek_stop_reply (ptid_t ptid);
211
212 struct threads_listing_context;
213 static void remove_new_fork_children (struct threads_listing_context *);
214
215 static void remote_async_inferior_event_handler (gdb_client_data);
216
217 static void remote_terminal_ours (struct target_ops *self);
218
219 static int remote_read_description_p (struct target_ops *target);
220
221 static void remote_console_output (char *msg);
222
223 static int remote_supports_cond_breakpoints (struct target_ops *self);
224
225 static int remote_can_run_breakpoint_commands (struct target_ops *self);
226
227 static void remote_btrace_reset (void);
228
229 static void remote_btrace_maybe_reopen (void);
230
231 static int stop_reply_queue_length (void);
232
233 static void readahead_cache_invalidate (void);
234
235 static void remote_unpush_and_throw (void);
236
237 static struct remote_state *get_remote_state (void);
238
239 /* For "remote". */
240
241 static struct cmd_list_element *remote_cmdlist;
242
243 /* For "set remote" and "show remote". */
244
245 static struct cmd_list_element *remote_set_cmdlist;
246 static struct cmd_list_element *remote_show_cmdlist;
247
248 /* Stub vCont actions support.
249
250 Each field is a boolean flag indicating whether the stub reports
251 support for the corresponding action. */
252
253 struct vCont_action_support
254 {
255 /* vCont;t */
256 int t;
257
258 /* vCont;r */
259 int r;
260
261 /* vCont;s */
262 int s;
263
264 /* vCont;S */
265 int S;
266 };
267
268 /* Controls whether GDB is willing to use range stepping. */
269
270 static int use_range_stepping = 1;
271
272 #define OPAQUETHREADBYTES 8
273
274 /* a 64 bit opaque identifier */
275 typedef unsigned char threadref[OPAQUETHREADBYTES];
276
277 /* About this many threadisds fit in a packet. */
278
279 #define MAXTHREADLISTRESULTS 32
280
281 /* The max number of chars in debug output. The rest of chars are
282 omitted. */
283
284 #define REMOTE_DEBUG_MAX_CHAR 512
285
286 /* Data for the vFile:pread readahead cache. */
287
288 struct readahead_cache
289 {
290 /* The file descriptor for the file that is being cached. -1 if the
291 cache is invalid. */
292 int fd;
293
294 /* The offset into the file that the cache buffer corresponds
295 to. */
296 ULONGEST offset;
297
298 /* The buffer holding the cache contents. */
299 gdb_byte *buf;
300 /* The buffer's size. We try to read as much as fits into a packet
301 at a time. */
302 size_t bufsize;
303
304 /* Cache hit and miss counters. */
305 ULONGEST hit_count;
306 ULONGEST miss_count;
307 };
308
309 /* Description of the remote protocol state for the currently
310 connected target. This is per-target state, and independent of the
311 selected architecture. */
312
313 struct remote_state
314 {
315 /* A buffer to use for incoming packets, and its current size. The
316 buffer is grown dynamically for larger incoming packets.
317 Outgoing packets may also be constructed in this buffer.
318 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
319 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
320 packets. */
321 char *buf;
322 long buf_size;
323
324 /* True if we're going through initial connection setup (finding out
325 about the remote side's threads, relocating symbols, etc.). */
326 int starting_up;
327
328 /* If we negotiated packet size explicitly (and thus can bypass
329 heuristics for the largest packet size that will not overflow
330 a buffer in the stub), this will be set to that packet size.
331 Otherwise zero, meaning to use the guessed size. */
332 long explicit_packet_size;
333
334 /* remote_wait is normally called when the target is running and
335 waits for a stop reply packet. But sometimes we need to call it
336 when the target is already stopped. We can send a "?" packet
337 and have remote_wait read the response. Or, if we already have
338 the response, we can stash it in BUF and tell remote_wait to
339 skip calling getpkt. This flag is set when BUF contains a
340 stop reply packet and the target is not waiting. */
341 int cached_wait_status;
342
343 /* True, if in no ack mode. That is, neither GDB nor the stub will
344 expect acks from each other. The connection is assumed to be
345 reliable. */
346 int noack_mode;
347
348 /* True if we're connected in extended remote mode. */
349 int extended;
350
351 /* True if we resumed the target and we're waiting for the target to
352 stop. In the mean time, we can't start another command/query.
353 The remote server wouldn't be ready to process it, so we'd
354 timeout waiting for a reply that would never come and eventually
355 we'd close the connection. This can happen in asynchronous mode
356 because we allow GDB commands while the target is running. */
357 int waiting_for_stop_reply;
358
359 /* The status of the stub support for the various vCont actions. */
360 struct vCont_action_support supports_vCont;
361
362 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
363 responded to that. */
364 int ctrlc_pending_p;
365
366 /* True if we saw a Ctrl-C while reading or writing from/to the
367 remote descriptor. At that point it is not safe to send a remote
368 interrupt packet, so we instead remember we saw the Ctrl-C and
369 process it once we're done with sending/receiving the current
370 packet, which should be shortly. If however that takes too long,
371 and the user presses Ctrl-C again, we offer to disconnect. */
372 int got_ctrlc_during_io;
373
374 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
375 remote_open knows that we don't have a file open when the program
376 starts. */
377 struct serial *remote_desc;
378
379 /* These are the threads which we last sent to the remote system. The
380 TID member will be -1 for all or -2 for not sent yet. */
381 ptid_t general_thread;
382 ptid_t continue_thread;
383
384 /* This is the traceframe which we last selected on the remote system.
385 It will be -1 if no traceframe is selected. */
386 int remote_traceframe_number;
387
388 char *last_pass_packet;
389
390 /* The last QProgramSignals packet sent to the target. We bypass
391 sending a new program signals list down to the target if the new
392 packet is exactly the same as the last we sent. IOW, we only let
393 the target know about program signals list changes. */
394 char *last_program_signals_packet;
395
396 enum gdb_signal last_sent_signal;
397
398 int last_sent_step;
399
400 /* The execution direction of the last resume we got. */
401 enum exec_direction_kind last_resume_exec_dir;
402
403 char *finished_object;
404 char *finished_annex;
405 ULONGEST finished_offset;
406
407 /* Should we try the 'ThreadInfo' query packet?
408
409 This variable (NOT available to the user: auto-detect only!)
410 determines whether GDB will use the new, simpler "ThreadInfo"
411 query or the older, more complex syntax for thread queries.
412 This is an auto-detect variable (set to true at each connect,
413 and set to false when the target fails to recognize it). */
414 int use_threadinfo_query;
415 int use_threadextra_query;
416
417 threadref echo_nextthread;
418 threadref nextthread;
419 threadref resultthreadlist[MAXTHREADLISTRESULTS];
420
421 /* The state of remote notification. */
422 struct remote_notif_state *notif_state;
423
424 /* The branch trace configuration. */
425 struct btrace_config btrace_config;
426
427 /* The argument to the last "vFile:setfs:" packet we sent, used
428 to avoid sending repeated unnecessary "vFile:setfs:" packets.
429 Initialized to -1 to indicate that no "vFile:setfs:" packet
430 has yet been sent. */
431 int fs_pid;
432
433 /* A readahead cache for vFile:pread. Often, reading a binary
434 involves a sequence of small reads. E.g., when parsing an ELF
435 file. A readahead cache helps mostly the case of remote
436 debugging on a connection with higher latency, due to the
437 request/reply nature of the RSP. We only cache data for a single
438 file descriptor at a time. */
439 struct readahead_cache readahead_cache;
440 };
441
442 /* Private data that we'll store in (struct thread_info)->private. */
443 struct private_thread_info
444 {
445 char *extra;
446 char *name;
447 int core;
448
449 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
450 sequence of bytes. */
451 gdb::byte_vector *thread_handle;
452
453 /* Whether the target stopped for a breakpoint/watchpoint. */
454 enum target_stop_reason stop_reason;
455
456 /* This is set to the data address of the access causing the target
457 to stop for a watchpoint. */
458 CORE_ADDR watch_data_address;
459
460 /* Fields used by the vCont action coalescing implemented in
461 remote_resume / remote_commit_resume. remote_resume stores each
462 thread's last resume request in these fields, so that a later
463 remote_commit_resume knows which is the proper action for this
464 thread to include in the vCont packet. */
465
466 /* True if the last target_resume call for this thread was a step
467 request, false if a continue request. */
468 int last_resume_step;
469
470 /* The signal specified in the last target_resume call for this
471 thread. */
472 enum gdb_signal last_resume_sig;
473
474 /* Whether this thread was already vCont-resumed on the remote
475 side. */
476 int vcont_resumed;
477 };
478
479 static void
480 free_private_thread_info (struct private_thread_info *info)
481 {
482 xfree (info->extra);
483 xfree (info->name);
484 delete info->thread_handle;
485 xfree (info);
486 }
487
488 /* This data could be associated with a target, but we do not always
489 have access to the current target when we need it, so for now it is
490 static. This will be fine for as long as only one target is in use
491 at a time. */
492 static struct remote_state *remote_state;
493
494 static struct remote_state *
495 get_remote_state_raw (void)
496 {
497 return remote_state;
498 }
499
500 /* Allocate a new struct remote_state with xmalloc, initialize it, and
501 return it. */
502
503 static struct remote_state *
504 new_remote_state (void)
505 {
506 struct remote_state *result = XCNEW (struct remote_state);
507
508 /* The default buffer size is unimportant; it will be expanded
509 whenever a larger buffer is needed. */
510 result->buf_size = 400;
511 result->buf = (char *) xmalloc (result->buf_size);
512 result->remote_traceframe_number = -1;
513 result->last_sent_signal = GDB_SIGNAL_0;
514 result->last_resume_exec_dir = EXEC_FORWARD;
515 result->fs_pid = -1;
516
517 return result;
518 }
519
520 /* Description of the remote protocol for a given architecture. */
521
522 struct packet_reg
523 {
524 long offset; /* Offset into G packet. */
525 long regnum; /* GDB's internal register number. */
526 LONGEST pnum; /* Remote protocol register number. */
527 int in_g_packet; /* Always part of G packet. */
528 /* long size in bytes; == register_size (target_gdbarch (), regnum);
529 at present. */
530 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
531 at present. */
532 };
533
534 struct remote_arch_state
535 {
536 /* Description of the remote protocol registers. */
537 long sizeof_g_packet;
538
539 /* Description of the remote protocol registers indexed by REGNUM
540 (making an array gdbarch_num_regs in size). */
541 struct packet_reg *regs;
542
543 /* This is the size (in chars) of the first response to the ``g''
544 packet. It is used as a heuristic when determining the maximum
545 size of memory-read and memory-write packets. A target will
546 typically only reserve a buffer large enough to hold the ``g''
547 packet. The size does not include packet overhead (headers and
548 trailers). */
549 long actual_register_packet_size;
550
551 /* This is the maximum size (in chars) of a non read/write packet.
552 It is also used as a cap on the size of read/write packets. */
553 long remote_packet_size;
554 };
555
556 /* Utility: generate error from an incoming stub packet. */
557 static void
558 trace_error (char *buf)
559 {
560 if (*buf++ != 'E')
561 return; /* not an error msg */
562 switch (*buf)
563 {
564 case '1': /* malformed packet error */
565 if (*++buf == '0') /* general case: */
566 error (_("remote.c: error in outgoing packet."));
567 else
568 error (_("remote.c: error in outgoing packet at field #%ld."),
569 strtol (buf, NULL, 16));
570 default:
571 error (_("Target returns error code '%s'."), buf);
572 }
573 }
574
575 /* Utility: wait for reply from stub, while accepting "O" packets. */
576
577 static char *
578 remote_get_noisy_reply ()
579 {
580 struct remote_state *rs = get_remote_state ();
581
582 do /* Loop on reply from remote stub. */
583 {
584 char *buf;
585
586 QUIT; /* Allow user to bail out with ^C. */
587 getpkt (&rs->buf, &rs->buf_size, 0);
588 buf = rs->buf;
589 if (buf[0] == 'E')
590 trace_error (buf);
591 else if (startswith (buf, "qRelocInsn:"))
592 {
593 ULONGEST ul;
594 CORE_ADDR from, to, org_to;
595 const char *p, *pp;
596 int adjusted_size = 0;
597 int relocated = 0;
598
599 p = buf + strlen ("qRelocInsn:");
600 pp = unpack_varlen_hex (p, &ul);
601 if (*pp != ';')
602 error (_("invalid qRelocInsn packet: %s"), buf);
603 from = ul;
604
605 p = pp + 1;
606 unpack_varlen_hex (p, &ul);
607 to = ul;
608
609 org_to = to;
610
611 TRY
612 {
613 gdbarch_relocate_instruction (target_gdbarch (), &to, from);
614 relocated = 1;
615 }
616 CATCH (ex, RETURN_MASK_ALL)
617 {
618 if (ex.error == MEMORY_ERROR)
619 {
620 /* Propagate memory errors silently back to the
621 target. The stub may have limited the range of
622 addresses we can write to, for example. */
623 }
624 else
625 {
626 /* Something unexpectedly bad happened. Be verbose
627 so we can tell what, and propagate the error back
628 to the stub, so it doesn't get stuck waiting for
629 a response. */
630 exception_fprintf (gdb_stderr, ex,
631 _("warning: relocating instruction: "));
632 }
633 putpkt ("E01");
634 }
635 END_CATCH
636
637 if (relocated)
638 {
639 adjusted_size = to - org_to;
640
641 xsnprintf (buf, rs->buf_size, "qRelocInsn:%x", adjusted_size);
642 putpkt (buf);
643 }
644 }
645 else if (buf[0] == 'O' && buf[1] != 'K')
646 remote_console_output (buf + 1); /* 'O' message from stub */
647 else
648 return buf; /* Here's the actual reply. */
649 }
650 while (1);
651 }
652
653 /* Handle for retreving the remote protocol data from gdbarch. */
654 static struct gdbarch_data *remote_gdbarch_data_handle;
655
656 static struct remote_arch_state *
657 get_remote_arch_state (struct gdbarch *gdbarch)
658 {
659 gdb_assert (gdbarch != NULL);
660 return ((struct remote_arch_state *)
661 gdbarch_data (gdbarch, remote_gdbarch_data_handle));
662 }
663
664 /* Fetch the global remote target state. */
665
666 static struct remote_state *
667 get_remote_state (void)
668 {
669 /* Make sure that the remote architecture state has been
670 initialized, because doing so might reallocate rs->buf. Any
671 function which calls getpkt also needs to be mindful of changes
672 to rs->buf, but this call limits the number of places which run
673 into trouble. */
674 get_remote_arch_state (target_gdbarch ());
675
676 return get_remote_state_raw ();
677 }
678
679 /* Cleanup routine for the remote module's pspace data. */
680
681 static void
682 remote_pspace_data_cleanup (struct program_space *pspace, void *arg)
683 {
684 char *remote_exec_file = (char *) arg;
685
686 xfree (remote_exec_file);
687 }
688
689 /* Fetch the remote exec-file from the current program space. */
690
691 static const char *
692 get_remote_exec_file (void)
693 {
694 char *remote_exec_file;
695
696 remote_exec_file
697 = (char *) program_space_data (current_program_space,
698 remote_pspace_data);
699 if (remote_exec_file == NULL)
700 return "";
701
702 return remote_exec_file;
703 }
704
705 /* Set the remote exec file for PSPACE. */
706
707 static void
708 set_pspace_remote_exec_file (struct program_space *pspace,
709 char *remote_exec_file)
710 {
711 char *old_file = (char *) program_space_data (pspace, remote_pspace_data);
712
713 xfree (old_file);
714 set_program_space_data (pspace, remote_pspace_data,
715 xstrdup (remote_exec_file));
716 }
717
718 /* The "set/show remote exec-file" set command hook. */
719
720 static void
721 set_remote_exec_file (const char *ignored, int from_tty,
722 struct cmd_list_element *c)
723 {
724 gdb_assert (remote_exec_file_var != NULL);
725 set_pspace_remote_exec_file (current_program_space, remote_exec_file_var);
726 }
727
728 /* The "set/show remote exec-file" show command hook. */
729
730 static void
731 show_remote_exec_file (struct ui_file *file, int from_tty,
732 struct cmd_list_element *cmd, const char *value)
733 {
734 fprintf_filtered (file, "%s\n", remote_exec_file_var);
735 }
736
737 static int
738 compare_pnums (const void *lhs_, const void *rhs_)
739 {
740 const struct packet_reg * const *lhs
741 = (const struct packet_reg * const *) lhs_;
742 const struct packet_reg * const *rhs
743 = (const struct packet_reg * const *) rhs_;
744
745 if ((*lhs)->pnum < (*rhs)->pnum)
746 return -1;
747 else if ((*lhs)->pnum == (*rhs)->pnum)
748 return 0;
749 else
750 return 1;
751 }
752
753 static int
754 map_regcache_remote_table (struct gdbarch *gdbarch, struct packet_reg *regs)
755 {
756 int regnum, num_remote_regs, offset;
757 struct packet_reg **remote_regs;
758
759 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
760 {
761 struct packet_reg *r = &regs[regnum];
762
763 if (register_size (gdbarch, regnum) == 0)
764 /* Do not try to fetch zero-sized (placeholder) registers. */
765 r->pnum = -1;
766 else
767 r->pnum = gdbarch_remote_register_number (gdbarch, regnum);
768
769 r->regnum = regnum;
770 }
771
772 /* Define the g/G packet format as the contents of each register
773 with a remote protocol number, in order of ascending protocol
774 number. */
775
776 remote_regs = XALLOCAVEC (struct packet_reg *, gdbarch_num_regs (gdbarch));
777 for (num_remote_regs = 0, regnum = 0;
778 regnum < gdbarch_num_regs (gdbarch);
779 regnum++)
780 if (regs[regnum].pnum != -1)
781 remote_regs[num_remote_regs++] = &regs[regnum];
782
783 qsort (remote_regs, num_remote_regs, sizeof (struct packet_reg *),
784 compare_pnums);
785
786 for (regnum = 0, offset = 0; regnum < num_remote_regs; regnum++)
787 {
788 remote_regs[regnum]->in_g_packet = 1;
789 remote_regs[regnum]->offset = offset;
790 offset += register_size (gdbarch, remote_regs[regnum]->regnum);
791 }
792
793 return offset;
794 }
795
796 /* Given the architecture described by GDBARCH, return the remote
797 protocol register's number and the register's offset in the g/G
798 packets of GDB register REGNUM, in PNUM and POFFSET respectively.
799 If the target does not have a mapping for REGNUM, return false,
800 otherwise, return true. */
801
802 int
803 remote_register_number_and_offset (struct gdbarch *gdbarch, int regnum,
804 int *pnum, int *poffset)
805 {
806 gdb_assert (regnum < gdbarch_num_regs (gdbarch));
807
808 std::vector<packet_reg> regs (gdbarch_num_regs (gdbarch));
809
810 map_regcache_remote_table (gdbarch, regs.data ());
811
812 *pnum = regs[regnum].pnum;
813 *poffset = regs[regnum].offset;
814
815 return *pnum != -1;
816 }
817
818 static void *
819 init_remote_state (struct gdbarch *gdbarch)
820 {
821 struct remote_state *rs = get_remote_state_raw ();
822 struct remote_arch_state *rsa;
823
824 rsa = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct remote_arch_state);
825
826 /* Use the architecture to build a regnum<->pnum table, which will be
827 1:1 unless a feature set specifies otherwise. */
828 rsa->regs = GDBARCH_OBSTACK_CALLOC (gdbarch,
829 gdbarch_num_regs (gdbarch),
830 struct packet_reg);
831
832 /* Record the maximum possible size of the g packet - it may turn out
833 to be smaller. */
834 rsa->sizeof_g_packet = map_regcache_remote_table (gdbarch, rsa->regs);
835
836 /* Default maximum number of characters in a packet body. Many
837 remote stubs have a hardwired buffer size of 400 bytes
838 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
839 as the maximum packet-size to ensure that the packet and an extra
840 NUL character can always fit in the buffer. This stops GDB
841 trashing stubs that try to squeeze an extra NUL into what is
842 already a full buffer (As of 1999-12-04 that was most stubs). */
843 rsa->remote_packet_size = 400 - 1;
844
845 /* This one is filled in when a ``g'' packet is received. */
846 rsa->actual_register_packet_size = 0;
847
848 /* Should rsa->sizeof_g_packet needs more space than the
849 default, adjust the size accordingly. Remember that each byte is
850 encoded as two characters. 32 is the overhead for the packet
851 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
852 (``$NN:G...#NN'') is a better guess, the below has been padded a
853 little. */
854 if (rsa->sizeof_g_packet > ((rsa->remote_packet_size - 32) / 2))
855 rsa->remote_packet_size = (rsa->sizeof_g_packet * 2 + 32);
856
857 /* Make sure that the packet buffer is plenty big enough for
858 this architecture. */
859 if (rs->buf_size < rsa->remote_packet_size)
860 {
861 rs->buf_size = 2 * rsa->remote_packet_size;
862 rs->buf = (char *) xrealloc (rs->buf, rs->buf_size);
863 }
864
865 return rsa;
866 }
867
868 /* Return the current allowed size of a remote packet. This is
869 inferred from the current architecture, and should be used to
870 limit the length of outgoing packets. */
871 static long
872 get_remote_packet_size (void)
873 {
874 struct remote_state *rs = get_remote_state ();
875 remote_arch_state *rsa = get_remote_arch_state (target_gdbarch ());
876
877 if (rs->explicit_packet_size)
878 return rs->explicit_packet_size;
879
880 return rsa->remote_packet_size;
881 }
882
883 static struct packet_reg *
884 packet_reg_from_regnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
885 long regnum)
886 {
887 if (regnum < 0 && regnum >= gdbarch_num_regs (gdbarch))
888 return NULL;
889 else
890 {
891 struct packet_reg *r = &rsa->regs[regnum];
892
893 gdb_assert (r->regnum == regnum);
894 return r;
895 }
896 }
897
898 static struct packet_reg *
899 packet_reg_from_pnum (struct gdbarch *gdbarch, struct remote_arch_state *rsa,
900 LONGEST pnum)
901 {
902 int i;
903
904 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
905 {
906 struct packet_reg *r = &rsa->regs[i];
907
908 if (r->pnum == pnum)
909 return r;
910 }
911 return NULL;
912 }
913
914 static struct target_ops remote_ops;
915
916 static struct target_ops extended_remote_ops;
917
918 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
919 ``forever'' still use the normal timeout mechanism. This is
920 currently used by the ASYNC code to guarentee that target reads
921 during the initial connect always time-out. Once getpkt has been
922 modified to return a timeout indication and, in turn
923 remote_wait()/wait_for_inferior() have gained a timeout parameter
924 this can go away. */
925 static int wait_forever_enabled_p = 1;
926
927 /* Allow the user to specify what sequence to send to the remote
928 when he requests a program interruption: Although ^C is usually
929 what remote systems expect (this is the default, here), it is
930 sometimes preferable to send a break. On other systems such
931 as the Linux kernel, a break followed by g, which is Magic SysRq g
932 is required in order to interrupt the execution. */
933 const char interrupt_sequence_control_c[] = "Ctrl-C";
934 const char interrupt_sequence_break[] = "BREAK";
935 const char interrupt_sequence_break_g[] = "BREAK-g";
936 static const char *const interrupt_sequence_modes[] =
937 {
938 interrupt_sequence_control_c,
939 interrupt_sequence_break,
940 interrupt_sequence_break_g,
941 NULL
942 };
943 static const char *interrupt_sequence_mode = interrupt_sequence_control_c;
944
945 static void
946 show_interrupt_sequence (struct ui_file *file, int from_tty,
947 struct cmd_list_element *c,
948 const char *value)
949 {
950 if (interrupt_sequence_mode == interrupt_sequence_control_c)
951 fprintf_filtered (file,
952 _("Send the ASCII ETX character (Ctrl-c) "
953 "to the remote target to interrupt the "
954 "execution of the program.\n"));
955 else if (interrupt_sequence_mode == interrupt_sequence_break)
956 fprintf_filtered (file,
957 _("send a break signal to the remote target "
958 "to interrupt the execution of the program.\n"));
959 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
960 fprintf_filtered (file,
961 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
962 "the remote target to interrupt the execution "
963 "of Linux kernel.\n"));
964 else
965 internal_error (__FILE__, __LINE__,
966 _("Invalid value for interrupt_sequence_mode: %s."),
967 interrupt_sequence_mode);
968 }
969
970 /* This boolean variable specifies whether interrupt_sequence is sent
971 to the remote target when gdb connects to it.
972 This is mostly needed when you debug the Linux kernel: The Linux kernel
973 expects BREAK g which is Magic SysRq g for connecting gdb. */
974 static int interrupt_on_connect = 0;
975
976 /* This variable is used to implement the "set/show remotebreak" commands.
977 Since these commands are now deprecated in favor of "set/show remote
978 interrupt-sequence", it no longer has any effect on the code. */
979 static int remote_break;
980
981 static void
982 set_remotebreak (const char *args, int from_tty, struct cmd_list_element *c)
983 {
984 if (remote_break)
985 interrupt_sequence_mode = interrupt_sequence_break;
986 else
987 interrupt_sequence_mode = interrupt_sequence_control_c;
988 }
989
990 static void
991 show_remotebreak (struct ui_file *file, int from_tty,
992 struct cmd_list_element *c,
993 const char *value)
994 {
995 }
996
997 /* This variable sets the number of bits in an address that are to be
998 sent in a memory ("M" or "m") packet. Normally, after stripping
999 leading zeros, the entire address would be sent. This variable
1000 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1001 initial implementation of remote.c restricted the address sent in
1002 memory packets to ``host::sizeof long'' bytes - (typically 32
1003 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1004 address was never sent. Since fixing this bug may cause a break in
1005 some remote targets this variable is principly provided to
1006 facilitate backward compatibility. */
1007
1008 static unsigned int remote_address_size;
1009
1010 \f
1011 /* User configurable variables for the number of characters in a
1012 memory read/write packet. MIN (rsa->remote_packet_size,
1013 rsa->sizeof_g_packet) is the default. Some targets need smaller
1014 values (fifo overruns, et.al.) and some users need larger values
1015 (speed up transfers). The variables ``preferred_*'' (the user
1016 request), ``current_*'' (what was actually set) and ``forced_*''
1017 (Positive - a soft limit, negative - a hard limit). */
1018
1019 struct memory_packet_config
1020 {
1021 const char *name;
1022 long size;
1023 int fixed_p;
1024 };
1025
1026 /* The default max memory-write-packet-size. The 16k is historical.
1027 (It came from older GDB's using alloca for buffers and the
1028 knowledge (folklore?) that some hosts don't cope very well with
1029 large alloca calls.) */
1030 #define DEFAULT_MAX_MEMORY_PACKET_SIZE 16384
1031
1032 /* The minimum remote packet size for memory transfers. Ensures we
1033 can write at least one byte. */
1034 #define MIN_MEMORY_PACKET_SIZE 20
1035
1036 /* Compute the current size of a read/write packet. Since this makes
1037 use of ``actual_register_packet_size'' the computation is dynamic. */
1038
1039 static long
1040 get_memory_packet_size (struct memory_packet_config *config)
1041 {
1042 struct remote_state *rs = get_remote_state ();
1043 remote_arch_state *rsa = get_remote_arch_state (target_gdbarch ());
1044
1045 long what_they_get;
1046 if (config->fixed_p)
1047 {
1048 if (config->size <= 0)
1049 what_they_get = DEFAULT_MAX_MEMORY_PACKET_SIZE;
1050 else
1051 what_they_get = config->size;
1052 }
1053 else
1054 {
1055 what_they_get = get_remote_packet_size ();
1056 /* Limit the packet to the size specified by the user. */
1057 if (config->size > 0
1058 && what_they_get > config->size)
1059 what_they_get = config->size;
1060
1061 /* Limit it to the size of the targets ``g'' response unless we have
1062 permission from the stub to use a larger packet size. */
1063 if (rs->explicit_packet_size == 0
1064 && rsa->actual_register_packet_size > 0
1065 && what_they_get > rsa->actual_register_packet_size)
1066 what_they_get = rsa->actual_register_packet_size;
1067 }
1068 if (what_they_get < MIN_MEMORY_PACKET_SIZE)
1069 what_they_get = MIN_MEMORY_PACKET_SIZE;
1070
1071 /* Make sure there is room in the global buffer for this packet
1072 (including its trailing NUL byte). */
1073 if (rs->buf_size < what_they_get + 1)
1074 {
1075 rs->buf_size = 2 * what_they_get;
1076 rs->buf = (char *) xrealloc (rs->buf, 2 * what_they_get);
1077 }
1078
1079 return what_they_get;
1080 }
1081
1082 /* Update the size of a read/write packet. If they user wants
1083 something really big then do a sanity check. */
1084
1085 static void
1086 set_memory_packet_size (const char *args, struct memory_packet_config *config)
1087 {
1088 int fixed_p = config->fixed_p;
1089 long size = config->size;
1090
1091 if (args == NULL)
1092 error (_("Argument required (integer, `fixed' or `limited')."));
1093 else if (strcmp (args, "hard") == 0
1094 || strcmp (args, "fixed") == 0)
1095 fixed_p = 1;
1096 else if (strcmp (args, "soft") == 0
1097 || strcmp (args, "limit") == 0)
1098 fixed_p = 0;
1099 else
1100 {
1101 char *end;
1102
1103 size = strtoul (args, &end, 0);
1104 if (args == end)
1105 error (_("Invalid %s (bad syntax)."), config->name);
1106
1107 /* Instead of explicitly capping the size of a packet to or
1108 disallowing it, the user is allowed to set the size to
1109 something arbitrarily large. */
1110 }
1111
1112 /* So that the query shows the correct value. */
1113 if (size <= 0)
1114 size = DEFAULT_MAX_MEMORY_PACKET_SIZE;
1115
1116 /* Extra checks? */
1117 if (fixed_p && !config->fixed_p)
1118 {
1119 if (! query (_("The target may not be able to correctly handle a %s\n"
1120 "of %ld bytes. Change the packet size? "),
1121 config->name, size))
1122 error (_("Packet size not changed."));
1123 }
1124 /* Update the config. */
1125 config->fixed_p = fixed_p;
1126 config->size = size;
1127 }
1128
1129 static void
1130 show_memory_packet_size (struct memory_packet_config *config)
1131 {
1132 printf_filtered (_("The %s is %ld. "), config->name, config->size);
1133 if (config->fixed_p)
1134 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1135 get_memory_packet_size (config));
1136 else
1137 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1138 get_memory_packet_size (config));
1139 }
1140
1141 static struct memory_packet_config memory_write_packet_config =
1142 {
1143 "memory-write-packet-size",
1144 };
1145
1146 static void
1147 set_memory_write_packet_size (const char *args, int from_tty)
1148 {
1149 set_memory_packet_size (args, &memory_write_packet_config);
1150 }
1151
1152 static void
1153 show_memory_write_packet_size (const char *args, int from_tty)
1154 {
1155 show_memory_packet_size (&memory_write_packet_config);
1156 }
1157
1158 static long
1159 get_memory_write_packet_size (void)
1160 {
1161 return get_memory_packet_size (&memory_write_packet_config);
1162 }
1163
1164 static struct memory_packet_config memory_read_packet_config =
1165 {
1166 "memory-read-packet-size",
1167 };
1168
1169 static void
1170 set_memory_read_packet_size (const char *args, int from_tty)
1171 {
1172 set_memory_packet_size (args, &memory_read_packet_config);
1173 }
1174
1175 static void
1176 show_memory_read_packet_size (const char *args, int from_tty)
1177 {
1178 show_memory_packet_size (&memory_read_packet_config);
1179 }
1180
1181 static long
1182 get_memory_read_packet_size (void)
1183 {
1184 long size = get_memory_packet_size (&memory_read_packet_config);
1185
1186 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1187 extra buffer size argument before the memory read size can be
1188 increased beyond this. */
1189 if (size > get_remote_packet_size ())
1190 size = get_remote_packet_size ();
1191 return size;
1192 }
1193
1194 \f
1195 /* Generic configuration support for packets the stub optionally
1196 supports. Allows the user to specify the use of the packet as well
1197 as allowing GDB to auto-detect support in the remote stub. */
1198
1199 enum packet_support
1200 {
1201 PACKET_SUPPORT_UNKNOWN = 0,
1202 PACKET_ENABLE,
1203 PACKET_DISABLE
1204 };
1205
1206 struct packet_config
1207 {
1208 const char *name;
1209 const char *title;
1210
1211 /* If auto, GDB auto-detects support for this packet or feature,
1212 either through qSupported, or by trying the packet and looking
1213 at the response. If true, GDB assumes the target supports this
1214 packet. If false, the packet is disabled. Configs that don't
1215 have an associated command always have this set to auto. */
1216 enum auto_boolean detect;
1217
1218 /* Does the target support this packet? */
1219 enum packet_support support;
1220 };
1221
1222 /* Analyze a packet's return value and update the packet config
1223 accordingly. */
1224
1225 enum packet_result
1226 {
1227 PACKET_ERROR,
1228 PACKET_OK,
1229 PACKET_UNKNOWN
1230 };
1231
1232 static enum packet_support packet_config_support (struct packet_config *config);
1233 static enum packet_support packet_support (int packet);
1234
1235 static void
1236 show_packet_config_cmd (struct packet_config *config)
1237 {
1238 const char *support = "internal-error";
1239
1240 switch (packet_config_support (config))
1241 {
1242 case PACKET_ENABLE:
1243 support = "enabled";
1244 break;
1245 case PACKET_DISABLE:
1246 support = "disabled";
1247 break;
1248 case PACKET_SUPPORT_UNKNOWN:
1249 support = "unknown";
1250 break;
1251 }
1252 switch (config->detect)
1253 {
1254 case AUTO_BOOLEAN_AUTO:
1255 printf_filtered (_("Support for the `%s' packet "
1256 "is auto-detected, currently %s.\n"),
1257 config->name, support);
1258 break;
1259 case AUTO_BOOLEAN_TRUE:
1260 case AUTO_BOOLEAN_FALSE:
1261 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1262 config->name, support);
1263 break;
1264 }
1265 }
1266
1267 static void
1268 add_packet_config_cmd (struct packet_config *config, const char *name,
1269 const char *title, int legacy)
1270 {
1271 char *set_doc;
1272 char *show_doc;
1273 char *cmd_name;
1274
1275 config->name = name;
1276 config->title = title;
1277 set_doc = xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1278 name, title);
1279 show_doc = xstrprintf ("Show current use of remote "
1280 "protocol `%s' (%s) packet",
1281 name, title);
1282 /* set/show TITLE-packet {auto,on,off} */
1283 cmd_name = xstrprintf ("%s-packet", title);
1284 add_setshow_auto_boolean_cmd (cmd_name, class_obscure,
1285 &config->detect, set_doc,
1286 show_doc, NULL, /* help_doc */
1287 NULL,
1288 show_remote_protocol_packet_cmd,
1289 &remote_set_cmdlist, &remote_show_cmdlist);
1290 /* The command code copies the documentation strings. */
1291 xfree (set_doc);
1292 xfree (show_doc);
1293 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1294 if (legacy)
1295 {
1296 char *legacy_name;
1297
1298 legacy_name = xstrprintf ("%s-packet", name);
1299 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1300 &remote_set_cmdlist);
1301 add_alias_cmd (legacy_name, cmd_name, class_obscure, 0,
1302 &remote_show_cmdlist);
1303 }
1304 }
1305
1306 static enum packet_result
1307 packet_check_result (const char *buf)
1308 {
1309 if (buf[0] != '\0')
1310 {
1311 /* The stub recognized the packet request. Check that the
1312 operation succeeded. */
1313 if (buf[0] == 'E'
1314 && isxdigit (buf[1]) && isxdigit (buf[2])
1315 && buf[3] == '\0')
1316 /* "Enn" - definitly an error. */
1317 return PACKET_ERROR;
1318
1319 /* Always treat "E." as an error. This will be used for
1320 more verbose error messages, such as E.memtypes. */
1321 if (buf[0] == 'E' && buf[1] == '.')
1322 return PACKET_ERROR;
1323
1324 /* The packet may or may not be OK. Just assume it is. */
1325 return PACKET_OK;
1326 }
1327 else
1328 /* The stub does not support the packet. */
1329 return PACKET_UNKNOWN;
1330 }
1331
1332 static enum packet_result
1333 packet_ok (const char *buf, struct packet_config *config)
1334 {
1335 enum packet_result result;
1336
1337 if (config->detect != AUTO_BOOLEAN_TRUE
1338 && config->support == PACKET_DISABLE)
1339 internal_error (__FILE__, __LINE__,
1340 _("packet_ok: attempt to use a disabled packet"));
1341
1342 result = packet_check_result (buf);
1343 switch (result)
1344 {
1345 case PACKET_OK:
1346 case PACKET_ERROR:
1347 /* The stub recognized the packet request. */
1348 if (config->support == PACKET_SUPPORT_UNKNOWN)
1349 {
1350 if (remote_debug)
1351 fprintf_unfiltered (gdb_stdlog,
1352 "Packet %s (%s) is supported\n",
1353 config->name, config->title);
1354 config->support = PACKET_ENABLE;
1355 }
1356 break;
1357 case PACKET_UNKNOWN:
1358 /* The stub does not support the packet. */
1359 if (config->detect == AUTO_BOOLEAN_AUTO
1360 && config->support == PACKET_ENABLE)
1361 {
1362 /* If the stub previously indicated that the packet was
1363 supported then there is a protocol error. */
1364 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1365 config->name, config->title);
1366 }
1367 else if (config->detect == AUTO_BOOLEAN_TRUE)
1368 {
1369 /* The user set it wrong. */
1370 error (_("Enabled packet %s (%s) not recognized by stub"),
1371 config->name, config->title);
1372 }
1373
1374 if (remote_debug)
1375 fprintf_unfiltered (gdb_stdlog,
1376 "Packet %s (%s) is NOT supported\n",
1377 config->name, config->title);
1378 config->support = PACKET_DISABLE;
1379 break;
1380 }
1381
1382 return result;
1383 }
1384
1385 enum {
1386 PACKET_vCont = 0,
1387 PACKET_X,
1388 PACKET_qSymbol,
1389 PACKET_P,
1390 PACKET_p,
1391 PACKET_Z0,
1392 PACKET_Z1,
1393 PACKET_Z2,
1394 PACKET_Z3,
1395 PACKET_Z4,
1396 PACKET_vFile_setfs,
1397 PACKET_vFile_open,
1398 PACKET_vFile_pread,
1399 PACKET_vFile_pwrite,
1400 PACKET_vFile_close,
1401 PACKET_vFile_unlink,
1402 PACKET_vFile_readlink,
1403 PACKET_vFile_fstat,
1404 PACKET_qXfer_auxv,
1405 PACKET_qXfer_features,
1406 PACKET_qXfer_exec_file,
1407 PACKET_qXfer_libraries,
1408 PACKET_qXfer_libraries_svr4,
1409 PACKET_qXfer_memory_map,
1410 PACKET_qXfer_spu_read,
1411 PACKET_qXfer_spu_write,
1412 PACKET_qXfer_osdata,
1413 PACKET_qXfer_threads,
1414 PACKET_qXfer_statictrace_read,
1415 PACKET_qXfer_traceframe_info,
1416 PACKET_qXfer_uib,
1417 PACKET_qGetTIBAddr,
1418 PACKET_qGetTLSAddr,
1419 PACKET_qSupported,
1420 PACKET_qTStatus,
1421 PACKET_QPassSignals,
1422 PACKET_QCatchSyscalls,
1423 PACKET_QProgramSignals,
1424 PACKET_QSetWorkingDir,
1425 PACKET_QStartupWithShell,
1426 PACKET_QEnvironmentHexEncoded,
1427 PACKET_QEnvironmentReset,
1428 PACKET_QEnvironmentUnset,
1429 PACKET_qCRC,
1430 PACKET_qSearch_memory,
1431 PACKET_vAttach,
1432 PACKET_vRun,
1433 PACKET_QStartNoAckMode,
1434 PACKET_vKill,
1435 PACKET_qXfer_siginfo_read,
1436 PACKET_qXfer_siginfo_write,
1437 PACKET_qAttached,
1438
1439 /* Support for conditional tracepoints. */
1440 PACKET_ConditionalTracepoints,
1441
1442 /* Support for target-side breakpoint conditions. */
1443 PACKET_ConditionalBreakpoints,
1444
1445 /* Support for target-side breakpoint commands. */
1446 PACKET_BreakpointCommands,
1447
1448 /* Support for fast tracepoints. */
1449 PACKET_FastTracepoints,
1450
1451 /* Support for static tracepoints. */
1452 PACKET_StaticTracepoints,
1453
1454 /* Support for installing tracepoints while a trace experiment is
1455 running. */
1456 PACKET_InstallInTrace,
1457
1458 PACKET_bc,
1459 PACKET_bs,
1460 PACKET_TracepointSource,
1461 PACKET_QAllow,
1462 PACKET_qXfer_fdpic,
1463 PACKET_QDisableRandomization,
1464 PACKET_QAgent,
1465 PACKET_QTBuffer_size,
1466 PACKET_Qbtrace_off,
1467 PACKET_Qbtrace_bts,
1468 PACKET_Qbtrace_pt,
1469 PACKET_qXfer_btrace,
1470
1471 /* Support for the QNonStop packet. */
1472 PACKET_QNonStop,
1473
1474 /* Support for the QThreadEvents packet. */
1475 PACKET_QThreadEvents,
1476
1477 /* Support for multi-process extensions. */
1478 PACKET_multiprocess_feature,
1479
1480 /* Support for enabling and disabling tracepoints while a trace
1481 experiment is running. */
1482 PACKET_EnableDisableTracepoints_feature,
1483
1484 /* Support for collecting strings using the tracenz bytecode. */
1485 PACKET_tracenz_feature,
1486
1487 /* Support for continuing to run a trace experiment while GDB is
1488 disconnected. */
1489 PACKET_DisconnectedTracing_feature,
1490
1491 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1492 PACKET_augmented_libraries_svr4_read_feature,
1493
1494 /* Support for the qXfer:btrace-conf:read packet. */
1495 PACKET_qXfer_btrace_conf,
1496
1497 /* Support for the Qbtrace-conf:bts:size packet. */
1498 PACKET_Qbtrace_conf_bts_size,
1499
1500 /* Support for swbreak+ feature. */
1501 PACKET_swbreak_feature,
1502
1503 /* Support for hwbreak+ feature. */
1504 PACKET_hwbreak_feature,
1505
1506 /* Support for fork events. */
1507 PACKET_fork_event_feature,
1508
1509 /* Support for vfork events. */
1510 PACKET_vfork_event_feature,
1511
1512 /* Support for the Qbtrace-conf:pt:size packet. */
1513 PACKET_Qbtrace_conf_pt_size,
1514
1515 /* Support for exec events. */
1516 PACKET_exec_event_feature,
1517
1518 /* Support for query supported vCont actions. */
1519 PACKET_vContSupported,
1520
1521 /* Support remote CTRL-C. */
1522 PACKET_vCtrlC,
1523
1524 /* Support TARGET_WAITKIND_NO_RESUMED. */
1525 PACKET_no_resumed,
1526
1527 PACKET_MAX
1528 };
1529
1530 static struct packet_config remote_protocol_packets[PACKET_MAX];
1531
1532 /* Returns the packet's corresponding "set remote foo-packet" command
1533 state. See struct packet_config for more details. */
1534
1535 static enum auto_boolean
1536 packet_set_cmd_state (int packet)
1537 {
1538 return remote_protocol_packets[packet].detect;
1539 }
1540
1541 /* Returns whether a given packet or feature is supported. This takes
1542 into account the state of the corresponding "set remote foo-packet"
1543 command, which may be used to bypass auto-detection. */
1544
1545 static enum packet_support
1546 packet_config_support (struct packet_config *config)
1547 {
1548 switch (config->detect)
1549 {
1550 case AUTO_BOOLEAN_TRUE:
1551 return PACKET_ENABLE;
1552 case AUTO_BOOLEAN_FALSE:
1553 return PACKET_DISABLE;
1554 case AUTO_BOOLEAN_AUTO:
1555 return config->support;
1556 default:
1557 gdb_assert_not_reached (_("bad switch"));
1558 }
1559 }
1560
1561 /* Same as packet_config_support, but takes the packet's enum value as
1562 argument. */
1563
1564 static enum packet_support
1565 packet_support (int packet)
1566 {
1567 struct packet_config *config = &remote_protocol_packets[packet];
1568
1569 return packet_config_support (config);
1570 }
1571
1572 static void
1573 show_remote_protocol_packet_cmd (struct ui_file *file, int from_tty,
1574 struct cmd_list_element *c,
1575 const char *value)
1576 {
1577 struct packet_config *packet;
1578
1579 for (packet = remote_protocol_packets;
1580 packet < &remote_protocol_packets[PACKET_MAX];
1581 packet++)
1582 {
1583 if (&packet->detect == c->var)
1584 {
1585 show_packet_config_cmd (packet);
1586 return;
1587 }
1588 }
1589 internal_error (__FILE__, __LINE__, _("Could not find config for %s"),
1590 c->name);
1591 }
1592
1593 /* Should we try one of the 'Z' requests? */
1594
1595 enum Z_packet_type
1596 {
1597 Z_PACKET_SOFTWARE_BP,
1598 Z_PACKET_HARDWARE_BP,
1599 Z_PACKET_WRITE_WP,
1600 Z_PACKET_READ_WP,
1601 Z_PACKET_ACCESS_WP,
1602 NR_Z_PACKET_TYPES
1603 };
1604
1605 /* For compatibility with older distributions. Provide a ``set remote
1606 Z-packet ...'' command that updates all the Z packet types. */
1607
1608 static enum auto_boolean remote_Z_packet_detect;
1609
1610 static void
1611 set_remote_protocol_Z_packet_cmd (const char *args, int from_tty,
1612 struct cmd_list_element *c)
1613 {
1614 int i;
1615
1616 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1617 remote_protocol_packets[PACKET_Z0 + i].detect = remote_Z_packet_detect;
1618 }
1619
1620 static void
1621 show_remote_protocol_Z_packet_cmd (struct ui_file *file, int from_tty,
1622 struct cmd_list_element *c,
1623 const char *value)
1624 {
1625 int i;
1626
1627 for (i = 0; i < NR_Z_PACKET_TYPES; i++)
1628 {
1629 show_packet_config_cmd (&remote_protocol_packets[PACKET_Z0 + i]);
1630 }
1631 }
1632
1633 /* Returns true if the multi-process extensions are in effect. */
1634
1635 static int
1636 remote_multi_process_p (struct remote_state *rs)
1637 {
1638 return packet_support (PACKET_multiprocess_feature) == PACKET_ENABLE;
1639 }
1640
1641 /* Returns true if fork events are supported. */
1642
1643 static int
1644 remote_fork_event_p (struct remote_state *rs)
1645 {
1646 return packet_support (PACKET_fork_event_feature) == PACKET_ENABLE;
1647 }
1648
1649 /* Returns true if vfork events are supported. */
1650
1651 static int
1652 remote_vfork_event_p (struct remote_state *rs)
1653 {
1654 return packet_support (PACKET_vfork_event_feature) == PACKET_ENABLE;
1655 }
1656
1657 /* Returns true if exec events are supported. */
1658
1659 static int
1660 remote_exec_event_p (struct remote_state *rs)
1661 {
1662 return packet_support (PACKET_exec_event_feature) == PACKET_ENABLE;
1663 }
1664
1665 /* Insert fork catchpoint target routine. If fork events are enabled
1666 then return success, nothing more to do. */
1667
1668 static int
1669 remote_insert_fork_catchpoint (struct target_ops *ops, int pid)
1670 {
1671 struct remote_state *rs = get_remote_state ();
1672
1673 return !remote_fork_event_p (rs);
1674 }
1675
1676 /* Remove fork catchpoint target routine. Nothing to do, just
1677 return success. */
1678
1679 static int
1680 remote_remove_fork_catchpoint (struct target_ops *ops, int pid)
1681 {
1682 return 0;
1683 }
1684
1685 /* Insert vfork catchpoint target routine. If vfork events are enabled
1686 then return success, nothing more to do. */
1687
1688 static int
1689 remote_insert_vfork_catchpoint (struct target_ops *ops, int pid)
1690 {
1691 struct remote_state *rs = get_remote_state ();
1692
1693 return !remote_vfork_event_p (rs);
1694 }
1695
1696 /* Remove vfork catchpoint target routine. Nothing to do, just
1697 return success. */
1698
1699 static int
1700 remote_remove_vfork_catchpoint (struct target_ops *ops, int pid)
1701 {
1702 return 0;
1703 }
1704
1705 /* Insert exec catchpoint target routine. If exec events are
1706 enabled, just return success. */
1707
1708 static int
1709 remote_insert_exec_catchpoint (struct target_ops *ops, int pid)
1710 {
1711 struct remote_state *rs = get_remote_state ();
1712
1713 return !remote_exec_event_p (rs);
1714 }
1715
1716 /* Remove exec catchpoint target routine. Nothing to do, just
1717 return success. */
1718
1719 static int
1720 remote_remove_exec_catchpoint (struct target_ops *ops, int pid)
1721 {
1722 return 0;
1723 }
1724
1725 \f
1726 /* Asynchronous signal handle registered as event loop source for
1727 when we have pending events ready to be passed to the core. */
1728
1729 static struct async_event_handler *remote_async_inferior_event_token;
1730
1731 \f
1732
1733 static ptid_t magic_null_ptid;
1734 static ptid_t not_sent_ptid;
1735 static ptid_t any_thread_ptid;
1736
1737 /* Find out if the stub attached to PID (and hence GDB should offer to
1738 detach instead of killing it when bailing out). */
1739
1740 static int
1741 remote_query_attached (int pid)
1742 {
1743 struct remote_state *rs = get_remote_state ();
1744 size_t size = get_remote_packet_size ();
1745
1746 if (packet_support (PACKET_qAttached) == PACKET_DISABLE)
1747 return 0;
1748
1749 if (remote_multi_process_p (rs))
1750 xsnprintf (rs->buf, size, "qAttached:%x", pid);
1751 else
1752 xsnprintf (rs->buf, size, "qAttached");
1753
1754 putpkt (rs->buf);
1755 getpkt (&rs->buf, &rs->buf_size, 0);
1756
1757 switch (packet_ok (rs->buf,
1758 &remote_protocol_packets[PACKET_qAttached]))
1759 {
1760 case PACKET_OK:
1761 if (strcmp (rs->buf, "1") == 0)
1762 return 1;
1763 break;
1764 case PACKET_ERROR:
1765 warning (_("Remote failure reply: %s"), rs->buf);
1766 break;
1767 case PACKET_UNKNOWN:
1768 break;
1769 }
1770
1771 return 0;
1772 }
1773
1774 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1775 has been invented by GDB, instead of reported by the target. Since
1776 we can be connected to a remote system before before knowing about
1777 any inferior, mark the target with execution when we find the first
1778 inferior. If ATTACHED is 1, then we had just attached to this
1779 inferior. If it is 0, then we just created this inferior. If it
1780 is -1, then try querying the remote stub to find out if it had
1781 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1782 attempt to open this inferior's executable as the main executable
1783 if no main executable is open already. */
1784
1785 static struct inferior *
1786 remote_add_inferior (int fake_pid_p, int pid, int attached,
1787 int try_open_exec)
1788 {
1789 struct inferior *inf;
1790
1791 /* Check whether this process we're learning about is to be
1792 considered attached, or if is to be considered to have been
1793 spawned by the stub. */
1794 if (attached == -1)
1795 attached = remote_query_attached (pid);
1796
1797 if (gdbarch_has_global_solist (target_gdbarch ()))
1798 {
1799 /* If the target shares code across all inferiors, then every
1800 attach adds a new inferior. */
1801 inf = add_inferior (pid);
1802
1803 /* ... and every inferior is bound to the same program space.
1804 However, each inferior may still have its own address
1805 space. */
1806 inf->aspace = maybe_new_address_space ();
1807 inf->pspace = current_program_space;
1808 }
1809 else
1810 {
1811 /* In the traditional debugging scenario, there's a 1-1 match
1812 between program/address spaces. We simply bind the inferior
1813 to the program space's address space. */
1814 inf = current_inferior ();
1815 inferior_appeared (inf, pid);
1816 }
1817
1818 inf->attach_flag = attached;
1819 inf->fake_pid_p = fake_pid_p;
1820
1821 /* If no main executable is currently open then attempt to
1822 open the file that was executed to create this inferior. */
1823 if (try_open_exec && get_exec_file (0) == NULL)
1824 exec_file_locate_attach (pid, 0, 1);
1825
1826 return inf;
1827 }
1828
1829 static struct private_thread_info *
1830 get_private_info_thread (struct thread_info *info);
1831
1832 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1833 according to RUNNING. */
1834
1835 static void
1836 remote_add_thread (ptid_t ptid, int running, int executing)
1837 {
1838 struct remote_state *rs = get_remote_state ();
1839 struct thread_info *thread;
1840
1841 /* GDB historically didn't pull threads in the initial connection
1842 setup. If the remote target doesn't even have a concept of
1843 threads (e.g., a bare-metal target), even if internally we
1844 consider that a single-threaded target, mentioning a new thread
1845 might be confusing to the user. Be silent then, preserving the
1846 age old behavior. */
1847 if (rs->starting_up)
1848 thread = add_thread_silent (ptid);
1849 else
1850 thread = add_thread (ptid);
1851
1852 get_private_info_thread (thread)->vcont_resumed = executing;
1853 set_executing (ptid, executing);
1854 set_running (ptid, running);
1855 }
1856
1857 /* Come here when we learn about a thread id from the remote target.
1858 It may be the first time we hear about such thread, so take the
1859 opportunity to add it to GDB's thread list. In case this is the
1860 first time we're noticing its corresponding inferior, add it to
1861 GDB's inferior list as well. EXECUTING indicates whether the
1862 thread is (internally) executing or stopped. */
1863
1864 static void
1865 remote_notice_new_inferior (ptid_t currthread, int executing)
1866 {
1867 /* In non-stop mode, we assume new found threads are (externally)
1868 running until proven otherwise with a stop reply. In all-stop,
1869 we can only get here if all threads are stopped. */
1870 int running = target_is_non_stop_p () ? 1 : 0;
1871
1872 /* If this is a new thread, add it to GDB's thread list.
1873 If we leave it up to WFI to do this, bad things will happen. */
1874
1875 if (in_thread_list (currthread) && is_exited (currthread))
1876 {
1877 /* We're seeing an event on a thread id we knew had exited.
1878 This has to be a new thread reusing the old id. Add it. */
1879 remote_add_thread (currthread, running, executing);
1880 return;
1881 }
1882
1883 if (!in_thread_list (currthread))
1884 {
1885 struct inferior *inf = NULL;
1886 int pid = ptid_get_pid (currthread);
1887
1888 if (ptid_is_pid (inferior_ptid)
1889 && pid == ptid_get_pid (inferior_ptid))
1890 {
1891 /* inferior_ptid has no thread member yet. This can happen
1892 with the vAttach -> remote_wait,"TAAthread:" path if the
1893 stub doesn't support qC. This is the first stop reported
1894 after an attach, so this is the main thread. Update the
1895 ptid in the thread list. */
1896 if (in_thread_list (pid_to_ptid (pid)))
1897 thread_change_ptid (inferior_ptid, currthread);
1898 else
1899 {
1900 remote_add_thread (currthread, running, executing);
1901 inferior_ptid = currthread;
1902 }
1903 return;
1904 }
1905
1906 if (ptid_equal (magic_null_ptid, inferior_ptid))
1907 {
1908 /* inferior_ptid is not set yet. This can happen with the
1909 vRun -> remote_wait,"TAAthread:" path if the stub
1910 doesn't support qC. This is the first stop reported
1911 after an attach, so this is the main thread. Update the
1912 ptid in the thread list. */
1913 thread_change_ptid (inferior_ptid, currthread);
1914 return;
1915 }
1916
1917 /* When connecting to a target remote, or to a target
1918 extended-remote which already was debugging an inferior, we
1919 may not know about it yet. Add it before adding its child
1920 thread, so notifications are emitted in a sensible order. */
1921 if (!in_inferior_list (ptid_get_pid (currthread)))
1922 {
1923 struct remote_state *rs = get_remote_state ();
1924 int fake_pid_p = !remote_multi_process_p (rs);
1925
1926 inf = remote_add_inferior (fake_pid_p,
1927 ptid_get_pid (currthread), -1, 1);
1928 }
1929
1930 /* This is really a new thread. Add it. */
1931 remote_add_thread (currthread, running, executing);
1932
1933 /* If we found a new inferior, let the common code do whatever
1934 it needs to with it (e.g., read shared libraries, insert
1935 breakpoints), unless we're just setting up an all-stop
1936 connection. */
1937 if (inf != NULL)
1938 {
1939 struct remote_state *rs = get_remote_state ();
1940
1941 if (!rs->starting_up)
1942 notice_new_inferior (currthread, executing, 0);
1943 }
1944 }
1945 }
1946
1947 /* Return THREAD's private thread data, creating it if necessary. */
1948
1949 static struct private_thread_info *
1950 get_private_info_thread (struct thread_info *thread)
1951 {
1952 gdb_assert (thread != NULL);
1953
1954 if (thread->priv == NULL)
1955 {
1956 struct private_thread_info *priv = XNEW (struct private_thread_info);
1957
1958 thread->private_dtor = free_private_thread_info;
1959 thread->priv = priv;
1960
1961 priv->core = -1;
1962 priv->extra = NULL;
1963 priv->name = NULL;
1964 priv->name = NULL;
1965 priv->last_resume_step = 0;
1966 priv->last_resume_sig = GDB_SIGNAL_0;
1967 priv->vcont_resumed = 0;
1968 priv->thread_handle = nullptr;
1969 }
1970
1971 return thread->priv;
1972 }
1973
1974 /* Return PTID's private thread data, creating it if necessary. */
1975
1976 static struct private_thread_info *
1977 get_private_info_ptid (ptid_t ptid)
1978 {
1979 struct thread_info *info = find_thread_ptid (ptid);
1980
1981 return get_private_info_thread (info);
1982 }
1983
1984 /* Call this function as a result of
1985 1) A halt indication (T packet) containing a thread id
1986 2) A direct query of currthread
1987 3) Successful execution of set thread */
1988
1989 static void
1990 record_currthread (struct remote_state *rs, ptid_t currthread)
1991 {
1992 rs->general_thread = currthread;
1993 }
1994
1995 /* If 'QPassSignals' is supported, tell the remote stub what signals
1996 it can simply pass through to the inferior without reporting. */
1997
1998 static void
1999 remote_pass_signals (struct target_ops *self,
2000 int numsigs, unsigned char *pass_signals)
2001 {
2002 if (packet_support (PACKET_QPassSignals) != PACKET_DISABLE)
2003 {
2004 char *pass_packet, *p;
2005 int count = 0, i;
2006 struct remote_state *rs = get_remote_state ();
2007
2008 gdb_assert (numsigs < 256);
2009 for (i = 0; i < numsigs; i++)
2010 {
2011 if (pass_signals[i])
2012 count++;
2013 }
2014 pass_packet = (char *) xmalloc (count * 3 + strlen ("QPassSignals:") + 1);
2015 strcpy (pass_packet, "QPassSignals:");
2016 p = pass_packet + strlen (pass_packet);
2017 for (i = 0; i < numsigs; i++)
2018 {
2019 if (pass_signals[i])
2020 {
2021 if (i >= 16)
2022 *p++ = tohex (i >> 4);
2023 *p++ = tohex (i & 15);
2024 if (count)
2025 *p++ = ';';
2026 else
2027 break;
2028 count--;
2029 }
2030 }
2031 *p = 0;
2032 if (!rs->last_pass_packet || strcmp (rs->last_pass_packet, pass_packet))
2033 {
2034 putpkt (pass_packet);
2035 getpkt (&rs->buf, &rs->buf_size, 0);
2036 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QPassSignals]);
2037 if (rs->last_pass_packet)
2038 xfree (rs->last_pass_packet);
2039 rs->last_pass_packet = pass_packet;
2040 }
2041 else
2042 xfree (pass_packet);
2043 }
2044 }
2045
2046 /* If 'QCatchSyscalls' is supported, tell the remote stub
2047 to report syscalls to GDB. */
2048
2049 static int
2050 remote_set_syscall_catchpoint (struct target_ops *self,
2051 int pid, int needed, int any_count,
2052 int table_size, int *table)
2053 {
2054 const char *catch_packet;
2055 enum packet_result result;
2056 int n_sysno = 0;
2057
2058 if (packet_support (PACKET_QCatchSyscalls) == PACKET_DISABLE)
2059 {
2060 /* Not supported. */
2061 return 1;
2062 }
2063
2064 if (needed && !any_count)
2065 {
2066 int i;
2067
2068 /* Count how many syscalls are to be caught (table[sysno] != 0). */
2069 for (i = 0; i < table_size; i++)
2070 {
2071 if (table[i] != 0)
2072 n_sysno++;
2073 }
2074 }
2075
2076 if (remote_debug)
2077 {
2078 fprintf_unfiltered (gdb_stdlog,
2079 "remote_set_syscall_catchpoint "
2080 "pid %d needed %d any_count %d n_sysno %d\n",
2081 pid, needed, any_count, n_sysno);
2082 }
2083
2084 std::string built_packet;
2085 if (needed)
2086 {
2087 /* Prepare a packet with the sysno list, assuming max 8+1
2088 characters for a sysno. If the resulting packet size is too
2089 big, fallback on the non-selective packet. */
2090 const int maxpktsz = strlen ("QCatchSyscalls:1") + n_sysno * 9 + 1;
2091 built_packet.reserve (maxpktsz);
2092 built_packet = "QCatchSyscalls:1";
2093 if (!any_count)
2094 {
2095 /* Add in catch_packet each syscall to be caught (table[i] != 0). */
2096 for (int i = 0; i < table_size; i++)
2097 {
2098 if (table[i] != 0)
2099 string_appendf (built_packet, ";%x", i);
2100 }
2101 }
2102 if (built_packet.size () > get_remote_packet_size ())
2103 {
2104 /* catch_packet too big. Fallback to less efficient
2105 non selective mode, with GDB doing the filtering. */
2106 catch_packet = "QCatchSyscalls:1";
2107 }
2108 else
2109 catch_packet = built_packet.c_str ();
2110 }
2111 else
2112 catch_packet = "QCatchSyscalls:0";
2113
2114 struct remote_state *rs = get_remote_state ();
2115
2116 putpkt (catch_packet);
2117 getpkt (&rs->buf, &rs->buf_size, 0);
2118 result = packet_ok (rs->buf, &remote_protocol_packets[PACKET_QCatchSyscalls]);
2119 if (result == PACKET_OK)
2120 return 0;
2121 else
2122 return -1;
2123 }
2124
2125 /* If 'QProgramSignals' is supported, tell the remote stub what
2126 signals it should pass through to the inferior when detaching. */
2127
2128 static void
2129 remote_program_signals (struct target_ops *self,
2130 int numsigs, unsigned char *signals)
2131 {
2132 if (packet_support (PACKET_QProgramSignals) != PACKET_DISABLE)
2133 {
2134 char *packet, *p;
2135 int count = 0, i;
2136 struct remote_state *rs = get_remote_state ();
2137
2138 gdb_assert (numsigs < 256);
2139 for (i = 0; i < numsigs; i++)
2140 {
2141 if (signals[i])
2142 count++;
2143 }
2144 packet = (char *) xmalloc (count * 3 + strlen ("QProgramSignals:") + 1);
2145 strcpy (packet, "QProgramSignals:");
2146 p = packet + strlen (packet);
2147 for (i = 0; i < numsigs; i++)
2148 {
2149 if (signal_pass_state (i))
2150 {
2151 if (i >= 16)
2152 *p++ = tohex (i >> 4);
2153 *p++ = tohex (i & 15);
2154 if (count)
2155 *p++ = ';';
2156 else
2157 break;
2158 count--;
2159 }
2160 }
2161 *p = 0;
2162 if (!rs->last_program_signals_packet
2163 || strcmp (rs->last_program_signals_packet, packet) != 0)
2164 {
2165 putpkt (packet);
2166 getpkt (&rs->buf, &rs->buf_size, 0);
2167 packet_ok (rs->buf, &remote_protocol_packets[PACKET_QProgramSignals]);
2168 xfree (rs->last_program_signals_packet);
2169 rs->last_program_signals_packet = packet;
2170 }
2171 else
2172 xfree (packet);
2173 }
2174 }
2175
2176 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2177 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2178 thread. If GEN is set, set the general thread, if not, then set
2179 the step/continue thread. */
2180 static void
2181 set_thread (ptid_t ptid, int gen)
2182 {
2183 struct remote_state *rs = get_remote_state ();
2184 ptid_t state = gen ? rs->general_thread : rs->continue_thread;
2185 char *buf = rs->buf;
2186 char *endbuf = rs->buf + get_remote_packet_size ();
2187
2188 if (ptid_equal (state, ptid))
2189 return;
2190
2191 *buf++ = 'H';
2192 *buf++ = gen ? 'g' : 'c';
2193 if (ptid_equal (ptid, magic_null_ptid))
2194 xsnprintf (buf, endbuf - buf, "0");
2195 else if (ptid_equal (ptid, any_thread_ptid))
2196 xsnprintf (buf, endbuf - buf, "0");
2197 else if (ptid_equal (ptid, minus_one_ptid))
2198 xsnprintf (buf, endbuf - buf, "-1");
2199 else
2200 write_ptid (buf, endbuf, ptid);
2201 putpkt (rs->buf);
2202 getpkt (&rs->buf, &rs->buf_size, 0);
2203 if (gen)
2204 rs->general_thread = ptid;
2205 else
2206 rs->continue_thread = ptid;
2207 }
2208
2209 static void
2210 set_general_thread (ptid_t ptid)
2211 {
2212 set_thread (ptid, 1);
2213 }
2214
2215 static void
2216 set_continue_thread (ptid_t ptid)
2217 {
2218 set_thread (ptid, 0);
2219 }
2220
2221 /* Change the remote current process. Which thread within the process
2222 ends up selected isn't important, as long as it is the same process
2223 as what INFERIOR_PTID points to.
2224
2225 This comes from that fact that there is no explicit notion of
2226 "selected process" in the protocol. The selected process for
2227 general operations is the process the selected general thread
2228 belongs to. */
2229
2230 static void
2231 set_general_process (void)
2232 {
2233 struct remote_state *rs = get_remote_state ();
2234
2235 /* If the remote can't handle multiple processes, don't bother. */
2236 if (!remote_multi_process_p (rs))
2237 return;
2238
2239 /* We only need to change the remote current thread if it's pointing
2240 at some other process. */
2241 if (ptid_get_pid (rs->general_thread) != ptid_get_pid (inferior_ptid))
2242 set_general_thread (inferior_ptid);
2243 }
2244
2245 \f
2246 /* Return nonzero if this is the main thread that we made up ourselves
2247 to model non-threaded targets as single-threaded. */
2248
2249 static int
2250 remote_thread_always_alive (struct target_ops *ops, ptid_t ptid)
2251 {
2252 if (ptid_equal (ptid, magic_null_ptid))
2253 /* The main thread is always alive. */
2254 return 1;
2255
2256 if (ptid_get_pid (ptid) != 0 && ptid_get_lwp (ptid) == 0)
2257 /* The main thread is always alive. This can happen after a
2258 vAttach, if the remote side doesn't support
2259 multi-threading. */
2260 return 1;
2261
2262 return 0;
2263 }
2264
2265 /* Return nonzero if the thread PTID is still alive on the remote
2266 system. */
2267
2268 static int
2269 remote_thread_alive (struct target_ops *ops, ptid_t ptid)
2270 {
2271 struct remote_state *rs = get_remote_state ();
2272 char *p, *endp;
2273
2274 /* Check if this is a thread that we made up ourselves to model
2275 non-threaded targets as single-threaded. */
2276 if (remote_thread_always_alive (ops, ptid))
2277 return 1;
2278
2279 p = rs->buf;
2280 endp = rs->buf + get_remote_packet_size ();
2281
2282 *p++ = 'T';
2283 write_ptid (p, endp, ptid);
2284
2285 putpkt (rs->buf);
2286 getpkt (&rs->buf, &rs->buf_size, 0);
2287 return (rs->buf[0] == 'O' && rs->buf[1] == 'K');
2288 }
2289
2290 /* Return a pointer to a thread name if we know it and NULL otherwise.
2291 The thread_info object owns the memory for the name. */
2292
2293 static const char *
2294 remote_thread_name (struct target_ops *ops, struct thread_info *info)
2295 {
2296 if (info->priv != NULL)
2297 return info->priv->name;
2298
2299 return NULL;
2300 }
2301
2302 /* About these extended threadlist and threadinfo packets. They are
2303 variable length packets but, the fields within them are often fixed
2304 length. They are redundent enough to send over UDP as is the
2305 remote protocol in general. There is a matching unit test module
2306 in libstub. */
2307
2308 /* WARNING: This threadref data structure comes from the remote O.S.,
2309 libstub protocol encoding, and remote.c. It is not particularly
2310 changable. */
2311
2312 /* Right now, the internal structure is int. We want it to be bigger.
2313 Plan to fix this. */
2314
2315 typedef int gdb_threadref; /* Internal GDB thread reference. */
2316
2317 /* gdb_ext_thread_info is an internal GDB data structure which is
2318 equivalent to the reply of the remote threadinfo packet. */
2319
2320 struct gdb_ext_thread_info
2321 {
2322 threadref threadid; /* External form of thread reference. */
2323 int active; /* Has state interesting to GDB?
2324 regs, stack. */
2325 char display[256]; /* Brief state display, name,
2326 blocked/suspended. */
2327 char shortname[32]; /* To be used to name threads. */
2328 char more_display[256]; /* Long info, statistics, queue depth,
2329 whatever. */
2330 };
2331
2332 /* The volume of remote transfers can be limited by submitting
2333 a mask containing bits specifying the desired information.
2334 Use a union of these values as the 'selection' parameter to
2335 get_thread_info. FIXME: Make these TAG names more thread specific. */
2336
2337 #define TAG_THREADID 1
2338 #define TAG_EXISTS 2
2339 #define TAG_DISPLAY 4
2340 #define TAG_THREADNAME 8
2341 #define TAG_MOREDISPLAY 16
2342
2343 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2344
2345 static char *unpack_nibble (char *buf, int *val);
2346
2347 static char *unpack_byte (char *buf, int *value);
2348
2349 static char *pack_int (char *buf, int value);
2350
2351 static char *unpack_int (char *buf, int *value);
2352
2353 static char *unpack_string (char *src, char *dest, int length);
2354
2355 static char *pack_threadid (char *pkt, threadref *id);
2356
2357 static char *unpack_threadid (char *inbuf, threadref *id);
2358
2359 void int_to_threadref (threadref *id, int value);
2360
2361 static int threadref_to_int (threadref *ref);
2362
2363 static void copy_threadref (threadref *dest, threadref *src);
2364
2365 static int threadmatch (threadref *dest, threadref *src);
2366
2367 static char *pack_threadinfo_request (char *pkt, int mode,
2368 threadref *id);
2369
2370 static int remote_unpack_thread_info_response (char *pkt,
2371 threadref *expectedref,
2372 struct gdb_ext_thread_info
2373 *info);
2374
2375
2376 static int remote_get_threadinfo (threadref *threadid,
2377 int fieldset, /*TAG mask */
2378 struct gdb_ext_thread_info *info);
2379
2380 static char *pack_threadlist_request (char *pkt, int startflag,
2381 int threadcount,
2382 threadref *nextthread);
2383
2384 static int parse_threadlist_response (char *pkt,
2385 int result_limit,
2386 threadref *original_echo,
2387 threadref *resultlist,
2388 int *doneflag);
2389
2390 static int remote_get_threadlist (int startflag,
2391 threadref *nextthread,
2392 int result_limit,
2393 int *done,
2394 int *result_count,
2395 threadref *threadlist);
2396
2397 typedef int (*rmt_thread_action) (threadref *ref, void *context);
2398
2399 static int remote_threadlist_iterator (rmt_thread_action stepfunction,
2400 void *context, int looplimit);
2401
2402 static int remote_newthread_step (threadref *ref, void *context);
2403
2404
2405 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2406 buffer we're allowed to write to. Returns
2407 BUF+CHARACTERS_WRITTEN. */
2408
2409 static char *
2410 write_ptid (char *buf, const char *endbuf, ptid_t ptid)
2411 {
2412 int pid, tid;
2413 struct remote_state *rs = get_remote_state ();
2414
2415 if (remote_multi_process_p (rs))
2416 {
2417 pid = ptid_get_pid (ptid);
2418 if (pid < 0)
2419 buf += xsnprintf (buf, endbuf - buf, "p-%x.", -pid);
2420 else
2421 buf += xsnprintf (buf, endbuf - buf, "p%x.", pid);
2422 }
2423 tid = ptid_get_lwp (ptid);
2424 if (tid < 0)
2425 buf += xsnprintf (buf, endbuf - buf, "-%x", -tid);
2426 else
2427 buf += xsnprintf (buf, endbuf - buf, "%x", tid);
2428
2429 return buf;
2430 }
2431
2432 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2433 last parsed char. Returns null_ptid if no thread id is found, and
2434 throws an error if the thread id has an invalid format. */
2435
2436 static ptid_t
2437 read_ptid (const char *buf, const char **obuf)
2438 {
2439 const char *p = buf;
2440 const char *pp;
2441 ULONGEST pid = 0, tid = 0;
2442
2443 if (*p == 'p')
2444 {
2445 /* Multi-process ptid. */
2446 pp = unpack_varlen_hex (p + 1, &pid);
2447 if (*pp != '.')
2448 error (_("invalid remote ptid: %s"), p);
2449
2450 p = pp;
2451 pp = unpack_varlen_hex (p + 1, &tid);
2452 if (obuf)
2453 *obuf = pp;
2454 return ptid_build (pid, tid, 0);
2455 }
2456
2457 /* No multi-process. Just a tid. */
2458 pp = unpack_varlen_hex (p, &tid);
2459
2460 /* Return null_ptid when no thread id is found. */
2461 if (p == pp)
2462 {
2463 if (obuf)
2464 *obuf = pp;
2465 return null_ptid;
2466 }
2467
2468 /* Since the stub is not sending a process id, then default to
2469 what's in inferior_ptid, unless it's null at this point. If so,
2470 then since there's no way to know the pid of the reported
2471 threads, use the magic number. */
2472 if (ptid_equal (inferior_ptid, null_ptid))
2473 pid = ptid_get_pid (magic_null_ptid);
2474 else
2475 pid = ptid_get_pid (inferior_ptid);
2476
2477 if (obuf)
2478 *obuf = pp;
2479 return ptid_build (pid, tid, 0);
2480 }
2481
2482 static int
2483 stubhex (int ch)
2484 {
2485 if (ch >= 'a' && ch <= 'f')
2486 return ch - 'a' + 10;
2487 if (ch >= '0' && ch <= '9')
2488 return ch - '0';
2489 if (ch >= 'A' && ch <= 'F')
2490 return ch - 'A' + 10;
2491 return -1;
2492 }
2493
2494 static int
2495 stub_unpack_int (char *buff, int fieldlength)
2496 {
2497 int nibble;
2498 int retval = 0;
2499
2500 while (fieldlength)
2501 {
2502 nibble = stubhex (*buff++);
2503 retval |= nibble;
2504 fieldlength--;
2505 if (fieldlength)
2506 retval = retval << 4;
2507 }
2508 return retval;
2509 }
2510
2511 static char *
2512 unpack_nibble (char *buf, int *val)
2513 {
2514 *val = fromhex (*buf++);
2515 return buf;
2516 }
2517
2518 static char *
2519 unpack_byte (char *buf, int *value)
2520 {
2521 *value = stub_unpack_int (buf, 2);
2522 return buf + 2;
2523 }
2524
2525 static char *
2526 pack_int (char *buf, int value)
2527 {
2528 buf = pack_hex_byte (buf, (value >> 24) & 0xff);
2529 buf = pack_hex_byte (buf, (value >> 16) & 0xff);
2530 buf = pack_hex_byte (buf, (value >> 8) & 0x0ff);
2531 buf = pack_hex_byte (buf, (value & 0xff));
2532 return buf;
2533 }
2534
2535 static char *
2536 unpack_int (char *buf, int *value)
2537 {
2538 *value = stub_unpack_int (buf, 8);
2539 return buf + 8;
2540 }
2541
2542 #if 0 /* Currently unused, uncomment when needed. */
2543 static char *pack_string (char *pkt, char *string);
2544
2545 static char *
2546 pack_string (char *pkt, char *string)
2547 {
2548 char ch;
2549 int len;
2550
2551 len = strlen (string);
2552 if (len > 200)
2553 len = 200; /* Bigger than most GDB packets, junk??? */
2554 pkt = pack_hex_byte (pkt, len);
2555 while (len-- > 0)
2556 {
2557 ch = *string++;
2558 if ((ch == '\0') || (ch == '#'))
2559 ch = '*'; /* Protect encapsulation. */
2560 *pkt++ = ch;
2561 }
2562 return pkt;
2563 }
2564 #endif /* 0 (unused) */
2565
2566 static char *
2567 unpack_string (char *src, char *dest, int length)
2568 {
2569 while (length--)
2570 *dest++ = *src++;
2571 *dest = '\0';
2572 return src;
2573 }
2574
2575 static char *
2576 pack_threadid (char *pkt, threadref *id)
2577 {
2578 char *limit;
2579 unsigned char *altid;
2580
2581 altid = (unsigned char *) id;
2582 limit = pkt + BUF_THREAD_ID_SIZE;
2583 while (pkt < limit)
2584 pkt = pack_hex_byte (pkt, *altid++);
2585 return pkt;
2586 }
2587
2588
2589 static char *
2590 unpack_threadid (char *inbuf, threadref *id)
2591 {
2592 char *altref;
2593 char *limit = inbuf + BUF_THREAD_ID_SIZE;
2594 int x, y;
2595
2596 altref = (char *) id;
2597
2598 while (inbuf < limit)
2599 {
2600 x = stubhex (*inbuf++);
2601 y = stubhex (*inbuf++);
2602 *altref++ = (x << 4) | y;
2603 }
2604 return inbuf;
2605 }
2606
2607 /* Externally, threadrefs are 64 bits but internally, they are still
2608 ints. This is due to a mismatch of specifications. We would like
2609 to use 64bit thread references internally. This is an adapter
2610 function. */
2611
2612 void
2613 int_to_threadref (threadref *id, int value)
2614 {
2615 unsigned char *scan;
2616
2617 scan = (unsigned char *) id;
2618 {
2619 int i = 4;
2620 while (i--)
2621 *scan++ = 0;
2622 }
2623 *scan++ = (value >> 24) & 0xff;
2624 *scan++ = (value >> 16) & 0xff;
2625 *scan++ = (value >> 8) & 0xff;
2626 *scan++ = (value & 0xff);
2627 }
2628
2629 static int
2630 threadref_to_int (threadref *ref)
2631 {
2632 int i, value = 0;
2633 unsigned char *scan;
2634
2635 scan = *ref;
2636 scan += 4;
2637 i = 4;
2638 while (i-- > 0)
2639 value = (value << 8) | ((*scan++) & 0xff);
2640 return value;
2641 }
2642
2643 static void
2644 copy_threadref (threadref *dest, threadref *src)
2645 {
2646 int i;
2647 unsigned char *csrc, *cdest;
2648
2649 csrc = (unsigned char *) src;
2650 cdest = (unsigned char *) dest;
2651 i = 8;
2652 while (i--)
2653 *cdest++ = *csrc++;
2654 }
2655
2656 static int
2657 threadmatch (threadref *dest, threadref *src)
2658 {
2659 /* Things are broken right now, so just assume we got a match. */
2660 #if 0
2661 unsigned char *srcp, *destp;
2662 int i, result;
2663 srcp = (char *) src;
2664 destp = (char *) dest;
2665
2666 result = 1;
2667 while (i-- > 0)
2668 result &= (*srcp++ == *destp++) ? 1 : 0;
2669 return result;
2670 #endif
2671 return 1;
2672 }
2673
2674 /*
2675 threadid:1, # always request threadid
2676 context_exists:2,
2677 display:4,
2678 unique_name:8,
2679 more_display:16
2680 */
2681
2682 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2683
2684 static char *
2685 pack_threadinfo_request (char *pkt, int mode, threadref *id)
2686 {
2687 *pkt++ = 'q'; /* Info Query */
2688 *pkt++ = 'P'; /* process or thread info */
2689 pkt = pack_int (pkt, mode); /* mode */
2690 pkt = pack_threadid (pkt, id); /* threadid */
2691 *pkt = '\0'; /* terminate */
2692 return pkt;
2693 }
2694
2695 /* These values tag the fields in a thread info response packet. */
2696 /* Tagging the fields allows us to request specific fields and to
2697 add more fields as time goes by. */
2698
2699 #define TAG_THREADID 1 /* Echo the thread identifier. */
2700 #define TAG_EXISTS 2 /* Is this process defined enough to
2701 fetch registers and its stack? */
2702 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2703 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2704 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2705 the process. */
2706
2707 static int
2708 remote_unpack_thread_info_response (char *pkt, threadref *expectedref,
2709 struct gdb_ext_thread_info *info)
2710 {
2711 struct remote_state *rs = get_remote_state ();
2712 int mask, length;
2713 int tag;
2714 threadref ref;
2715 char *limit = pkt + rs->buf_size; /* Plausible parsing limit. */
2716 int retval = 1;
2717
2718 /* info->threadid = 0; FIXME: implement zero_threadref. */
2719 info->active = 0;
2720 info->display[0] = '\0';
2721 info->shortname[0] = '\0';
2722 info->more_display[0] = '\0';
2723
2724 /* Assume the characters indicating the packet type have been
2725 stripped. */
2726 pkt = unpack_int (pkt, &mask); /* arg mask */
2727 pkt = unpack_threadid (pkt, &ref);
2728
2729 if (mask == 0)
2730 warning (_("Incomplete response to threadinfo request."));
2731 if (!threadmatch (&ref, expectedref))
2732 { /* This is an answer to a different request. */
2733 warning (_("ERROR RMT Thread info mismatch."));
2734 return 0;
2735 }
2736 copy_threadref (&info->threadid, &ref);
2737
2738 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2739
2740 /* Packets are terminated with nulls. */
2741 while ((pkt < limit) && mask && *pkt)
2742 {
2743 pkt = unpack_int (pkt, &tag); /* tag */
2744 pkt = unpack_byte (pkt, &length); /* length */
2745 if (!(tag & mask)) /* Tags out of synch with mask. */
2746 {
2747 warning (_("ERROR RMT: threadinfo tag mismatch."));
2748 retval = 0;
2749 break;
2750 }
2751 if (tag == TAG_THREADID)
2752 {
2753 if (length != 16)
2754 {
2755 warning (_("ERROR RMT: length of threadid is not 16."));
2756 retval = 0;
2757 break;
2758 }
2759 pkt = unpack_threadid (pkt, &ref);
2760 mask = mask & ~TAG_THREADID;
2761 continue;
2762 }
2763 if (tag == TAG_EXISTS)
2764 {
2765 info->active = stub_unpack_int (pkt, length);
2766 pkt += length;
2767 mask = mask & ~(TAG_EXISTS);
2768 if (length > 8)
2769 {
2770 warning (_("ERROR RMT: 'exists' length too long."));
2771 retval = 0;
2772 break;
2773 }
2774 continue;
2775 }
2776 if (tag == TAG_THREADNAME)
2777 {
2778 pkt = unpack_string (pkt, &info->shortname[0], length);
2779 mask = mask & ~TAG_THREADNAME;
2780 continue;
2781 }
2782 if (tag == TAG_DISPLAY)
2783 {
2784 pkt = unpack_string (pkt, &info->display[0], length);
2785 mask = mask & ~TAG_DISPLAY;
2786 continue;
2787 }
2788 if (tag == TAG_MOREDISPLAY)
2789 {
2790 pkt = unpack_string (pkt, &info->more_display[0], length);
2791 mask = mask & ~TAG_MOREDISPLAY;
2792 continue;
2793 }
2794 warning (_("ERROR RMT: unknown thread info tag."));
2795 break; /* Not a tag we know about. */
2796 }
2797 return retval;
2798 }
2799
2800 static int
2801 remote_get_threadinfo (threadref *threadid, int fieldset, /* TAG mask */
2802 struct gdb_ext_thread_info *info)
2803 {
2804 struct remote_state *rs = get_remote_state ();
2805 int result;
2806
2807 pack_threadinfo_request (rs->buf, fieldset, threadid);
2808 putpkt (rs->buf);
2809 getpkt (&rs->buf, &rs->buf_size, 0);
2810
2811 if (rs->buf[0] == '\0')
2812 return 0;
2813
2814 result = remote_unpack_thread_info_response (rs->buf + 2,
2815 threadid, info);
2816 return result;
2817 }
2818
2819 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2820
2821 static char *
2822 pack_threadlist_request (char *pkt, int startflag, int threadcount,
2823 threadref *nextthread)
2824 {
2825 *pkt++ = 'q'; /* info query packet */
2826 *pkt++ = 'L'; /* Process LIST or threadLIST request */
2827 pkt = pack_nibble (pkt, startflag); /* initflag 1 bytes */
2828 pkt = pack_hex_byte (pkt, threadcount); /* threadcount 2 bytes */
2829 pkt = pack_threadid (pkt, nextthread); /* 64 bit thread identifier */
2830 *pkt = '\0';
2831 return pkt;
2832 }
2833
2834 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2835
2836 static int
2837 parse_threadlist_response (char *pkt, int result_limit,
2838 threadref *original_echo, threadref *resultlist,
2839 int *doneflag)
2840 {
2841 struct remote_state *rs = get_remote_state ();
2842 char *limit;
2843 int count, resultcount, done;
2844
2845 resultcount = 0;
2846 /* Assume the 'q' and 'M chars have been stripped. */
2847 limit = pkt + (rs->buf_size - BUF_THREAD_ID_SIZE);
2848 /* done parse past here */
2849 pkt = unpack_byte (pkt, &count); /* count field */
2850 pkt = unpack_nibble (pkt, &done);
2851 /* The first threadid is the argument threadid. */
2852 pkt = unpack_threadid (pkt, original_echo); /* should match query packet */
2853 while ((count-- > 0) && (pkt < limit))
2854 {
2855 pkt = unpack_threadid (pkt, resultlist++);
2856 if (resultcount++ >= result_limit)
2857 break;
2858 }
2859 if (doneflag)
2860 *doneflag = done;
2861 return resultcount;
2862 }
2863
2864 /* Fetch the next batch of threads from the remote. Returns -1 if the
2865 qL packet is not supported, 0 on error and 1 on success. */
2866
2867 static int
2868 remote_get_threadlist (int startflag, threadref *nextthread, int result_limit,
2869 int *done, int *result_count, threadref *threadlist)
2870 {
2871 struct remote_state *rs = get_remote_state ();
2872 int result = 1;
2873
2874 /* Trancate result limit to be smaller than the packet size. */
2875 if ((((result_limit + 1) * BUF_THREAD_ID_SIZE) + 10)
2876 >= get_remote_packet_size ())
2877 result_limit = (get_remote_packet_size () / BUF_THREAD_ID_SIZE) - 2;
2878
2879 pack_threadlist_request (rs->buf, startflag, result_limit, nextthread);
2880 putpkt (rs->buf);
2881 getpkt (&rs->buf, &rs->buf_size, 0);
2882 if (*rs->buf == '\0')
2883 {
2884 /* Packet not supported. */
2885 return -1;
2886 }
2887
2888 *result_count =
2889 parse_threadlist_response (rs->buf + 2, result_limit,
2890 &rs->echo_nextthread, threadlist, done);
2891
2892 if (!threadmatch (&rs->echo_nextthread, nextthread))
2893 {
2894 /* FIXME: This is a good reason to drop the packet. */
2895 /* Possably, there is a duplicate response. */
2896 /* Possabilities :
2897 retransmit immediatly - race conditions
2898 retransmit after timeout - yes
2899 exit
2900 wait for packet, then exit
2901 */
2902 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2903 return 0; /* I choose simply exiting. */
2904 }
2905 if (*result_count <= 0)
2906 {
2907 if (*done != 1)
2908 {
2909 warning (_("RMT ERROR : failed to get remote thread list."));
2910 result = 0;
2911 }
2912 return result; /* break; */
2913 }
2914 if (*result_count > result_limit)
2915 {
2916 *result_count = 0;
2917 warning (_("RMT ERROR: threadlist response longer than requested."));
2918 return 0;
2919 }
2920 return result;
2921 }
2922
2923 /* Fetch the list of remote threads, with the qL packet, and call
2924 STEPFUNCTION for each thread found. Stops iterating and returns 1
2925 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2926 STEPFUNCTION returns false. If the packet is not supported,
2927 returns -1. */
2928
2929 static int
2930 remote_threadlist_iterator (rmt_thread_action stepfunction, void *context,
2931 int looplimit)
2932 {
2933 struct remote_state *rs = get_remote_state ();
2934 int done, i, result_count;
2935 int startflag = 1;
2936 int result = 1;
2937 int loopcount = 0;
2938
2939 done = 0;
2940 while (!done)
2941 {
2942 if (loopcount++ > looplimit)
2943 {
2944 result = 0;
2945 warning (_("Remote fetch threadlist -infinite loop-."));
2946 break;
2947 }
2948 result = remote_get_threadlist (startflag, &rs->nextthread,
2949 MAXTHREADLISTRESULTS,
2950 &done, &result_count,
2951 rs->resultthreadlist);
2952 if (result <= 0)
2953 break;
2954 /* Clear for later iterations. */
2955 startflag = 0;
2956 /* Setup to resume next batch of thread references, set nextthread. */
2957 if (result_count >= 1)
2958 copy_threadref (&rs->nextthread,
2959 &rs->resultthreadlist[result_count - 1]);
2960 i = 0;
2961 while (result_count--)
2962 {
2963 if (!(*stepfunction) (&rs->resultthreadlist[i++], context))
2964 {
2965 result = 0;
2966 break;
2967 }
2968 }
2969 }
2970 return result;
2971 }
2972
2973 /* A thread found on the remote target. */
2974
2975 typedef struct thread_item
2976 {
2977 /* The thread's PTID. */
2978 ptid_t ptid;
2979
2980 /* The thread's extra info. May be NULL. */
2981 char *extra;
2982
2983 /* The thread's name. May be NULL. */
2984 char *name;
2985
2986 /* The core the thread was running on. -1 if not known. */
2987 int core;
2988
2989 /* The thread handle associated with the thread. */
2990 gdb::byte_vector *thread_handle;
2991
2992 } thread_item_t;
2993 DEF_VEC_O(thread_item_t);
2994
2995 /* Context passed around to the various methods listing remote
2996 threads. As new threads are found, they're added to the ITEMS
2997 vector. */
2998
2999 struct threads_listing_context
3000 {
3001 /* The threads found on the remote target. */
3002 VEC (thread_item_t) *items;
3003 };
3004
3005 /* Discard the contents of the constructed thread listing context. */
3006
3007 static void
3008 clear_threads_listing_context (void *p)
3009 {
3010 struct threads_listing_context *context
3011 = (struct threads_listing_context *) p;
3012 int i;
3013 struct thread_item *item;
3014
3015 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
3016 {
3017 xfree (item->extra);
3018 xfree (item->name);
3019 delete item->thread_handle;
3020 }
3021
3022 VEC_free (thread_item_t, context->items);
3023 }
3024
3025 /* Remove the thread specified as the related_pid field of WS
3026 from the CONTEXT list. */
3027
3028 static void
3029 threads_listing_context_remove (struct target_waitstatus *ws,
3030 struct threads_listing_context *context)
3031 {
3032 struct thread_item *item;
3033 int i;
3034 ptid_t child_ptid = ws->value.related_pid;
3035
3036 for (i = 0; VEC_iterate (thread_item_t, context->items, i, item); ++i)
3037 {
3038 if (ptid_equal (item->ptid, child_ptid))
3039 {
3040 VEC_ordered_remove (thread_item_t, context->items, i);
3041 break;
3042 }
3043 }
3044 }
3045
3046 static int
3047 remote_newthread_step (threadref *ref, void *data)
3048 {
3049 struct threads_listing_context *context
3050 = (struct threads_listing_context *) data;
3051 struct thread_item item;
3052 int pid = ptid_get_pid (inferior_ptid);
3053
3054 item.ptid = ptid_build (pid, threadref_to_int (ref), 0);
3055 item.core = -1;
3056 item.name = NULL;
3057 item.extra = NULL;
3058 item.thread_handle = nullptr;
3059
3060 VEC_safe_push (thread_item_t, context->items, &item);
3061
3062 return 1; /* continue iterator */
3063 }
3064
3065 #define CRAZY_MAX_THREADS 1000
3066
3067 static ptid_t
3068 remote_current_thread (ptid_t oldpid)
3069 {
3070 struct remote_state *rs = get_remote_state ();
3071
3072 putpkt ("qC");
3073 getpkt (&rs->buf, &rs->buf_size, 0);
3074 if (rs->buf[0] == 'Q' && rs->buf[1] == 'C')
3075 {
3076 const char *obuf;
3077 ptid_t result;
3078
3079 result = read_ptid (&rs->buf[2], &obuf);
3080 if (*obuf != '\0' && remote_debug)
3081 fprintf_unfiltered (gdb_stdlog,
3082 "warning: garbage in qC reply\n");
3083
3084 return result;
3085 }
3086 else
3087 return oldpid;
3088 }
3089
3090 /* List remote threads using the deprecated qL packet. */
3091
3092 static int
3093 remote_get_threads_with_ql (struct target_ops *ops,
3094 struct threads_listing_context *context)
3095 {
3096 if (remote_threadlist_iterator (remote_newthread_step, context,
3097 CRAZY_MAX_THREADS) >= 0)
3098 return 1;
3099
3100 return 0;
3101 }
3102
3103 #if defined(HAVE_LIBEXPAT)
3104
3105 static void
3106 start_thread (struct gdb_xml_parser *parser,
3107 const struct gdb_xml_element *element,
3108 void *user_data, VEC(gdb_xml_value_s) *attributes)
3109 {
3110 struct threads_listing_context *data
3111 = (struct threads_listing_context *) user_data;
3112
3113 struct thread_item item;
3114 char *id;
3115 struct gdb_xml_value *attr;
3116
3117 id = (char *) xml_find_attribute (attributes, "id")->value;
3118 item.ptid = read_ptid (id, NULL);
3119
3120 attr = xml_find_attribute (attributes, "core");
3121 if (attr != NULL)
3122 item.core = *(ULONGEST *) attr->value;
3123 else
3124 item.core = -1;
3125
3126 attr = xml_find_attribute (attributes, "name");
3127 item.name = attr != NULL ? xstrdup ((const char *) attr->value) : NULL;
3128
3129 attr = xml_find_attribute (attributes, "handle");
3130 if (attr != NULL)
3131 {
3132 item.thread_handle = new gdb::byte_vector
3133 (strlen ((const char *) attr->value) / 2);
3134 hex2bin ((const char *) attr->value, item.thread_handle->data (),
3135 item.thread_handle->size ());
3136 }
3137 else
3138 item.thread_handle = nullptr;
3139
3140 item.extra = 0;
3141
3142 VEC_safe_push (thread_item_t, data->items, &item);
3143 }
3144
3145 static void
3146 end_thread (struct gdb_xml_parser *parser,
3147 const struct gdb_xml_element *element,
3148 void *user_data, const char *body_text)
3149 {
3150 struct threads_listing_context *data
3151 = (struct threads_listing_context *) user_data;
3152
3153 if (body_text && *body_text)
3154 VEC_last (thread_item_t, data->items)->extra = xstrdup (body_text);
3155 }
3156
3157 const struct gdb_xml_attribute thread_attributes[] = {
3158 { "id", GDB_XML_AF_NONE, NULL, NULL },
3159 { "core", GDB_XML_AF_OPTIONAL, gdb_xml_parse_attr_ulongest, NULL },
3160 { "name", GDB_XML_AF_OPTIONAL, NULL, NULL },
3161 { "handle", GDB_XML_AF_OPTIONAL, NULL, NULL },
3162 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3163 };
3164
3165 const struct gdb_xml_element thread_children[] = {
3166 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3167 };
3168
3169 const struct gdb_xml_element threads_children[] = {
3170 { "thread", thread_attributes, thread_children,
3171 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3172 start_thread, end_thread },
3173 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3174 };
3175
3176 const struct gdb_xml_element threads_elements[] = {
3177 { "threads", NULL, threads_children,
3178 GDB_XML_EF_NONE, NULL, NULL },
3179 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3180 };
3181
3182 #endif
3183
3184 /* List remote threads using qXfer:threads:read. */
3185
3186 static int
3187 remote_get_threads_with_qxfer (struct target_ops *ops,
3188 struct threads_listing_context *context)
3189 {
3190 #if defined(HAVE_LIBEXPAT)
3191 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3192 {
3193 gdb::unique_xmalloc_ptr<char> xml
3194 = target_read_stralloc (ops, TARGET_OBJECT_THREADS, NULL);
3195
3196 if (xml != NULL && *xml != '\0')
3197 {
3198 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3199 threads_elements, xml.get (), context);
3200 }
3201
3202 return 1;
3203 }
3204 #endif
3205
3206 return 0;
3207 }
3208
3209 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3210
3211 static int
3212 remote_get_threads_with_qthreadinfo (struct target_ops *ops,
3213 struct threads_listing_context *context)
3214 {
3215 struct remote_state *rs = get_remote_state ();
3216
3217 if (rs->use_threadinfo_query)
3218 {
3219 const char *bufp;
3220
3221 putpkt ("qfThreadInfo");
3222 getpkt (&rs->buf, &rs->buf_size, 0);
3223 bufp = rs->buf;
3224 if (bufp[0] != '\0') /* q packet recognized */
3225 {
3226 while (*bufp++ == 'm') /* reply contains one or more TID */
3227 {
3228 do
3229 {
3230 struct thread_item item;
3231
3232 item.ptid = read_ptid (bufp, &bufp);
3233 item.core = -1;
3234 item.name = NULL;
3235 item.extra = NULL;
3236 item.thread_handle = nullptr;
3237
3238 VEC_safe_push (thread_item_t, context->items, &item);
3239 }
3240 while (*bufp++ == ','); /* comma-separated list */
3241 putpkt ("qsThreadInfo");
3242 getpkt (&rs->buf, &rs->buf_size, 0);
3243 bufp = rs->buf;
3244 }
3245 return 1;
3246 }
3247 else
3248 {
3249 /* Packet not recognized. */
3250 rs->use_threadinfo_query = 0;
3251 }
3252 }
3253
3254 return 0;
3255 }
3256
3257 /* Implement the to_update_thread_list function for the remote
3258 targets. */
3259
3260 static void
3261 remote_update_thread_list (struct target_ops *ops)
3262 {
3263 struct threads_listing_context context;
3264 struct cleanup *old_chain;
3265 int got_list = 0;
3266
3267 context.items = NULL;
3268 old_chain = make_cleanup (clear_threads_listing_context, &context);
3269
3270 /* We have a few different mechanisms to fetch the thread list. Try
3271 them all, starting with the most preferred one first, falling
3272 back to older methods. */
3273 if (remote_get_threads_with_qxfer (ops, &context)
3274 || remote_get_threads_with_qthreadinfo (ops, &context)
3275 || remote_get_threads_with_ql (ops, &context))
3276 {
3277 int i;
3278 struct thread_item *item;
3279 struct thread_info *tp, *tmp;
3280
3281 got_list = 1;
3282
3283 if (VEC_empty (thread_item_t, context.items)
3284 && remote_thread_always_alive (ops, inferior_ptid))
3285 {
3286 /* Some targets don't really support threads, but still
3287 reply an (empty) thread list in response to the thread
3288 listing packets, instead of replying "packet not
3289 supported". Exit early so we don't delete the main
3290 thread. */
3291 do_cleanups (old_chain);
3292 return;
3293 }
3294
3295 /* CONTEXT now holds the current thread list on the remote
3296 target end. Delete GDB-side threads no longer found on the
3297 target. */
3298 ALL_THREADS_SAFE (tp, tmp)
3299 {
3300 for (i = 0;
3301 VEC_iterate (thread_item_t, context.items, i, item);
3302 ++i)
3303 {
3304 if (ptid_equal (item->ptid, tp->ptid))
3305 break;
3306 }
3307
3308 if (i == VEC_length (thread_item_t, context.items))
3309 {
3310 /* Not found. */
3311 delete_thread (tp->ptid);
3312 }
3313 }
3314
3315 /* Remove any unreported fork child threads from CONTEXT so
3316 that we don't interfere with follow fork, which is where
3317 creation of such threads is handled. */
3318 remove_new_fork_children (&context);
3319
3320 /* And now add threads we don't know about yet to our list. */
3321 for (i = 0;
3322 VEC_iterate (thread_item_t, context.items, i, item);
3323 ++i)
3324 {
3325 if (!ptid_equal (item->ptid, null_ptid))
3326 {
3327 struct private_thread_info *info;
3328 /* In non-stop mode, we assume new found threads are
3329 executing until proven otherwise with a stop reply.
3330 In all-stop, we can only get here if all threads are
3331 stopped. */
3332 int executing = target_is_non_stop_p () ? 1 : 0;
3333
3334 remote_notice_new_inferior (item->ptid, executing);
3335
3336 info = get_private_info_ptid (item->ptid);
3337 info->core = item->core;
3338 info->extra = item->extra;
3339 item->extra = NULL;
3340 info->name = item->name;
3341 item->name = NULL;
3342 info->thread_handle = item->thread_handle;
3343 item->thread_handle = nullptr;
3344 }
3345 }
3346 }
3347
3348 if (!got_list)
3349 {
3350 /* If no thread listing method is supported, then query whether
3351 each known thread is alive, one by one, with the T packet.
3352 If the target doesn't support threads at all, then this is a
3353 no-op. See remote_thread_alive. */
3354 prune_threads ();
3355 }
3356
3357 do_cleanups (old_chain);
3358 }
3359
3360 /*
3361 * Collect a descriptive string about the given thread.
3362 * The target may say anything it wants to about the thread
3363 * (typically info about its blocked / runnable state, name, etc.).
3364 * This string will appear in the info threads display.
3365 *
3366 * Optional: targets are not required to implement this function.
3367 */
3368
3369 static const char *
3370 remote_threads_extra_info (struct target_ops *self, struct thread_info *tp)
3371 {
3372 struct remote_state *rs = get_remote_state ();
3373 int result;
3374 int set;
3375 threadref id;
3376 struct gdb_ext_thread_info threadinfo;
3377 static char display_buf[100]; /* arbitrary... */
3378 int n = 0; /* position in display_buf */
3379
3380 if (rs->remote_desc == 0) /* paranoia */
3381 internal_error (__FILE__, __LINE__,
3382 _("remote_threads_extra_info"));
3383
3384 if (ptid_equal (tp->ptid, magic_null_ptid)
3385 || (ptid_get_pid (tp->ptid) != 0 && ptid_get_lwp (tp->ptid) == 0))
3386 /* This is the main thread which was added by GDB. The remote
3387 server doesn't know about it. */
3388 return NULL;
3389
3390 if (packet_support (PACKET_qXfer_threads) == PACKET_ENABLE)
3391 {
3392 struct thread_info *info = find_thread_ptid (tp->ptid);
3393
3394 if (info && info->priv)
3395 return info->priv->extra;
3396 else
3397 return NULL;
3398 }
3399
3400 if (rs->use_threadextra_query)
3401 {
3402 char *b = rs->buf;
3403 char *endb = rs->buf + get_remote_packet_size ();
3404
3405 xsnprintf (b, endb - b, "qThreadExtraInfo,");
3406 b += strlen (b);
3407 write_ptid (b, endb, tp->ptid);
3408
3409 putpkt (rs->buf);
3410 getpkt (&rs->buf, &rs->buf_size, 0);
3411 if (rs->buf[0] != 0)
3412 {
3413 n = std::min (strlen (rs->buf) / 2, sizeof (display_buf));
3414 result = hex2bin (rs->buf, (gdb_byte *) display_buf, n);
3415 display_buf [result] = '\0';
3416 return display_buf;
3417 }
3418 }
3419
3420 /* If the above query fails, fall back to the old method. */
3421 rs->use_threadextra_query = 0;
3422 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
3423 | TAG_MOREDISPLAY | TAG_DISPLAY;
3424 int_to_threadref (&id, ptid_get_lwp (tp->ptid));
3425 if (remote_get_threadinfo (&id, set, &threadinfo))
3426 if (threadinfo.active)
3427 {
3428 if (*threadinfo.shortname)
3429 n += xsnprintf (&display_buf[0], sizeof (display_buf) - n,
3430 " Name: %s,", threadinfo.shortname);
3431 if (*threadinfo.display)
3432 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
3433 " State: %s,", threadinfo.display);
3434 if (*threadinfo.more_display)
3435 n += xsnprintf (&display_buf[n], sizeof (display_buf) - n,
3436 " Priority: %s", threadinfo.more_display);
3437
3438 if (n > 0)
3439 {
3440 /* For purely cosmetic reasons, clear up trailing commas. */
3441 if (',' == display_buf[n-1])
3442 display_buf[n-1] = ' ';
3443 return display_buf;
3444 }
3445 }
3446 return NULL;
3447 }
3448 \f
3449
3450 static int
3451 remote_static_tracepoint_marker_at (struct target_ops *self, CORE_ADDR addr,
3452 struct static_tracepoint_marker *marker)
3453 {
3454 struct remote_state *rs = get_remote_state ();
3455 char *p = rs->buf;
3456
3457 xsnprintf (p, get_remote_packet_size (), "qTSTMat:");
3458 p += strlen (p);
3459 p += hexnumstr (p, addr);
3460 putpkt (rs->buf);
3461 getpkt (&rs->buf, &rs->buf_size, 0);
3462 p = rs->buf;
3463
3464 if (*p == 'E')
3465 error (_("Remote failure reply: %s"), p);
3466
3467 if (*p++ == 'm')
3468 {
3469 parse_static_tracepoint_marker_definition (p, NULL, marker);
3470 return 1;
3471 }
3472
3473 return 0;
3474 }
3475
3476 static VEC(static_tracepoint_marker_p) *
3477 remote_static_tracepoint_markers_by_strid (struct target_ops *self,
3478 const char *strid)
3479 {
3480 struct remote_state *rs = get_remote_state ();
3481 VEC(static_tracepoint_marker_p) *markers = NULL;
3482 struct static_tracepoint_marker *marker = NULL;
3483 struct cleanup *old_chain;
3484 const char *p;
3485
3486 /* Ask for a first packet of static tracepoint marker
3487 definition. */
3488 putpkt ("qTfSTM");
3489 getpkt (&rs->buf, &rs->buf_size, 0);
3490 p = rs->buf;
3491 if (*p == 'E')
3492 error (_("Remote failure reply: %s"), p);
3493
3494 old_chain = make_cleanup (free_current_marker, &marker);
3495
3496 while (*p++ == 'm')
3497 {
3498 if (marker == NULL)
3499 marker = XCNEW (struct static_tracepoint_marker);
3500
3501 do
3502 {
3503 parse_static_tracepoint_marker_definition (p, &p, marker);
3504
3505 if (strid == NULL || strcmp (strid, marker->str_id) == 0)
3506 {
3507 VEC_safe_push (static_tracepoint_marker_p,
3508 markers, marker);
3509 marker = NULL;
3510 }
3511 else
3512 {
3513 release_static_tracepoint_marker (marker);
3514 memset (marker, 0, sizeof (*marker));
3515 }
3516 }
3517 while (*p++ == ','); /* comma-separated list */
3518 /* Ask for another packet of static tracepoint definition. */
3519 putpkt ("qTsSTM");
3520 getpkt (&rs->buf, &rs->buf_size, 0);
3521 p = rs->buf;
3522 }
3523
3524 do_cleanups (old_chain);
3525 return markers;
3526 }
3527
3528 \f
3529 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3530
3531 static ptid_t
3532 remote_get_ada_task_ptid (struct target_ops *self, long lwp, long thread)
3533 {
3534 return ptid_build (ptid_get_pid (inferior_ptid), lwp, 0);
3535 }
3536 \f
3537
3538 /* Restart the remote side; this is an extended protocol operation. */
3539
3540 static void
3541 extended_remote_restart (void)
3542 {
3543 struct remote_state *rs = get_remote_state ();
3544
3545 /* Send the restart command; for reasons I don't understand the
3546 remote side really expects a number after the "R". */
3547 xsnprintf (rs->buf, get_remote_packet_size (), "R%x", 0);
3548 putpkt (rs->buf);
3549
3550 remote_fileio_reset ();
3551 }
3552 \f
3553 /* Clean up connection to a remote debugger. */
3554
3555 static void
3556 remote_close (struct target_ops *self)
3557 {
3558 struct remote_state *rs = get_remote_state ();
3559
3560 if (rs->remote_desc == NULL)
3561 return; /* already closed */
3562
3563 /* Make sure we leave stdin registered in the event loop. */
3564 remote_terminal_ours (self);
3565
3566 serial_close (rs->remote_desc);
3567 rs->remote_desc = NULL;
3568
3569 /* We don't have a connection to the remote stub anymore. Get rid
3570 of all the inferiors and their threads we were controlling.
3571 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3572 will be unable to find the thread corresponding to (pid, 0, 0). */
3573 inferior_ptid = null_ptid;
3574 discard_all_inferiors ();
3575
3576 /* We are closing the remote target, so we should discard
3577 everything of this target. */
3578 discard_pending_stop_replies_in_queue (rs);
3579
3580 if (remote_async_inferior_event_token)
3581 delete_async_event_handler (&remote_async_inferior_event_token);
3582
3583 remote_notif_state_xfree (rs->notif_state);
3584
3585 trace_reset_local_state ();
3586 }
3587
3588 /* Query the remote side for the text, data and bss offsets. */
3589
3590 static void
3591 get_offsets (void)
3592 {
3593 struct remote_state *rs = get_remote_state ();
3594 char *buf;
3595 char *ptr;
3596 int lose, num_segments = 0, do_sections, do_segments;
3597 CORE_ADDR text_addr, data_addr, bss_addr, segments[2];
3598 struct section_offsets *offs;
3599 struct symfile_segment_data *data;
3600
3601 if (symfile_objfile == NULL)
3602 return;
3603
3604 putpkt ("qOffsets");
3605 getpkt (&rs->buf, &rs->buf_size, 0);
3606 buf = rs->buf;
3607
3608 if (buf[0] == '\000')
3609 return; /* Return silently. Stub doesn't support
3610 this command. */
3611 if (buf[0] == 'E')
3612 {
3613 warning (_("Remote failure reply: %s"), buf);
3614 return;
3615 }
3616
3617 /* Pick up each field in turn. This used to be done with scanf, but
3618 scanf will make trouble if CORE_ADDR size doesn't match
3619 conversion directives correctly. The following code will work
3620 with any size of CORE_ADDR. */
3621 text_addr = data_addr = bss_addr = 0;
3622 ptr = buf;
3623 lose = 0;
3624
3625 if (startswith (ptr, "Text="))
3626 {
3627 ptr += 5;
3628 /* Don't use strtol, could lose on big values. */
3629 while (*ptr && *ptr != ';')
3630 text_addr = (text_addr << 4) + fromhex (*ptr++);
3631
3632 if (startswith (ptr, ";Data="))
3633 {
3634 ptr += 6;
3635 while (*ptr && *ptr != ';')
3636 data_addr = (data_addr << 4) + fromhex (*ptr++);
3637 }
3638 else
3639 lose = 1;
3640
3641 if (!lose && startswith (ptr, ";Bss="))
3642 {
3643 ptr += 5;
3644 while (*ptr && *ptr != ';')
3645 bss_addr = (bss_addr << 4) + fromhex (*ptr++);
3646
3647 if (bss_addr != data_addr)
3648 warning (_("Target reported unsupported offsets: %s"), buf);
3649 }
3650 else
3651 lose = 1;
3652 }
3653 else if (startswith (ptr, "TextSeg="))
3654 {
3655 ptr += 8;
3656 /* Don't use strtol, could lose on big values. */
3657 while (*ptr && *ptr != ';')
3658 text_addr = (text_addr << 4) + fromhex (*ptr++);
3659 num_segments = 1;
3660
3661 if (startswith (ptr, ";DataSeg="))
3662 {
3663 ptr += 9;
3664 while (*ptr && *ptr != ';')
3665 data_addr = (data_addr << 4) + fromhex (*ptr++);
3666 num_segments++;
3667 }
3668 }
3669 else
3670 lose = 1;
3671
3672 if (lose)
3673 error (_("Malformed response to offset query, %s"), buf);
3674 else if (*ptr != '\0')
3675 warning (_("Target reported unsupported offsets: %s"), buf);
3676
3677 offs = ((struct section_offsets *)
3678 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections)));
3679 memcpy (offs, symfile_objfile->section_offsets,
3680 SIZEOF_N_SECTION_OFFSETS (symfile_objfile->num_sections));
3681
3682 data = get_symfile_segment_data (symfile_objfile->obfd);
3683 do_segments = (data != NULL);
3684 do_sections = num_segments == 0;
3685
3686 if (num_segments > 0)
3687 {
3688 segments[0] = text_addr;
3689 segments[1] = data_addr;
3690 }
3691 /* If we have two segments, we can still try to relocate everything
3692 by assuming that the .text and .data offsets apply to the whole
3693 text and data segments. Convert the offsets given in the packet
3694 to base addresses for symfile_map_offsets_to_segments. */
3695 else if (data && data->num_segments == 2)
3696 {
3697 segments[0] = data->segment_bases[0] + text_addr;
3698 segments[1] = data->segment_bases[1] + data_addr;
3699 num_segments = 2;
3700 }
3701 /* If the object file has only one segment, assume that it is text
3702 rather than data; main programs with no writable data are rare,
3703 but programs with no code are useless. Of course the code might
3704 have ended up in the data segment... to detect that we would need
3705 the permissions here. */
3706 else if (data && data->num_segments == 1)
3707 {
3708 segments[0] = data->segment_bases[0] + text_addr;
3709 num_segments = 1;
3710 }
3711 /* There's no way to relocate by segment. */
3712 else
3713 do_segments = 0;
3714
3715 if (do_segments)
3716 {
3717 int ret = symfile_map_offsets_to_segments (symfile_objfile->obfd, data,
3718 offs, num_segments, segments);
3719
3720 if (ret == 0 && !do_sections)
3721 error (_("Can not handle qOffsets TextSeg "
3722 "response with this symbol file"));
3723
3724 if (ret > 0)
3725 do_sections = 0;
3726 }
3727
3728 if (data)
3729 free_symfile_segment_data (data);
3730
3731 if (do_sections)
3732 {
3733 offs->offsets[SECT_OFF_TEXT (symfile_objfile)] = text_addr;
3734
3735 /* This is a temporary kludge to force data and bss to use the
3736 same offsets because that's what nlmconv does now. The real
3737 solution requires changes to the stub and remote.c that I
3738 don't have time to do right now. */
3739
3740 offs->offsets[SECT_OFF_DATA (symfile_objfile)] = data_addr;
3741 offs->offsets[SECT_OFF_BSS (symfile_objfile)] = data_addr;
3742 }
3743
3744 objfile_relocate (symfile_objfile, offs);
3745 }
3746
3747 /* Send interrupt_sequence to remote target. */
3748 static void
3749 send_interrupt_sequence (void)
3750 {
3751 struct remote_state *rs = get_remote_state ();
3752
3753 if (interrupt_sequence_mode == interrupt_sequence_control_c)
3754 remote_serial_write ("\x03", 1);
3755 else if (interrupt_sequence_mode == interrupt_sequence_break)
3756 serial_send_break (rs->remote_desc);
3757 else if (interrupt_sequence_mode == interrupt_sequence_break_g)
3758 {
3759 serial_send_break (rs->remote_desc);
3760 remote_serial_write ("g", 1);
3761 }
3762 else
3763 internal_error (__FILE__, __LINE__,
3764 _("Invalid value for interrupt_sequence_mode: %s."),
3765 interrupt_sequence_mode);
3766 }
3767
3768
3769 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3770 and extract the PTID. Returns NULL_PTID if not found. */
3771
3772 static ptid_t
3773 stop_reply_extract_thread (char *stop_reply)
3774 {
3775 if (stop_reply[0] == 'T' && strlen (stop_reply) > 3)
3776 {
3777 const char *p;
3778
3779 /* Txx r:val ; r:val (...) */
3780 p = &stop_reply[3];
3781
3782 /* Look for "register" named "thread". */
3783 while (*p != '\0')
3784 {
3785 const char *p1;
3786
3787 p1 = strchr (p, ':');
3788 if (p1 == NULL)
3789 return null_ptid;
3790
3791 if (strncmp (p, "thread", p1 - p) == 0)
3792 return read_ptid (++p1, &p);
3793
3794 p1 = strchr (p, ';');
3795 if (p1 == NULL)
3796 return null_ptid;
3797 p1++;
3798
3799 p = p1;
3800 }
3801 }
3802
3803 return null_ptid;
3804 }
3805
3806 /* Determine the remote side's current thread. If we have a stop
3807 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3808 "thread" register we can extract the current thread from. If not,
3809 ask the remote which is the current thread with qC. The former
3810 method avoids a roundtrip. */
3811
3812 static ptid_t
3813 get_current_thread (char *wait_status)
3814 {
3815 ptid_t ptid = null_ptid;
3816
3817 /* Note we don't use remote_parse_stop_reply as that makes use of
3818 the target architecture, which we haven't yet fully determined at
3819 this point. */
3820 if (wait_status != NULL)
3821 ptid = stop_reply_extract_thread (wait_status);
3822 if (ptid_equal (ptid, null_ptid))
3823 ptid = remote_current_thread (inferior_ptid);
3824
3825 return ptid;
3826 }
3827
3828 /* Query the remote target for which is the current thread/process,
3829 add it to our tables, and update INFERIOR_PTID. The caller is
3830 responsible for setting the state such that the remote end is ready
3831 to return the current thread.
3832
3833 This function is called after handling the '?' or 'vRun' packets,
3834 whose response is a stop reply from which we can also try
3835 extracting the thread. If the target doesn't support the explicit
3836 qC query, we infer the current thread from that stop reply, passed
3837 in in WAIT_STATUS, which may be NULL. */
3838
3839 static void
3840 add_current_inferior_and_thread (char *wait_status)
3841 {
3842 struct remote_state *rs = get_remote_state ();
3843 int fake_pid_p = 0;
3844
3845 inferior_ptid = null_ptid;
3846
3847 /* Now, if we have thread information, update inferior_ptid. */
3848 ptid_t curr_ptid = get_current_thread (wait_status);
3849
3850 if (curr_ptid != null_ptid)
3851 {
3852 if (!remote_multi_process_p (rs))
3853 fake_pid_p = 1;
3854 }
3855 else
3856 {
3857 /* Without this, some commands which require an active target
3858 (such as kill) won't work. This variable serves (at least)
3859 double duty as both the pid of the target process (if it has
3860 such), and as a flag indicating that a target is active. */
3861 curr_ptid = magic_null_ptid;
3862 fake_pid_p = 1;
3863 }
3864
3865 remote_add_inferior (fake_pid_p, ptid_get_pid (curr_ptid), -1, 1);
3866
3867 /* Add the main thread and switch to it. Don't try reading
3868 registers yet, since we haven't fetched the target description
3869 yet. */
3870 thread_info *tp = add_thread_silent (curr_ptid);
3871 switch_to_thread_no_regs (tp);
3872 }
3873
3874 /* Print info about a thread that was found already stopped on
3875 connection. */
3876
3877 static void
3878 print_one_stopped_thread (struct thread_info *thread)
3879 {
3880 struct target_waitstatus *ws = &thread->suspend.waitstatus;
3881
3882 switch_to_thread (thread->ptid);
3883 stop_pc = get_frame_pc (get_current_frame ());
3884 set_current_sal_from_frame (get_current_frame ());
3885
3886 thread->suspend.waitstatus_pending_p = 0;
3887
3888 if (ws->kind == TARGET_WAITKIND_STOPPED)
3889 {
3890 enum gdb_signal sig = ws->value.sig;
3891
3892 if (signal_print_state (sig))
3893 observer_notify_signal_received (sig);
3894 }
3895 observer_notify_normal_stop (NULL, 1);
3896 }
3897
3898 /* Process all initial stop replies the remote side sent in response
3899 to the ? packet. These indicate threads that were already stopped
3900 on initial connection. We mark these threads as stopped and print
3901 their current frame before giving the user the prompt. */
3902
3903 static void
3904 process_initial_stop_replies (int from_tty)
3905 {
3906 int pending_stop_replies = stop_reply_queue_length ();
3907 struct inferior *inf;
3908 struct thread_info *thread;
3909 struct thread_info *selected = NULL;
3910 struct thread_info *lowest_stopped = NULL;
3911 struct thread_info *first = NULL;
3912
3913 /* Consume the initial pending events. */
3914 while (pending_stop_replies-- > 0)
3915 {
3916 ptid_t waiton_ptid = minus_one_ptid;
3917 ptid_t event_ptid;
3918 struct target_waitstatus ws;
3919 int ignore_event = 0;
3920 struct thread_info *thread;
3921
3922 memset (&ws, 0, sizeof (ws));
3923 event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
3924 if (remote_debug)
3925 print_target_wait_results (waiton_ptid, event_ptid, &ws);
3926
3927 switch (ws.kind)
3928 {
3929 case TARGET_WAITKIND_IGNORE:
3930 case TARGET_WAITKIND_NO_RESUMED:
3931 case TARGET_WAITKIND_SIGNALLED:
3932 case TARGET_WAITKIND_EXITED:
3933 /* We shouldn't see these, but if we do, just ignore. */
3934 if (remote_debug)
3935 fprintf_unfiltered (gdb_stdlog, "remote: event ignored\n");
3936 ignore_event = 1;
3937 break;
3938
3939 case TARGET_WAITKIND_EXECD:
3940 xfree (ws.value.execd_pathname);
3941 break;
3942 default:
3943 break;
3944 }
3945
3946 if (ignore_event)
3947 continue;
3948
3949 thread = find_thread_ptid (event_ptid);
3950
3951 if (ws.kind == TARGET_WAITKIND_STOPPED)
3952 {
3953 enum gdb_signal sig = ws.value.sig;
3954
3955 /* Stubs traditionally report SIGTRAP as initial signal,
3956 instead of signal 0. Suppress it. */
3957 if (sig == GDB_SIGNAL_TRAP)
3958 sig = GDB_SIGNAL_0;
3959 thread->suspend.stop_signal = sig;
3960 ws.value.sig = sig;
3961 }
3962
3963 thread->suspend.waitstatus = ws;
3964
3965 if (ws.kind != TARGET_WAITKIND_STOPPED
3966 || ws.value.sig != GDB_SIGNAL_0)
3967 thread->suspend.waitstatus_pending_p = 1;
3968
3969 set_executing (event_ptid, 0);
3970 set_running (event_ptid, 0);
3971 thread->priv->vcont_resumed = 0;
3972 }
3973
3974 /* "Notice" the new inferiors before anything related to
3975 registers/memory. */
3976 ALL_INFERIORS (inf)
3977 {
3978 if (inf->pid == 0)
3979 continue;
3980
3981 inf->needs_setup = 1;
3982
3983 if (non_stop)
3984 {
3985 thread = any_live_thread_of_process (inf->pid);
3986 notice_new_inferior (thread->ptid,
3987 thread->state == THREAD_RUNNING,
3988 from_tty);
3989 }
3990 }
3991
3992 /* If all-stop on top of non-stop, pause all threads. Note this
3993 records the threads' stop pc, so must be done after "noticing"
3994 the inferiors. */
3995 if (!non_stop)
3996 {
3997 stop_all_threads ();
3998
3999 /* If all threads of an inferior were already stopped, we
4000 haven't setup the inferior yet. */
4001 ALL_INFERIORS (inf)
4002 {
4003 if (inf->pid == 0)
4004 continue;
4005
4006 if (inf->needs_setup)
4007 {
4008 thread = any_live_thread_of_process (inf->pid);
4009 switch_to_thread_no_regs (thread);
4010 setup_inferior (0);
4011 }
4012 }
4013 }
4014
4015 /* Now go over all threads that are stopped, and print their current
4016 frame. If all-stop, then if there's a signalled thread, pick
4017 that as current. */
4018 ALL_NON_EXITED_THREADS (thread)
4019 {
4020 if (first == NULL)
4021 first = thread;
4022
4023 if (!non_stop)
4024 set_running (thread->ptid, 0);
4025 else if (thread->state != THREAD_STOPPED)
4026 continue;
4027
4028 if (selected == NULL
4029 && thread->suspend.waitstatus_pending_p)
4030 selected = thread;
4031
4032 if (lowest_stopped == NULL
4033 || thread->inf->num < lowest_stopped->inf->num
4034 || thread->per_inf_num < lowest_stopped->per_inf_num)
4035 lowest_stopped = thread;
4036
4037 if (non_stop)
4038 print_one_stopped_thread (thread);
4039 }
4040
4041 /* In all-stop, we only print the status of one thread, and leave
4042 others with their status pending. */
4043 if (!non_stop)
4044 {
4045 thread = selected;
4046 if (thread == NULL)
4047 thread = lowest_stopped;
4048 if (thread == NULL)
4049 thread = first;
4050
4051 print_one_stopped_thread (thread);
4052 }
4053
4054 /* For "info program". */
4055 thread = inferior_thread ();
4056 if (thread->state == THREAD_STOPPED)
4057 set_last_target_status (inferior_ptid, thread->suspend.waitstatus);
4058 }
4059
4060 /* Start the remote connection and sync state. */
4061
4062 static void
4063 remote_start_remote (int from_tty, struct target_ops *target, int extended_p)
4064 {
4065 struct remote_state *rs = get_remote_state ();
4066 struct packet_config *noack_config;
4067 char *wait_status = NULL;
4068
4069 /* Signal other parts that we're going through the initial setup,
4070 and so things may not be stable yet. E.g., we don't try to
4071 install tracepoints until we've relocated symbols. Also, a
4072 Ctrl-C before we're connected and synced up can't interrupt the
4073 target. Instead, it offers to drop the (potentially wedged)
4074 connection. */
4075 rs->starting_up = 1;
4076
4077 QUIT;
4078
4079 if (interrupt_on_connect)
4080 send_interrupt_sequence ();
4081
4082 /* Ack any packet which the remote side has already sent. */
4083 remote_serial_write ("+", 1);
4084
4085 /* The first packet we send to the target is the optional "supported
4086 packets" request. If the target can answer this, it will tell us
4087 which later probes to skip. */
4088 remote_query_supported ();
4089
4090 /* If the stub wants to get a QAllow, compose one and send it. */
4091 if (packet_support (PACKET_QAllow) != PACKET_DISABLE)
4092 remote_set_permissions (target);
4093
4094 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4095 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4096 as a reply to known packet. For packet "vFile:setfs:" it is an
4097 invalid reply and GDB would return error in
4098 remote_hostio_set_filesystem, making remote files access impossible.
4099 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4100 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4101 {
4102 const char v_mustreplyempty[] = "vMustReplyEmpty";
4103
4104 putpkt (v_mustreplyempty);
4105 getpkt (&rs->buf, &rs->buf_size, 0);
4106 if (strcmp (rs->buf, "OK") == 0)
4107 remote_protocol_packets[PACKET_vFile_setfs].support = PACKET_DISABLE;
4108 else if (strcmp (rs->buf, "") != 0)
4109 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty,
4110 rs->buf);
4111 }
4112
4113 /* Next, we possibly activate noack mode.
4114
4115 If the QStartNoAckMode packet configuration is set to AUTO,
4116 enable noack mode if the stub reported a wish for it with
4117 qSupported.
4118
4119 If set to TRUE, then enable noack mode even if the stub didn't
4120 report it in qSupported. If the stub doesn't reply OK, the
4121 session ends with an error.
4122
4123 If FALSE, then don't activate noack mode, regardless of what the
4124 stub claimed should be the default with qSupported. */
4125
4126 noack_config = &remote_protocol_packets[PACKET_QStartNoAckMode];
4127 if (packet_config_support (noack_config) != PACKET_DISABLE)
4128 {
4129 putpkt ("QStartNoAckMode");
4130 getpkt (&rs->buf, &rs->buf_size, 0);
4131 if (packet_ok (rs->buf, noack_config) == PACKET_OK)
4132 rs->noack_mode = 1;
4133 }
4134
4135 if (extended_p)
4136 {
4137 /* Tell the remote that we are using the extended protocol. */
4138 putpkt ("!");
4139 getpkt (&rs->buf, &rs->buf_size, 0);
4140 }
4141
4142 /* Let the target know which signals it is allowed to pass down to
4143 the program. */
4144 update_signals_program_target ();
4145
4146 /* Next, if the target can specify a description, read it. We do
4147 this before anything involving memory or registers. */
4148 target_find_description ();
4149
4150 /* Next, now that we know something about the target, update the
4151 address spaces in the program spaces. */
4152 update_address_spaces ();
4153
4154 /* On OSs where the list of libraries is global to all
4155 processes, we fetch them early. */
4156 if (gdbarch_has_global_solist (target_gdbarch ()))
4157 solib_add (NULL, from_tty, auto_solib_add);
4158
4159 if (target_is_non_stop_p ())
4160 {
4161 if (packet_support (PACKET_QNonStop) != PACKET_ENABLE)
4162 error (_("Non-stop mode requested, but remote "
4163 "does not support non-stop"));
4164
4165 putpkt ("QNonStop:1");
4166 getpkt (&rs->buf, &rs->buf_size, 0);
4167
4168 if (strcmp (rs->buf, "OK") != 0)
4169 error (_("Remote refused setting non-stop mode with: %s"), rs->buf);
4170
4171 /* Find about threads and processes the stub is already
4172 controlling. We default to adding them in the running state.
4173 The '?' query below will then tell us about which threads are
4174 stopped. */
4175 remote_update_thread_list (target);
4176 }
4177 else if (packet_support (PACKET_QNonStop) == PACKET_ENABLE)
4178 {
4179 /* Don't assume that the stub can operate in all-stop mode.
4180 Request it explicitly. */
4181 putpkt ("QNonStop:0");
4182 getpkt (&rs->buf, &rs->buf_size, 0);
4183
4184 if (strcmp (rs->buf, "OK") != 0)
4185 error (_("Remote refused setting all-stop mode with: %s"), rs->buf);
4186 }
4187
4188 /* Upload TSVs regardless of whether the target is running or not. The
4189 remote stub, such as GDBserver, may have some predefined or builtin
4190 TSVs, even if the target is not running. */
4191 if (remote_get_trace_status (target, current_trace_status ()) != -1)
4192 {
4193 struct uploaded_tsv *uploaded_tsvs = NULL;
4194
4195 remote_upload_trace_state_variables (target, &uploaded_tsvs);
4196 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4197 }
4198
4199 /* Check whether the target is running now. */
4200 putpkt ("?");
4201 getpkt (&rs->buf, &rs->buf_size, 0);
4202
4203 if (!target_is_non_stop_p ())
4204 {
4205 if (rs->buf[0] == 'W' || rs->buf[0] == 'X')
4206 {
4207 if (!extended_p)
4208 error (_("The target is not running (try extended-remote?)"));
4209
4210 /* We're connected, but not running. Drop out before we
4211 call start_remote. */
4212 rs->starting_up = 0;
4213 return;
4214 }
4215 else
4216 {
4217 /* Save the reply for later. */
4218 wait_status = (char *) alloca (strlen (rs->buf) + 1);
4219 strcpy (wait_status, rs->buf);
4220 }
4221
4222 /* Fetch thread list. */
4223 target_update_thread_list ();
4224
4225 /* Let the stub know that we want it to return the thread. */
4226 set_continue_thread (minus_one_ptid);
4227
4228 if (thread_count () == 0)
4229 {
4230 /* Target has no concept of threads at all. GDB treats
4231 non-threaded target as single-threaded; add a main
4232 thread. */
4233 add_current_inferior_and_thread (wait_status);
4234 }
4235 else
4236 {
4237 /* We have thread information; select the thread the target
4238 says should be current. If we're reconnecting to a
4239 multi-threaded program, this will ideally be the thread
4240 that last reported an event before GDB disconnected. */
4241 inferior_ptid = get_current_thread (wait_status);
4242 if (ptid_equal (inferior_ptid, null_ptid))
4243 {
4244 /* Odd... The target was able to list threads, but not
4245 tell us which thread was current (no "thread"
4246 register in T stop reply?). Just pick the first
4247 thread in the thread list then. */
4248
4249 if (remote_debug)
4250 fprintf_unfiltered (gdb_stdlog,
4251 "warning: couldn't determine remote "
4252 "current thread; picking first in list.\n");
4253
4254 inferior_ptid = thread_list->ptid;
4255 }
4256 }
4257
4258 /* init_wait_for_inferior should be called before get_offsets in order
4259 to manage `inserted' flag in bp loc in a correct state.
4260 breakpoint_init_inferior, called from init_wait_for_inferior, set
4261 `inserted' flag to 0, while before breakpoint_re_set, called from
4262 start_remote, set `inserted' flag to 1. In the initialization of
4263 inferior, breakpoint_init_inferior should be called first, and then
4264 breakpoint_re_set can be called. If this order is broken, state of
4265 `inserted' flag is wrong, and cause some problems on breakpoint
4266 manipulation. */
4267 init_wait_for_inferior ();
4268
4269 get_offsets (); /* Get text, data & bss offsets. */
4270
4271 /* If we could not find a description using qXfer, and we know
4272 how to do it some other way, try again. This is not
4273 supported for non-stop; it could be, but it is tricky if
4274 there are no stopped threads when we connect. */
4275 if (remote_read_description_p (target)
4276 && gdbarch_target_desc (target_gdbarch ()) == NULL)
4277 {
4278 target_clear_description ();
4279 target_find_description ();
4280 }
4281
4282 /* Use the previously fetched status. */
4283 gdb_assert (wait_status != NULL);
4284 strcpy (rs->buf, wait_status);
4285 rs->cached_wait_status = 1;
4286
4287 start_remote (from_tty); /* Initialize gdb process mechanisms. */
4288 }
4289 else
4290 {
4291 /* Clear WFI global state. Do this before finding about new
4292 threads and inferiors, and setting the current inferior.
4293 Otherwise we would clear the proceed status of the current
4294 inferior when we want its stop_soon state to be preserved
4295 (see notice_new_inferior). */
4296 init_wait_for_inferior ();
4297
4298 /* In non-stop, we will either get an "OK", meaning that there
4299 are no stopped threads at this time; or, a regular stop
4300 reply. In the latter case, there may be more than one thread
4301 stopped --- we pull them all out using the vStopped
4302 mechanism. */
4303 if (strcmp (rs->buf, "OK") != 0)
4304 {
4305 struct notif_client *notif = &notif_client_stop;
4306
4307 /* remote_notif_get_pending_replies acks this one, and gets
4308 the rest out. */
4309 rs->notif_state->pending_event[notif_client_stop.id]
4310 = remote_notif_parse (notif, rs->buf);
4311 remote_notif_get_pending_events (notif);
4312 }
4313
4314 if (thread_count () == 0)
4315 {
4316 if (!extended_p)
4317 error (_("The target is not running (try extended-remote?)"));
4318
4319 /* We're connected, but not running. Drop out before we
4320 call start_remote. */
4321 rs->starting_up = 0;
4322 return;
4323 }
4324
4325 /* In non-stop mode, any cached wait status will be stored in
4326 the stop reply queue. */
4327 gdb_assert (wait_status == NULL);
4328
4329 /* Report all signals during attach/startup. */
4330 remote_pass_signals (target, 0, NULL);
4331
4332 /* If there are already stopped threads, mark them stopped and
4333 report their stops before giving the prompt to the user. */
4334 process_initial_stop_replies (from_tty);
4335
4336 if (target_can_async_p ())
4337 target_async (1);
4338 }
4339
4340 /* If we connected to a live target, do some additional setup. */
4341 if (target_has_execution)
4342 {
4343 if (symfile_objfile) /* No use without a symbol-file. */
4344 remote_check_symbols ();
4345 }
4346
4347 /* Possibly the target has been engaged in a trace run started
4348 previously; find out where things are at. */
4349 if (remote_get_trace_status (target, current_trace_status ()) != -1)
4350 {
4351 struct uploaded_tp *uploaded_tps = NULL;
4352
4353 if (current_trace_status ()->running)
4354 printf_filtered (_("Trace is already running on the target.\n"));
4355
4356 remote_upload_tracepoints (target, &uploaded_tps);
4357
4358 merge_uploaded_tracepoints (&uploaded_tps);
4359 }
4360
4361 /* Possibly the target has been engaged in a btrace record started
4362 previously; find out where things are at. */
4363 remote_btrace_maybe_reopen ();
4364
4365 /* The thread and inferior lists are now synchronized with the
4366 target, our symbols have been relocated, and we're merged the
4367 target's tracepoints with ours. We're done with basic start
4368 up. */
4369 rs->starting_up = 0;
4370
4371 /* Maybe breakpoints are global and need to be inserted now. */
4372 if (breakpoints_should_be_inserted_now ())
4373 insert_breakpoints ();
4374 }
4375
4376 /* Open a connection to a remote debugger.
4377 NAME is the filename used for communication. */
4378
4379 static void
4380 remote_open (const char *name, int from_tty)
4381 {
4382 remote_open_1 (name, from_tty, &remote_ops, 0);
4383 }
4384
4385 /* Open a connection to a remote debugger using the extended
4386 remote gdb protocol. NAME is the filename used for communication. */
4387
4388 static void
4389 extended_remote_open (const char *name, int from_tty)
4390 {
4391 remote_open_1 (name, from_tty, &extended_remote_ops, 1 /*extended_p */);
4392 }
4393
4394 /* Reset all packets back to "unknown support". Called when opening a
4395 new connection to a remote target. */
4396
4397 static void
4398 reset_all_packet_configs_support (void)
4399 {
4400 int i;
4401
4402 for (i = 0; i < PACKET_MAX; i++)
4403 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4404 }
4405
4406 /* Initialize all packet configs. */
4407
4408 static void
4409 init_all_packet_configs (void)
4410 {
4411 int i;
4412
4413 for (i = 0; i < PACKET_MAX; i++)
4414 {
4415 remote_protocol_packets[i].detect = AUTO_BOOLEAN_AUTO;
4416 remote_protocol_packets[i].support = PACKET_SUPPORT_UNKNOWN;
4417 }
4418 }
4419
4420 /* Symbol look-up. */
4421
4422 static void
4423 remote_check_symbols (void)
4424 {
4425 struct remote_state *rs = get_remote_state ();
4426 char *msg, *reply, *tmp;
4427 int end;
4428 long reply_size;
4429 struct cleanup *old_chain;
4430
4431 /* The remote side has no concept of inferiors that aren't running
4432 yet, it only knows about running processes. If we're connected
4433 but our current inferior is not running, we should not invite the
4434 remote target to request symbol lookups related to its
4435 (unrelated) current process. */
4436 if (!target_has_execution)
4437 return;
4438
4439 if (packet_support (PACKET_qSymbol) == PACKET_DISABLE)
4440 return;
4441
4442 /* Make sure the remote is pointing at the right process. Note
4443 there's no way to select "no process". */
4444 set_general_process ();
4445
4446 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4447 because we need both at the same time. */
4448 msg = (char *) xmalloc (get_remote_packet_size ());
4449 old_chain = make_cleanup (xfree, msg);
4450 reply = (char *) xmalloc (get_remote_packet_size ());
4451 make_cleanup (free_current_contents, &reply);
4452 reply_size = get_remote_packet_size ();
4453
4454 /* Invite target to request symbol lookups. */
4455
4456 putpkt ("qSymbol::");
4457 getpkt (&reply, &reply_size, 0);
4458 packet_ok (reply, &remote_protocol_packets[PACKET_qSymbol]);
4459
4460 while (startswith (reply, "qSymbol:"))
4461 {
4462 struct bound_minimal_symbol sym;
4463
4464 tmp = &reply[8];
4465 end = hex2bin (tmp, (gdb_byte *) msg, strlen (tmp) / 2);
4466 msg[end] = '\0';
4467 sym = lookup_minimal_symbol (msg, NULL, NULL);
4468 if (sym.minsym == NULL)
4469 xsnprintf (msg, get_remote_packet_size (), "qSymbol::%s", &reply[8]);
4470 else
4471 {
4472 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
4473 CORE_ADDR sym_addr = BMSYMBOL_VALUE_ADDRESS (sym);
4474
4475 /* If this is a function address, return the start of code
4476 instead of any data function descriptor. */
4477 sym_addr = gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4478 sym_addr,
4479 &current_target);
4480
4481 xsnprintf (msg, get_remote_packet_size (), "qSymbol:%s:%s",
4482 phex_nz (sym_addr, addr_size), &reply[8]);
4483 }
4484
4485 putpkt (msg);
4486 getpkt (&reply, &reply_size, 0);
4487 }
4488
4489 do_cleanups (old_chain);
4490 }
4491
4492 static struct serial *
4493 remote_serial_open (const char *name)
4494 {
4495 static int udp_warning = 0;
4496
4497 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4498 of in ser-tcp.c, because it is the remote protocol assuming that the
4499 serial connection is reliable and not the serial connection promising
4500 to be. */
4501 if (!udp_warning && startswith (name, "udp:"))
4502 {
4503 warning (_("The remote protocol may be unreliable over UDP.\n"
4504 "Some events may be lost, rendering further debugging "
4505 "impossible."));
4506 udp_warning = 1;
4507 }
4508
4509 return serial_open (name);
4510 }
4511
4512 /* Inform the target of our permission settings. The permission flags
4513 work without this, but if the target knows the settings, it can do
4514 a couple things. First, it can add its own check, to catch cases
4515 that somehow manage to get by the permissions checks in target
4516 methods. Second, if the target is wired to disallow particular
4517 settings (for instance, a system in the field that is not set up to
4518 be able to stop at a breakpoint), it can object to any unavailable
4519 permissions. */
4520
4521 void
4522 remote_set_permissions (struct target_ops *self)
4523 {
4524 struct remote_state *rs = get_remote_state ();
4525
4526 xsnprintf (rs->buf, get_remote_packet_size (), "QAllow:"
4527 "WriteReg:%x;WriteMem:%x;"
4528 "InsertBreak:%x;InsertTrace:%x;"
4529 "InsertFastTrace:%x;Stop:%x",
4530 may_write_registers, may_write_memory,
4531 may_insert_breakpoints, may_insert_tracepoints,
4532 may_insert_fast_tracepoints, may_stop);
4533 putpkt (rs->buf);
4534 getpkt (&rs->buf, &rs->buf_size, 0);
4535
4536 /* If the target didn't like the packet, warn the user. Do not try
4537 to undo the user's settings, that would just be maddening. */
4538 if (strcmp (rs->buf, "OK") != 0)
4539 warning (_("Remote refused setting permissions with: %s"), rs->buf);
4540 }
4541
4542 /* This type describes each known response to the qSupported
4543 packet. */
4544 struct protocol_feature
4545 {
4546 /* The name of this protocol feature. */
4547 const char *name;
4548
4549 /* The default for this protocol feature. */
4550 enum packet_support default_support;
4551
4552 /* The function to call when this feature is reported, or after
4553 qSupported processing if the feature is not supported.
4554 The first argument points to this structure. The second
4555 argument indicates whether the packet requested support be
4556 enabled, disabled, or probed (or the default, if this function
4557 is being called at the end of processing and this feature was
4558 not reported). The third argument may be NULL; if not NULL, it
4559 is a NUL-terminated string taken from the packet following
4560 this feature's name and an equals sign. */
4561 void (*func) (const struct protocol_feature *, enum packet_support,
4562 const char *);
4563
4564 /* The corresponding packet for this feature. Only used if
4565 FUNC is remote_supported_packet. */
4566 int packet;
4567 };
4568
4569 static void
4570 remote_supported_packet (const struct protocol_feature *feature,
4571 enum packet_support support,
4572 const char *argument)
4573 {
4574 if (argument)
4575 {
4576 warning (_("Remote qSupported response supplied an unexpected value for"
4577 " \"%s\"."), feature->name);
4578 return;
4579 }
4580
4581 remote_protocol_packets[feature->packet].support = support;
4582 }
4583
4584 static void
4585 remote_packet_size (const struct protocol_feature *feature,
4586 enum packet_support support, const char *value)
4587 {
4588 struct remote_state *rs = get_remote_state ();
4589
4590 int packet_size;
4591 char *value_end;
4592
4593 if (support != PACKET_ENABLE)
4594 return;
4595
4596 if (value == NULL || *value == '\0')
4597 {
4598 warning (_("Remote target reported \"%s\" without a size."),
4599 feature->name);
4600 return;
4601 }
4602
4603 errno = 0;
4604 packet_size = strtol (value, &value_end, 16);
4605 if (errno != 0 || *value_end != '\0' || packet_size < 0)
4606 {
4607 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4608 feature->name, value);
4609 return;
4610 }
4611
4612 /* Record the new maximum packet size. */
4613 rs->explicit_packet_size = packet_size;
4614 }
4615
4616 static const struct protocol_feature remote_protocol_features[] = {
4617 { "PacketSize", PACKET_DISABLE, remote_packet_size, -1 },
4618 { "qXfer:auxv:read", PACKET_DISABLE, remote_supported_packet,
4619 PACKET_qXfer_auxv },
4620 { "qXfer:exec-file:read", PACKET_DISABLE, remote_supported_packet,
4621 PACKET_qXfer_exec_file },
4622 { "qXfer:features:read", PACKET_DISABLE, remote_supported_packet,
4623 PACKET_qXfer_features },
4624 { "qXfer:libraries:read", PACKET_DISABLE, remote_supported_packet,
4625 PACKET_qXfer_libraries },
4626 { "qXfer:libraries-svr4:read", PACKET_DISABLE, remote_supported_packet,
4627 PACKET_qXfer_libraries_svr4 },
4628 { "augmented-libraries-svr4-read", PACKET_DISABLE,
4629 remote_supported_packet, PACKET_augmented_libraries_svr4_read_feature },
4630 { "qXfer:memory-map:read", PACKET_DISABLE, remote_supported_packet,
4631 PACKET_qXfer_memory_map },
4632 { "qXfer:spu:read", PACKET_DISABLE, remote_supported_packet,
4633 PACKET_qXfer_spu_read },
4634 { "qXfer:spu:write", PACKET_DISABLE, remote_supported_packet,
4635 PACKET_qXfer_spu_write },
4636 { "qXfer:osdata:read", PACKET_DISABLE, remote_supported_packet,
4637 PACKET_qXfer_osdata },
4638 { "qXfer:threads:read", PACKET_DISABLE, remote_supported_packet,
4639 PACKET_qXfer_threads },
4640 { "qXfer:traceframe-info:read", PACKET_DISABLE, remote_supported_packet,
4641 PACKET_qXfer_traceframe_info },
4642 { "QPassSignals", PACKET_DISABLE, remote_supported_packet,
4643 PACKET_QPassSignals },
4644 { "QCatchSyscalls", PACKET_DISABLE, remote_supported_packet,
4645 PACKET_QCatchSyscalls },
4646 { "QProgramSignals", PACKET_DISABLE, remote_supported_packet,
4647 PACKET_QProgramSignals },
4648 { "QSetWorkingDir", PACKET_DISABLE, remote_supported_packet,
4649 PACKET_QSetWorkingDir },
4650 { "QStartupWithShell", PACKET_DISABLE, remote_supported_packet,
4651 PACKET_QStartupWithShell },
4652 { "QEnvironmentHexEncoded", PACKET_DISABLE, remote_supported_packet,
4653 PACKET_QEnvironmentHexEncoded },
4654 { "QEnvironmentReset", PACKET_DISABLE, remote_supported_packet,
4655 PACKET_QEnvironmentReset },
4656 { "QEnvironmentUnset", PACKET_DISABLE, remote_supported_packet,
4657 PACKET_QEnvironmentUnset },
4658 { "QStartNoAckMode", PACKET_DISABLE, remote_supported_packet,
4659 PACKET_QStartNoAckMode },
4660 { "multiprocess", PACKET_DISABLE, remote_supported_packet,
4661 PACKET_multiprocess_feature },
4662 { "QNonStop", PACKET_DISABLE, remote_supported_packet, PACKET_QNonStop },
4663 { "qXfer:siginfo:read", PACKET_DISABLE, remote_supported_packet,
4664 PACKET_qXfer_siginfo_read },
4665 { "qXfer:siginfo:write", PACKET_DISABLE, remote_supported_packet,
4666 PACKET_qXfer_siginfo_write },
4667 { "ConditionalTracepoints", PACKET_DISABLE, remote_supported_packet,
4668 PACKET_ConditionalTracepoints },
4669 { "ConditionalBreakpoints", PACKET_DISABLE, remote_supported_packet,
4670 PACKET_ConditionalBreakpoints },
4671 { "BreakpointCommands", PACKET_DISABLE, remote_supported_packet,
4672 PACKET_BreakpointCommands },
4673 { "FastTracepoints", PACKET_DISABLE, remote_supported_packet,
4674 PACKET_FastTracepoints },
4675 { "StaticTracepoints", PACKET_DISABLE, remote_supported_packet,
4676 PACKET_StaticTracepoints },
4677 {"InstallInTrace", PACKET_DISABLE, remote_supported_packet,
4678 PACKET_InstallInTrace},
4679 { "DisconnectedTracing", PACKET_DISABLE, remote_supported_packet,
4680 PACKET_DisconnectedTracing_feature },
4681 { "ReverseContinue", PACKET_DISABLE, remote_supported_packet,
4682 PACKET_bc },
4683 { "ReverseStep", PACKET_DISABLE, remote_supported_packet,
4684 PACKET_bs },
4685 { "TracepointSource", PACKET_DISABLE, remote_supported_packet,
4686 PACKET_TracepointSource },
4687 { "QAllow", PACKET_DISABLE, remote_supported_packet,
4688 PACKET_QAllow },
4689 { "EnableDisableTracepoints", PACKET_DISABLE, remote_supported_packet,
4690 PACKET_EnableDisableTracepoints_feature },
4691 { "qXfer:fdpic:read", PACKET_DISABLE, remote_supported_packet,
4692 PACKET_qXfer_fdpic },
4693 { "qXfer:uib:read", PACKET_DISABLE, remote_supported_packet,
4694 PACKET_qXfer_uib },
4695 { "QDisableRandomization", PACKET_DISABLE, remote_supported_packet,
4696 PACKET_QDisableRandomization },
4697 { "QAgent", PACKET_DISABLE, remote_supported_packet, PACKET_QAgent},
4698 { "QTBuffer:size", PACKET_DISABLE,
4699 remote_supported_packet, PACKET_QTBuffer_size},
4700 { "tracenz", PACKET_DISABLE, remote_supported_packet, PACKET_tracenz_feature },
4701 { "Qbtrace:off", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_off },
4702 { "Qbtrace:bts", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_bts },
4703 { "Qbtrace:pt", PACKET_DISABLE, remote_supported_packet, PACKET_Qbtrace_pt },
4704 { "qXfer:btrace:read", PACKET_DISABLE, remote_supported_packet,
4705 PACKET_qXfer_btrace },
4706 { "qXfer:btrace-conf:read", PACKET_DISABLE, remote_supported_packet,
4707 PACKET_qXfer_btrace_conf },
4708 { "Qbtrace-conf:bts:size", PACKET_DISABLE, remote_supported_packet,
4709 PACKET_Qbtrace_conf_bts_size },
4710 { "swbreak", PACKET_DISABLE, remote_supported_packet, PACKET_swbreak_feature },
4711 { "hwbreak", PACKET_DISABLE, remote_supported_packet, PACKET_hwbreak_feature },
4712 { "fork-events", PACKET_DISABLE, remote_supported_packet,
4713 PACKET_fork_event_feature },
4714 { "vfork-events", PACKET_DISABLE, remote_supported_packet,
4715 PACKET_vfork_event_feature },
4716 { "exec-events", PACKET_DISABLE, remote_supported_packet,
4717 PACKET_exec_event_feature },
4718 { "Qbtrace-conf:pt:size", PACKET_DISABLE, remote_supported_packet,
4719 PACKET_Qbtrace_conf_pt_size },
4720 { "vContSupported", PACKET_DISABLE, remote_supported_packet, PACKET_vContSupported },
4721 { "QThreadEvents", PACKET_DISABLE, remote_supported_packet, PACKET_QThreadEvents },
4722 { "no-resumed", PACKET_DISABLE, remote_supported_packet, PACKET_no_resumed },
4723 };
4724
4725 static char *remote_support_xml;
4726
4727 /* Register string appended to "xmlRegisters=" in qSupported query. */
4728
4729 void
4730 register_remote_support_xml (const char *xml)
4731 {
4732 #if defined(HAVE_LIBEXPAT)
4733 if (remote_support_xml == NULL)
4734 remote_support_xml = concat ("xmlRegisters=", xml, (char *) NULL);
4735 else
4736 {
4737 char *copy = xstrdup (remote_support_xml + 13);
4738 char *p = strtok (copy, ",");
4739
4740 do
4741 {
4742 if (strcmp (p, xml) == 0)
4743 {
4744 /* already there */
4745 xfree (copy);
4746 return;
4747 }
4748 }
4749 while ((p = strtok (NULL, ",")) != NULL);
4750 xfree (copy);
4751
4752 remote_support_xml = reconcat (remote_support_xml,
4753 remote_support_xml, ",", xml,
4754 (char *) NULL);
4755 }
4756 #endif
4757 }
4758
4759 static char *
4760 remote_query_supported_append (char *msg, const char *append)
4761 {
4762 if (msg)
4763 return reconcat (msg, msg, ";", append, (char *) NULL);
4764 else
4765 return xstrdup (append);
4766 }
4767
4768 static void
4769 remote_query_supported (void)
4770 {
4771 struct remote_state *rs = get_remote_state ();
4772 char *next;
4773 int i;
4774 unsigned char seen [ARRAY_SIZE (remote_protocol_features)];
4775
4776 /* The packet support flags are handled differently for this packet
4777 than for most others. We treat an error, a disabled packet, and
4778 an empty response identically: any features which must be reported
4779 to be used will be automatically disabled. An empty buffer
4780 accomplishes this, since that is also the representation for a list
4781 containing no features. */
4782
4783 rs->buf[0] = 0;
4784 if (packet_support (PACKET_qSupported) != PACKET_DISABLE)
4785 {
4786 char *q = NULL;
4787 struct cleanup *old_chain = make_cleanup (free_current_contents, &q);
4788
4789 if (packet_set_cmd_state (PACKET_multiprocess_feature) != AUTO_BOOLEAN_FALSE)
4790 q = remote_query_supported_append (q, "multiprocess+");
4791
4792 if (packet_set_cmd_state (PACKET_swbreak_feature) != AUTO_BOOLEAN_FALSE)
4793 q = remote_query_supported_append (q, "swbreak+");
4794 if (packet_set_cmd_state (PACKET_hwbreak_feature) != AUTO_BOOLEAN_FALSE)
4795 q = remote_query_supported_append (q, "hwbreak+");
4796
4797 q = remote_query_supported_append (q, "qRelocInsn+");
4798
4799 if (packet_set_cmd_state (PACKET_fork_event_feature)
4800 != AUTO_BOOLEAN_FALSE)
4801 q = remote_query_supported_append (q, "fork-events+");
4802 if (packet_set_cmd_state (PACKET_vfork_event_feature)
4803 != AUTO_BOOLEAN_FALSE)
4804 q = remote_query_supported_append (q, "vfork-events+");
4805 if (packet_set_cmd_state (PACKET_exec_event_feature)
4806 != AUTO_BOOLEAN_FALSE)
4807 q = remote_query_supported_append (q, "exec-events+");
4808
4809 if (packet_set_cmd_state (PACKET_vContSupported) != AUTO_BOOLEAN_FALSE)
4810 q = remote_query_supported_append (q, "vContSupported+");
4811
4812 if (packet_set_cmd_state (PACKET_QThreadEvents) != AUTO_BOOLEAN_FALSE)
4813 q = remote_query_supported_append (q, "QThreadEvents+");
4814
4815 if (packet_set_cmd_state (PACKET_no_resumed) != AUTO_BOOLEAN_FALSE)
4816 q = remote_query_supported_append (q, "no-resumed+");
4817
4818 /* Keep this one last to work around a gdbserver <= 7.10 bug in
4819 the qSupported:xmlRegisters=i386 handling. */
4820 if (remote_support_xml != NULL)
4821 q = remote_query_supported_append (q, remote_support_xml);
4822
4823 q = reconcat (q, "qSupported:", q, (char *) NULL);
4824 putpkt (q);
4825
4826 do_cleanups (old_chain);
4827
4828 getpkt (&rs->buf, &rs->buf_size, 0);
4829
4830 /* If an error occured, warn, but do not return - just reset the
4831 buffer to empty and go on to disable features. */
4832 if (packet_ok (rs->buf, &remote_protocol_packets[PACKET_qSupported])
4833 == PACKET_ERROR)
4834 {
4835 warning (_("Remote failure reply: %s"), rs->buf);
4836 rs->buf[0] = 0;
4837 }
4838 }
4839
4840 memset (seen, 0, sizeof (seen));
4841
4842 next = rs->buf;
4843 while (*next)
4844 {
4845 enum packet_support is_supported;
4846 char *p, *end, *name_end, *value;
4847
4848 /* First separate out this item from the rest of the packet. If
4849 there's another item after this, we overwrite the separator
4850 (terminated strings are much easier to work with). */
4851 p = next;
4852 end = strchr (p, ';');
4853 if (end == NULL)
4854 {
4855 end = p + strlen (p);
4856 next = end;
4857 }
4858 else
4859 {
4860 *end = '\0';
4861 next = end + 1;
4862
4863 if (end == p)
4864 {
4865 warning (_("empty item in \"qSupported\" response"));
4866 continue;
4867 }
4868 }
4869
4870 name_end = strchr (p, '=');
4871 if (name_end)
4872 {
4873 /* This is a name=value entry. */
4874 is_supported = PACKET_ENABLE;
4875 value = name_end + 1;
4876 *name_end = '\0';
4877 }
4878 else
4879 {
4880 value = NULL;
4881 switch (end[-1])
4882 {
4883 case '+':
4884 is_supported = PACKET_ENABLE;
4885 break;
4886
4887 case '-':
4888 is_supported = PACKET_DISABLE;
4889 break;
4890
4891 case '?':
4892 is_supported = PACKET_SUPPORT_UNKNOWN;
4893 break;
4894
4895 default:
4896 warning (_("unrecognized item \"%s\" "
4897 "in \"qSupported\" response"), p);
4898 continue;
4899 }
4900 end[-1] = '\0';
4901 }
4902
4903 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4904 if (strcmp (remote_protocol_features[i].name, p) == 0)
4905 {
4906 const struct protocol_feature *feature;
4907
4908 seen[i] = 1;
4909 feature = &remote_protocol_features[i];
4910 feature->func (feature, is_supported, value);
4911 break;
4912 }
4913 }
4914
4915 /* If we increased the packet size, make sure to increase the global
4916 buffer size also. We delay this until after parsing the entire
4917 qSupported packet, because this is the same buffer we were
4918 parsing. */
4919 if (rs->buf_size < rs->explicit_packet_size)
4920 {
4921 rs->buf_size = rs->explicit_packet_size;
4922 rs->buf = (char *) xrealloc (rs->buf, rs->buf_size);
4923 }
4924
4925 /* Handle the defaults for unmentioned features. */
4926 for (i = 0; i < ARRAY_SIZE (remote_protocol_features); i++)
4927 if (!seen[i])
4928 {
4929 const struct protocol_feature *feature;
4930
4931 feature = &remote_protocol_features[i];
4932 feature->func (feature, feature->default_support, NULL);
4933 }
4934 }
4935
4936 /* Serial QUIT handler for the remote serial descriptor.
4937
4938 Defers handling a Ctrl-C until we're done with the current
4939 command/response packet sequence, unless:
4940
4941 - We're setting up the connection. Don't send a remote interrupt
4942 request, as we're not fully synced yet. Quit immediately
4943 instead.
4944
4945 - The target has been resumed in the foreground
4946 (target_terminal::is_ours is false) with a synchronous resume
4947 packet, and we're blocked waiting for the stop reply, thus a
4948 Ctrl-C should be immediately sent to the target.
4949
4950 - We get a second Ctrl-C while still within the same serial read or
4951 write. In that case the serial is seemingly wedged --- offer to
4952 quit/disconnect.
4953
4954 - We see a second Ctrl-C without target response, after having
4955 previously interrupted the target. In that case the target/stub
4956 is probably wedged --- offer to quit/disconnect.
4957 */
4958
4959 static void
4960 remote_serial_quit_handler (void)
4961 {
4962 struct remote_state *rs = get_remote_state ();
4963
4964 if (check_quit_flag ())
4965 {
4966 /* If we're starting up, we're not fully synced yet. Quit
4967 immediately. */
4968 if (rs->starting_up)
4969 quit ();
4970 else if (rs->got_ctrlc_during_io)
4971 {
4972 if (query (_("The target is not responding to GDB commands.\n"
4973 "Stop debugging it? ")))
4974 remote_unpush_and_throw ();
4975 }
4976 /* If ^C has already been sent once, offer to disconnect. */
4977 else if (!target_terminal::is_ours () && rs->ctrlc_pending_p)
4978 interrupt_query ();
4979 /* All-stop protocol, and blocked waiting for stop reply. Send
4980 an interrupt request. */
4981 else if (!target_terminal::is_ours () && rs->waiting_for_stop_reply)
4982 target_interrupt (inferior_ptid);
4983 else
4984 rs->got_ctrlc_during_io = 1;
4985 }
4986 }
4987
4988 /* Remove any of the remote.c targets from target stack. Upper targets depend
4989 on it so remove them first. */
4990
4991 static void
4992 remote_unpush_target (void)
4993 {
4994 pop_all_targets_at_and_above (process_stratum);
4995 }
4996
4997 static void
4998 remote_unpush_and_throw (void)
4999 {
5000 remote_unpush_target ();
5001 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
5002 }
5003
5004 static void
5005 remote_open_1 (const char *name, int from_tty,
5006 struct target_ops *target, int extended_p)
5007 {
5008 struct remote_state *rs = get_remote_state ();
5009
5010 if (name == 0)
5011 error (_("To open a remote debug connection, you need to specify what\n"
5012 "serial device is attached to the remote system\n"
5013 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5014
5015 /* See FIXME above. */
5016 if (!target_async_permitted)
5017 wait_forever_enabled_p = 1;
5018
5019 /* If we're connected to a running target, target_preopen will kill it.
5020 Ask this question first, before target_preopen has a chance to kill
5021 anything. */
5022 if (rs->remote_desc != NULL && !have_inferiors ())
5023 {
5024 if (from_tty
5025 && !query (_("Already connected to a remote target. Disconnect? ")))
5026 error (_("Still connected."));
5027 }
5028
5029 /* Here the possibly existing remote target gets unpushed. */
5030 target_preopen (from_tty);
5031
5032 /* Make sure we send the passed signals list the next time we resume. */
5033 xfree (rs->last_pass_packet);
5034 rs->last_pass_packet = NULL;
5035
5036 /* Make sure we send the program signals list the next time we
5037 resume. */
5038 xfree (rs->last_program_signals_packet);
5039 rs->last_program_signals_packet = NULL;
5040
5041 remote_fileio_reset ();
5042 reopen_exec_file ();
5043 reread_symbols ();
5044
5045 rs->remote_desc = remote_serial_open (name);
5046 if (!rs->remote_desc)
5047 perror_with_name (name);
5048
5049 if (baud_rate != -1)
5050 {
5051 if (serial_setbaudrate (rs->remote_desc, baud_rate))
5052 {
5053 /* The requested speed could not be set. Error out to
5054 top level after closing remote_desc. Take care to
5055 set remote_desc to NULL to avoid closing remote_desc
5056 more than once. */
5057 serial_close (rs->remote_desc);
5058 rs->remote_desc = NULL;
5059 perror_with_name (name);
5060 }
5061 }
5062
5063 serial_setparity (rs->remote_desc, serial_parity);
5064 serial_raw (rs->remote_desc);
5065
5066 /* If there is something sitting in the buffer we might take it as a
5067 response to a command, which would be bad. */
5068 serial_flush_input (rs->remote_desc);
5069
5070 if (from_tty)
5071 {
5072 puts_filtered ("Remote debugging using ");
5073 puts_filtered (name);
5074 puts_filtered ("\n");
5075 }
5076 push_target (target); /* Switch to using remote target now. */
5077
5078 /* Register extra event sources in the event loop. */
5079 remote_async_inferior_event_token
5080 = create_async_event_handler (remote_async_inferior_event_handler,
5081 NULL);
5082 rs->notif_state = remote_notif_state_allocate ();
5083
5084 /* Reset the target state; these things will be queried either by
5085 remote_query_supported or as they are needed. */
5086 reset_all_packet_configs_support ();
5087 rs->cached_wait_status = 0;
5088 rs->explicit_packet_size = 0;
5089 rs->noack_mode = 0;
5090 rs->extended = extended_p;
5091 rs->waiting_for_stop_reply = 0;
5092 rs->ctrlc_pending_p = 0;
5093 rs->got_ctrlc_during_io = 0;
5094
5095 rs->general_thread = not_sent_ptid;
5096 rs->continue_thread = not_sent_ptid;
5097 rs->remote_traceframe_number = -1;
5098
5099 rs->last_resume_exec_dir = EXEC_FORWARD;
5100
5101 /* Probe for ability to use "ThreadInfo" query, as required. */
5102 rs->use_threadinfo_query = 1;
5103 rs->use_threadextra_query = 1;
5104
5105 readahead_cache_invalidate ();
5106
5107 if (target_async_permitted)
5108 {
5109 /* FIXME: cagney/1999-09-23: During the initial connection it is
5110 assumed that the target is already ready and able to respond to
5111 requests. Unfortunately remote_start_remote() eventually calls
5112 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5113 around this. Eventually a mechanism that allows
5114 wait_for_inferior() to expect/get timeouts will be
5115 implemented. */
5116 wait_forever_enabled_p = 0;
5117 }
5118
5119 /* First delete any symbols previously loaded from shared libraries. */
5120 no_shared_libraries (NULL, 0);
5121
5122 /* Start afresh. */
5123 init_thread_list ();
5124
5125 /* Start the remote connection. If error() or QUIT, discard this
5126 target (we'd otherwise be in an inconsistent state) and then
5127 propogate the error on up the exception chain. This ensures that
5128 the caller doesn't stumble along blindly assuming that the
5129 function succeeded. The CLI doesn't have this problem but other
5130 UI's, such as MI do.
5131
5132 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5133 this function should return an error indication letting the
5134 caller restore the previous state. Unfortunately the command
5135 ``target remote'' is directly wired to this function making that
5136 impossible. On a positive note, the CLI side of this problem has
5137 been fixed - the function set_cmd_context() makes it possible for
5138 all the ``target ....'' commands to share a common callback
5139 function. See cli-dump.c. */
5140 {
5141
5142 TRY
5143 {
5144 remote_start_remote (from_tty, target, extended_p);
5145 }
5146 CATCH (ex, RETURN_MASK_ALL)
5147 {
5148 /* Pop the partially set up target - unless something else did
5149 already before throwing the exception. */
5150 if (rs->remote_desc != NULL)
5151 remote_unpush_target ();
5152 if (target_async_permitted)
5153 wait_forever_enabled_p = 1;
5154 throw_exception (ex);
5155 }
5156 END_CATCH
5157 }
5158
5159 remote_btrace_reset ();
5160
5161 if (target_async_permitted)
5162 wait_forever_enabled_p = 1;
5163 }
5164
5165 /* Detach the specified process. */
5166
5167 static void
5168 remote_detach_pid (int pid)
5169 {
5170 struct remote_state *rs = get_remote_state ();
5171
5172 if (remote_multi_process_p (rs))
5173 xsnprintf (rs->buf, get_remote_packet_size (), "D;%x", pid);
5174 else
5175 strcpy (rs->buf, "D");
5176
5177 putpkt (rs->buf);
5178 getpkt (&rs->buf, &rs->buf_size, 0);
5179
5180 if (rs->buf[0] == 'O' && rs->buf[1] == 'K')
5181 ;
5182 else if (rs->buf[0] == '\0')
5183 error (_("Remote doesn't know how to detach"));
5184 else
5185 error (_("Can't detach process."));
5186 }
5187
5188 /* This detaches a program to which we previously attached, using
5189 inferior_ptid to identify the process. After this is done, GDB
5190 can be used to debug some other program. We better not have left
5191 any breakpoints in the target program or it'll die when it hits
5192 one. */
5193
5194 static void
5195 remote_detach_1 (const char *args, int from_tty)
5196 {
5197 int pid = ptid_get_pid (inferior_ptid);
5198 struct remote_state *rs = get_remote_state ();
5199 struct thread_info *tp = find_thread_ptid (inferior_ptid);
5200 int is_fork_parent;
5201
5202 if (args)
5203 error (_("Argument given to \"detach\" when remotely debugging."));
5204
5205 if (!target_has_execution)
5206 error (_("No process to detach from."));
5207
5208 target_announce_detach (from_tty);
5209
5210 /* Tell the remote target to detach. */
5211 remote_detach_pid (pid);
5212
5213 /* Exit only if this is the only active inferior. */
5214 if (from_tty && !rs->extended && number_of_live_inferiors () == 1)
5215 puts_filtered (_("Ending remote debugging.\n"));
5216
5217 /* Check to see if we are detaching a fork parent. Note that if we
5218 are detaching a fork child, tp == NULL. */
5219 is_fork_parent = (tp != NULL
5220 && tp->pending_follow.kind == TARGET_WAITKIND_FORKED);
5221
5222 /* If doing detach-on-fork, we don't mourn, because that will delete
5223 breakpoints that should be available for the followed inferior. */
5224 if (!is_fork_parent)
5225 target_mourn_inferior (inferior_ptid);
5226 else
5227 {
5228 inferior_ptid = null_ptid;
5229 detach_inferior (pid);
5230 }
5231 }
5232
5233 static void
5234 remote_detach (struct target_ops *ops, const char *args, int from_tty)
5235 {
5236 remote_detach_1 (args, from_tty);
5237 }
5238
5239 static void
5240 extended_remote_detach (struct target_ops *ops, const char *args, int from_tty)
5241 {
5242 remote_detach_1 (args, from_tty);
5243 }
5244
5245 /* Target follow-fork function for remote targets. On entry, and
5246 at return, the current inferior is the fork parent.
5247
5248 Note that although this is currently only used for extended-remote,
5249 it is named remote_follow_fork in anticipation of using it for the
5250 remote target as well. */
5251
5252 static int
5253 remote_follow_fork (struct target_ops *ops, int follow_child,
5254 int detach_fork)
5255 {
5256 struct remote_state *rs = get_remote_state ();
5257 enum target_waitkind kind = inferior_thread ()->pending_follow.kind;
5258
5259 if ((kind == TARGET_WAITKIND_FORKED && remote_fork_event_p (rs))
5260 || (kind == TARGET_WAITKIND_VFORKED && remote_vfork_event_p (rs)))
5261 {
5262 /* When following the parent and detaching the child, we detach
5263 the child here. For the case of following the child and
5264 detaching the parent, the detach is done in the target-
5265 independent follow fork code in infrun.c. We can't use
5266 target_detach when detaching an unfollowed child because
5267 the client side doesn't know anything about the child. */
5268 if (detach_fork && !follow_child)
5269 {
5270 /* Detach the fork child. */
5271 ptid_t child_ptid;
5272 pid_t child_pid;
5273
5274 child_ptid = inferior_thread ()->pending_follow.value.related_pid;
5275 child_pid = ptid_get_pid (child_ptid);
5276
5277 remote_detach_pid (child_pid);
5278 detach_inferior (child_pid);
5279 }
5280 }
5281 return 0;
5282 }
5283
5284 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5285 in the program space of the new inferior. On entry and at return the
5286 current inferior is the exec'ing inferior. INF is the new exec'd
5287 inferior, which may be the same as the exec'ing inferior unless
5288 follow-exec-mode is "new". */
5289
5290 static void
5291 remote_follow_exec (struct target_ops *ops,
5292 struct inferior *inf, char *execd_pathname)
5293 {
5294 /* We know that this is a target file name, so if it has the "target:"
5295 prefix we strip it off before saving it in the program space. */
5296 if (is_target_filename (execd_pathname))
5297 execd_pathname += strlen (TARGET_SYSROOT_PREFIX);
5298
5299 set_pspace_remote_exec_file (inf->pspace, execd_pathname);
5300 }
5301
5302 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5303
5304 static void
5305 remote_disconnect (struct target_ops *target, const char *args, int from_tty)
5306 {
5307 if (args)
5308 error (_("Argument given to \"disconnect\" when remotely debugging."));
5309
5310 /* Make sure we unpush even the extended remote targets. Calling
5311 target_mourn_inferior won't unpush, and remote_mourn won't
5312 unpush if there is more than one inferior left. */
5313 unpush_target (target);
5314 generic_mourn_inferior ();
5315
5316 if (from_tty)
5317 puts_filtered ("Ending remote debugging.\n");
5318 }
5319
5320 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5321 be chatty about it. */
5322
5323 static void
5324 extended_remote_attach (struct target_ops *target, const char *args,
5325 int from_tty)
5326 {
5327 struct remote_state *rs = get_remote_state ();
5328 int pid;
5329 char *wait_status = NULL;
5330
5331 pid = parse_pid_to_attach (args);
5332
5333 /* Remote PID can be freely equal to getpid, do not check it here the same
5334 way as in other targets. */
5335
5336 if (packet_support (PACKET_vAttach) == PACKET_DISABLE)
5337 error (_("This target does not support attaching to a process"));
5338
5339 if (from_tty)
5340 {
5341 char *exec_file = get_exec_file (0);
5342
5343 if (exec_file)
5344 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
5345 target_pid_to_str (pid_to_ptid (pid)));
5346 else
5347 printf_unfiltered (_("Attaching to %s\n"),
5348 target_pid_to_str (pid_to_ptid (pid)));
5349
5350 gdb_flush (gdb_stdout);
5351 }
5352
5353 xsnprintf (rs->buf, get_remote_packet_size (), "vAttach;%x", pid);
5354 putpkt (rs->buf);
5355 getpkt (&rs->buf, &rs->buf_size, 0);
5356
5357 switch (packet_ok (rs->buf,
5358 &remote_protocol_packets[PACKET_vAttach]))
5359 {
5360 case PACKET_OK:
5361 if (!target_is_non_stop_p ())
5362 {
5363 /* Save the reply for later. */
5364 wait_status = (char *) alloca (strlen (rs->buf) + 1);
5365 strcpy (wait_status, rs->buf);
5366 }
5367 else if (strcmp (rs->buf, "OK") != 0)
5368 error (_("Attaching to %s failed with: %s"),
5369 target_pid_to_str (pid_to_ptid (pid)),
5370 rs->buf);
5371 break;
5372 case PACKET_UNKNOWN:
5373 error (_("This target does not support attaching to a process"));
5374 default:
5375 error (_("Attaching to %s failed"),
5376 target_pid_to_str (pid_to_ptid (pid)));
5377 }
5378
5379 set_current_inferior (remote_add_inferior (0, pid, 1, 0));
5380
5381 inferior_ptid = pid_to_ptid (pid);
5382
5383 if (target_is_non_stop_p ())
5384 {
5385 struct thread_info *thread;
5386
5387 /* Get list of threads. */
5388 remote_update_thread_list (target);
5389
5390 thread = first_thread_of_process (pid);
5391 if (thread)
5392 inferior_ptid = thread->ptid;
5393 else
5394 inferior_ptid = pid_to_ptid (pid);
5395
5396 /* Invalidate our notion of the remote current thread. */
5397 record_currthread (rs, minus_one_ptid);
5398 }
5399 else
5400 {
5401 /* Now, if we have thread information, update inferior_ptid. */
5402 inferior_ptid = remote_current_thread (inferior_ptid);
5403
5404 /* Add the main thread to the thread list. */
5405 add_thread_silent (inferior_ptid);
5406 }
5407
5408 /* Next, if the target can specify a description, read it. We do
5409 this before anything involving memory or registers. */
5410 target_find_description ();
5411
5412 if (!target_is_non_stop_p ())
5413 {
5414 /* Use the previously fetched status. */
5415 gdb_assert (wait_status != NULL);
5416
5417 if (target_can_async_p ())
5418 {
5419 struct notif_event *reply
5420 = remote_notif_parse (&notif_client_stop, wait_status);
5421
5422 push_stop_reply ((struct stop_reply *) reply);
5423
5424 target_async (1);
5425 }
5426 else
5427 {
5428 gdb_assert (wait_status != NULL);
5429 strcpy (rs->buf, wait_status);
5430 rs->cached_wait_status = 1;
5431 }
5432 }
5433 else
5434 gdb_assert (wait_status == NULL);
5435 }
5436
5437 /* Implementation of the to_post_attach method. */
5438
5439 static void
5440 extended_remote_post_attach (struct target_ops *ops, int pid)
5441 {
5442 /* Get text, data & bss offsets. */
5443 get_offsets ();
5444
5445 /* In certain cases GDB might not have had the chance to start
5446 symbol lookup up until now. This could happen if the debugged
5447 binary is not using shared libraries, the vsyscall page is not
5448 present (on Linux) and the binary itself hadn't changed since the
5449 debugging process was started. */
5450 if (symfile_objfile != NULL)
5451 remote_check_symbols();
5452 }
5453
5454 \f
5455 /* Check for the availability of vCont. This function should also check
5456 the response. */
5457
5458 static void
5459 remote_vcont_probe (struct remote_state *rs)
5460 {
5461 char *buf;
5462
5463 strcpy (rs->buf, "vCont?");
5464 putpkt (rs->buf);
5465 getpkt (&rs->buf, &rs->buf_size, 0);
5466 buf = rs->buf;
5467
5468 /* Make sure that the features we assume are supported. */
5469 if (startswith (buf, "vCont"))
5470 {
5471 char *p = &buf[5];
5472 int support_c, support_C;
5473
5474 rs->supports_vCont.s = 0;
5475 rs->supports_vCont.S = 0;
5476 support_c = 0;
5477 support_C = 0;
5478 rs->supports_vCont.t = 0;
5479 rs->supports_vCont.r = 0;
5480 while (p && *p == ';')
5481 {
5482 p++;
5483 if (*p == 's' && (*(p + 1) == ';' || *(p + 1) == 0))
5484 rs->supports_vCont.s = 1;
5485 else if (*p == 'S' && (*(p + 1) == ';' || *(p + 1) == 0))
5486 rs->supports_vCont.S = 1;
5487 else if (*p == 'c' && (*(p + 1) == ';' || *(p + 1) == 0))
5488 support_c = 1;
5489 else if (*p == 'C' && (*(p + 1) == ';' || *(p + 1) == 0))
5490 support_C = 1;
5491 else if (*p == 't' && (*(p + 1) == ';' || *(p + 1) == 0))
5492 rs->supports_vCont.t = 1;
5493 else if (*p == 'r' && (*(p + 1) == ';' || *(p + 1) == 0))
5494 rs->supports_vCont.r = 1;
5495
5496 p = strchr (p, ';');
5497 }
5498
5499 /* If c, and C are not all supported, we can't use vCont. Clearing
5500 BUF will make packet_ok disable the packet. */
5501 if (!support_c || !support_C)
5502 buf[0] = 0;
5503 }
5504
5505 packet_ok (buf, &remote_protocol_packets[PACKET_vCont]);
5506 }
5507
5508 /* Helper function for building "vCont" resumptions. Write a
5509 resumption to P. ENDP points to one-passed-the-end of the buffer
5510 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5511 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5512 resumed thread should be single-stepped and/or signalled. If PTID
5513 equals minus_one_ptid, then all threads are resumed; if PTID
5514 represents a process, then all threads of the process are resumed;
5515 the thread to be stepped and/or signalled is given in the global
5516 INFERIOR_PTID. */
5517
5518 static char *
5519 append_resumption (char *p, char *endp,
5520 ptid_t ptid, int step, enum gdb_signal siggnal)
5521 {
5522 struct remote_state *rs = get_remote_state ();
5523
5524 if (step && siggnal != GDB_SIGNAL_0)
5525 p += xsnprintf (p, endp - p, ";S%02x", siggnal);
5526 else if (step
5527 /* GDB is willing to range step. */
5528 && use_range_stepping
5529 /* Target supports range stepping. */
5530 && rs->supports_vCont.r
5531 /* We don't currently support range stepping multiple
5532 threads with a wildcard (though the protocol allows it,
5533 so stubs shouldn't make an active effort to forbid
5534 it). */
5535 && !(remote_multi_process_p (rs) && ptid_is_pid (ptid)))
5536 {
5537 struct thread_info *tp;
5538
5539 if (ptid_equal (ptid, minus_one_ptid))
5540 {
5541 /* If we don't know about the target thread's tid, then
5542 we're resuming magic_null_ptid (see caller). */
5543 tp = find_thread_ptid (magic_null_ptid);
5544 }
5545 else
5546 tp = find_thread_ptid (ptid);
5547 gdb_assert (tp != NULL);
5548
5549 if (tp->control.may_range_step)
5550 {
5551 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
5552
5553 p += xsnprintf (p, endp - p, ";r%s,%s",
5554 phex_nz (tp->control.step_range_start,
5555 addr_size),
5556 phex_nz (tp->control.step_range_end,
5557 addr_size));
5558 }
5559 else
5560 p += xsnprintf (p, endp - p, ";s");
5561 }
5562 else if (step)
5563 p += xsnprintf (p, endp - p, ";s");
5564 else if (siggnal != GDB_SIGNAL_0)
5565 p += xsnprintf (p, endp - p, ";C%02x", siggnal);
5566 else
5567 p += xsnprintf (p, endp - p, ";c");
5568
5569 if (remote_multi_process_p (rs) && ptid_is_pid (ptid))
5570 {
5571 ptid_t nptid;
5572
5573 /* All (-1) threads of process. */
5574 nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
5575
5576 p += xsnprintf (p, endp - p, ":");
5577 p = write_ptid (p, endp, nptid);
5578 }
5579 else if (!ptid_equal (ptid, minus_one_ptid))
5580 {
5581 p += xsnprintf (p, endp - p, ":");
5582 p = write_ptid (p, endp, ptid);
5583 }
5584
5585 return p;
5586 }
5587
5588 /* Clear the thread's private info on resume. */
5589
5590 static void
5591 resume_clear_thread_private_info (struct thread_info *thread)
5592 {
5593 if (thread->priv != NULL)
5594 {
5595 thread->priv->stop_reason = TARGET_STOPPED_BY_NO_REASON;
5596 thread->priv->watch_data_address = 0;
5597 }
5598 }
5599
5600 /* Append a vCont continue-with-signal action for threads that have a
5601 non-zero stop signal. */
5602
5603 static char *
5604 append_pending_thread_resumptions (char *p, char *endp, ptid_t ptid)
5605 {
5606 struct thread_info *thread;
5607
5608 ALL_NON_EXITED_THREADS (thread)
5609 if (ptid_match (thread->ptid, ptid)
5610 && !ptid_equal (inferior_ptid, thread->ptid)
5611 && thread->suspend.stop_signal != GDB_SIGNAL_0)
5612 {
5613 p = append_resumption (p, endp, thread->ptid,
5614 0, thread->suspend.stop_signal);
5615 thread->suspend.stop_signal = GDB_SIGNAL_0;
5616 resume_clear_thread_private_info (thread);
5617 }
5618
5619 return p;
5620 }
5621
5622 /* Set the target running, using the packets that use Hc
5623 (c/s/C/S). */
5624
5625 static void
5626 remote_resume_with_hc (struct target_ops *ops,
5627 ptid_t ptid, int step, enum gdb_signal siggnal)
5628 {
5629 struct remote_state *rs = get_remote_state ();
5630 struct thread_info *thread;
5631 char *buf;
5632
5633 rs->last_sent_signal = siggnal;
5634 rs->last_sent_step = step;
5635
5636 /* The c/s/C/S resume packets use Hc, so set the continue
5637 thread. */
5638 if (ptid_equal (ptid, minus_one_ptid))
5639 set_continue_thread (any_thread_ptid);
5640 else
5641 set_continue_thread (ptid);
5642
5643 ALL_NON_EXITED_THREADS (thread)
5644 resume_clear_thread_private_info (thread);
5645
5646 buf = rs->buf;
5647 if (execution_direction == EXEC_REVERSE)
5648 {
5649 /* We don't pass signals to the target in reverse exec mode. */
5650 if (info_verbose && siggnal != GDB_SIGNAL_0)
5651 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5652 siggnal);
5653
5654 if (step && packet_support (PACKET_bs) == PACKET_DISABLE)
5655 error (_("Remote reverse-step not supported."));
5656 if (!step && packet_support (PACKET_bc) == PACKET_DISABLE)
5657 error (_("Remote reverse-continue not supported."));
5658
5659 strcpy (buf, step ? "bs" : "bc");
5660 }
5661 else if (siggnal != GDB_SIGNAL_0)
5662 {
5663 buf[0] = step ? 'S' : 'C';
5664 buf[1] = tohex (((int) siggnal >> 4) & 0xf);
5665 buf[2] = tohex (((int) siggnal) & 0xf);
5666 buf[3] = '\0';
5667 }
5668 else
5669 strcpy (buf, step ? "s" : "c");
5670
5671 putpkt (buf);
5672 }
5673
5674 /* Resume the remote inferior by using a "vCont" packet. The thread
5675 to be resumed is PTID; STEP and SIGGNAL indicate whether the
5676 resumed thread should be single-stepped and/or signalled. If PTID
5677 equals minus_one_ptid, then all threads are resumed; the thread to
5678 be stepped and/or signalled is given in the global INFERIOR_PTID.
5679 This function returns non-zero iff it resumes the inferior.
5680
5681 This function issues a strict subset of all possible vCont commands
5682 at the moment. */
5683
5684 static int
5685 remote_resume_with_vcont (ptid_t ptid, int step, enum gdb_signal siggnal)
5686 {
5687 struct remote_state *rs = get_remote_state ();
5688 char *p;
5689 char *endp;
5690
5691 /* No reverse execution actions defined for vCont. */
5692 if (execution_direction == EXEC_REVERSE)
5693 return 0;
5694
5695 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
5696 remote_vcont_probe (rs);
5697
5698 if (packet_support (PACKET_vCont) == PACKET_DISABLE)
5699 return 0;
5700
5701 p = rs->buf;
5702 endp = rs->buf + get_remote_packet_size ();
5703
5704 /* If we could generate a wider range of packets, we'd have to worry
5705 about overflowing BUF. Should there be a generic
5706 "multi-part-packet" packet? */
5707
5708 p += xsnprintf (p, endp - p, "vCont");
5709
5710 if (ptid_equal (ptid, magic_null_ptid))
5711 {
5712 /* MAGIC_NULL_PTID means that we don't have any active threads,
5713 so we don't have any TID numbers the inferior will
5714 understand. Make sure to only send forms that do not specify
5715 a TID. */
5716 append_resumption (p, endp, minus_one_ptid, step, siggnal);
5717 }
5718 else if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
5719 {
5720 /* Resume all threads (of all processes, or of a single
5721 process), with preference for INFERIOR_PTID. This assumes
5722 inferior_ptid belongs to the set of all threads we are about
5723 to resume. */
5724 if (step || siggnal != GDB_SIGNAL_0)
5725 {
5726 /* Step inferior_ptid, with or without signal. */
5727 p = append_resumption (p, endp, inferior_ptid, step, siggnal);
5728 }
5729
5730 /* Also pass down any pending signaled resumption for other
5731 threads not the current. */
5732 p = append_pending_thread_resumptions (p, endp, ptid);
5733
5734 /* And continue others without a signal. */
5735 append_resumption (p, endp, ptid, /*step=*/ 0, GDB_SIGNAL_0);
5736 }
5737 else
5738 {
5739 /* Scheduler locking; resume only PTID. */
5740 append_resumption (p, endp, ptid, step, siggnal);
5741 }
5742
5743 gdb_assert (strlen (rs->buf) < get_remote_packet_size ());
5744 putpkt (rs->buf);
5745
5746 if (target_is_non_stop_p ())
5747 {
5748 /* In non-stop, the stub replies to vCont with "OK". The stop
5749 reply will be reported asynchronously by means of a `%Stop'
5750 notification. */
5751 getpkt (&rs->buf, &rs->buf_size, 0);
5752 if (strcmp (rs->buf, "OK") != 0)
5753 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
5754 }
5755
5756 return 1;
5757 }
5758
5759 /* Tell the remote machine to resume. */
5760
5761 static void
5762 remote_resume (struct target_ops *ops,
5763 ptid_t ptid, int step, enum gdb_signal siggnal)
5764 {
5765 struct remote_state *rs = get_remote_state ();
5766
5767 /* When connected in non-stop mode, the core resumes threads
5768 individually. Resuming remote threads directly in target_resume
5769 would thus result in sending one packet per thread. Instead, to
5770 minimize roundtrip latency, here we just store the resume
5771 request; the actual remote resumption will be done in
5772 target_commit_resume / remote_commit_resume, where we'll be able
5773 to do vCont action coalescing. */
5774 if (target_is_non_stop_p () && execution_direction != EXEC_REVERSE)
5775 {
5776 struct private_thread_info *remote_thr;
5777
5778 if (ptid_equal (minus_one_ptid, ptid) || ptid_is_pid (ptid))
5779 remote_thr = get_private_info_ptid (inferior_ptid);
5780 else
5781 remote_thr = get_private_info_ptid (ptid);
5782 remote_thr->last_resume_step = step;
5783 remote_thr->last_resume_sig = siggnal;
5784 return;
5785 }
5786
5787 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5788 (explained in remote-notif.c:handle_notification) so
5789 remote_notif_process is not called. We need find a place where
5790 it is safe to start a 'vNotif' sequence. It is good to do it
5791 before resuming inferior, because inferior was stopped and no RSP
5792 traffic at that moment. */
5793 if (!target_is_non_stop_p ())
5794 remote_notif_process (rs->notif_state, &notif_client_stop);
5795
5796 rs->last_resume_exec_dir = execution_direction;
5797
5798 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
5799 if (!remote_resume_with_vcont (ptid, step, siggnal))
5800 remote_resume_with_hc (ops, ptid, step, siggnal);
5801
5802 /* We are about to start executing the inferior, let's register it
5803 with the event loop. NOTE: this is the one place where all the
5804 execution commands end up. We could alternatively do this in each
5805 of the execution commands in infcmd.c. */
5806 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5807 into infcmd.c in order to allow inferior function calls to work
5808 NOT asynchronously. */
5809 if (target_can_async_p ())
5810 target_async (1);
5811
5812 /* We've just told the target to resume. The remote server will
5813 wait for the inferior to stop, and then send a stop reply. In
5814 the mean time, we can't start another command/query ourselves
5815 because the stub wouldn't be ready to process it. This applies
5816 only to the base all-stop protocol, however. In non-stop (which
5817 only supports vCont), the stub replies with an "OK", and is
5818 immediate able to process further serial input. */
5819 if (!target_is_non_stop_p ())
5820 rs->waiting_for_stop_reply = 1;
5821 }
5822
5823 static void check_pending_events_prevent_wildcard_vcont
5824 (int *may_global_wildcard_vcont);
5825 static int is_pending_fork_parent_thread (struct thread_info *thread);
5826
5827 /* Private per-inferior info for target remote processes. */
5828
5829 struct private_inferior
5830 {
5831 /* Whether we can send a wildcard vCont for this process. */
5832 int may_wildcard_vcont;
5833 };
5834
5835 /* Structure used to track the construction of a vCont packet in the
5836 outgoing packet buffer. This is used to send multiple vCont
5837 packets if we have more actions than would fit a single packet. */
5838
5839 struct vcont_builder
5840 {
5841 /* Pointer to the first action. P points here if no action has been
5842 appended yet. */
5843 char *first_action;
5844
5845 /* Where the next action will be appended. */
5846 char *p;
5847
5848 /* The end of the buffer. Must never write past this. */
5849 char *endp;
5850 };
5851
5852 /* Prepare the outgoing buffer for a new vCont packet. */
5853
5854 static void
5855 vcont_builder_restart (struct vcont_builder *builder)
5856 {
5857 struct remote_state *rs = get_remote_state ();
5858
5859 builder->p = rs->buf;
5860 builder->endp = rs->buf + get_remote_packet_size ();
5861 builder->p += xsnprintf (builder->p, builder->endp - builder->p, "vCont");
5862 builder->first_action = builder->p;
5863 }
5864
5865 /* If the vCont packet being built has any action, send it to the
5866 remote end. */
5867
5868 static void
5869 vcont_builder_flush (struct vcont_builder *builder)
5870 {
5871 struct remote_state *rs;
5872
5873 if (builder->p == builder->first_action)
5874 return;
5875
5876 rs = get_remote_state ();
5877 putpkt (rs->buf);
5878 getpkt (&rs->buf, &rs->buf_size, 0);
5879 if (strcmp (rs->buf, "OK") != 0)
5880 error (_("Unexpected vCont reply in non-stop mode: %s"), rs->buf);
5881 }
5882
5883 /* The largest action is range-stepping, with its two addresses. This
5884 is more than sufficient. If a new, bigger action is created, it'll
5885 quickly trigger a failed assertion in append_resumption (and we'll
5886 just bump this). */
5887 #define MAX_ACTION_SIZE 200
5888
5889 /* Append a new vCont action in the outgoing packet being built. If
5890 the action doesn't fit the packet along with previous actions, push
5891 what we've got so far to the remote end and start over a new vCont
5892 packet (with the new action). */
5893
5894 static void
5895 vcont_builder_push_action (struct vcont_builder *builder,
5896 ptid_t ptid, int step, enum gdb_signal siggnal)
5897 {
5898 char buf[MAX_ACTION_SIZE + 1];
5899 char *endp;
5900 size_t rsize;
5901
5902 endp = append_resumption (buf, buf + sizeof (buf),
5903 ptid, step, siggnal);
5904
5905 /* Check whether this new action would fit in the vCont packet along
5906 with previous actions. If not, send what we've got so far and
5907 start a new vCont packet. */
5908 rsize = endp - buf;
5909 if (rsize > builder->endp - builder->p)
5910 {
5911 vcont_builder_flush (builder);
5912 vcont_builder_restart (builder);
5913
5914 /* Should now fit. */
5915 gdb_assert (rsize <= builder->endp - builder->p);
5916 }
5917
5918 memcpy (builder->p, buf, rsize);
5919 builder->p += rsize;
5920 *builder->p = '\0';
5921 }
5922
5923 /* to_commit_resume implementation. */
5924
5925 static void
5926 remote_commit_resume (struct target_ops *ops)
5927 {
5928 struct remote_state *rs = get_remote_state ();
5929 struct inferior *inf;
5930 struct thread_info *tp;
5931 int any_process_wildcard;
5932 int may_global_wildcard_vcont;
5933 struct vcont_builder vcont_builder;
5934
5935 /* If connected in all-stop mode, we'd send the remote resume
5936 request directly from remote_resume. Likewise if
5937 reverse-debugging, as there are no defined vCont actions for
5938 reverse execution. */
5939 if (!target_is_non_stop_p () || execution_direction == EXEC_REVERSE)
5940 return;
5941
5942 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
5943 instead of resuming all threads of each process individually.
5944 However, if any thread of a process must remain halted, we can't
5945 send wildcard resumes and must send one action per thread.
5946
5947 Care must be taken to not resume threads/processes the server
5948 side already told us are stopped, but the core doesn't know about
5949 yet, because the events are still in the vStopped notification
5950 queue. For example:
5951
5952 #1 => vCont s:p1.1;c
5953 #2 <= OK
5954 #3 <= %Stopped T05 p1.1
5955 #4 => vStopped
5956 #5 <= T05 p1.2
5957 #6 => vStopped
5958 #7 <= OK
5959 #8 (infrun handles the stop for p1.1 and continues stepping)
5960 #9 => vCont s:p1.1;c
5961
5962 The last vCont above would resume thread p1.2 by mistake, because
5963 the server has no idea that the event for p1.2 had not been
5964 handled yet.
5965
5966 The server side must similarly ignore resume actions for the
5967 thread that has a pending %Stopped notification (and any other
5968 threads with events pending), until GDB acks the notification
5969 with vStopped. Otherwise, e.g., the following case is
5970 mishandled:
5971
5972 #1 => g (or any other packet)
5973 #2 <= [registers]
5974 #3 <= %Stopped T05 p1.2
5975 #4 => vCont s:p1.1;c
5976 #5 <= OK
5977
5978 Above, the server must not resume thread p1.2. GDB can't know
5979 that p1.2 stopped until it acks the %Stopped notification, and
5980 since from GDB's perspective all threads should be running, it
5981 sends a "c" action.
5982
5983 Finally, special care must also be given to handling fork/vfork
5984 events. A (v)fork event actually tells us that two processes
5985 stopped -- the parent and the child. Until we follow the fork,
5986 we must not resume the child. Therefore, if we have a pending
5987 fork follow, we must not send a global wildcard resume action
5988 (vCont;c). We can still send process-wide wildcards though. */
5989
5990 /* Start by assuming a global wildcard (vCont;c) is possible. */
5991 may_global_wildcard_vcont = 1;
5992
5993 /* And assume every process is individually wildcard-able too. */
5994 ALL_NON_EXITED_INFERIORS (inf)
5995 {
5996 if (inf->priv == NULL)
5997 inf->priv = XNEW (struct private_inferior);
5998 inf->priv->may_wildcard_vcont = 1;
5999 }
6000
6001 /* Check for any pending events (not reported or processed yet) and
6002 disable process and global wildcard resumes appropriately. */
6003 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont);
6004
6005 ALL_NON_EXITED_THREADS (tp)
6006 {
6007 /* If a thread of a process is not meant to be resumed, then we
6008 can't wildcard that process. */
6009 if (!tp->executing)
6010 {
6011 tp->inf->priv->may_wildcard_vcont = 0;
6012
6013 /* And if we can't wildcard a process, we can't wildcard
6014 everything either. */
6015 may_global_wildcard_vcont = 0;
6016 continue;
6017 }
6018
6019 /* If a thread is the parent of an unfollowed fork, then we
6020 can't do a global wildcard, as that would resume the fork
6021 child. */
6022 if (is_pending_fork_parent_thread (tp))
6023 may_global_wildcard_vcont = 0;
6024 }
6025
6026 /* Now let's build the vCont packet(s). Actions must be appended
6027 from narrower to wider scopes (thread -> process -> global). If
6028 we end up with too many actions for a single packet vcont_builder
6029 flushes the current vCont packet to the remote side and starts a
6030 new one. */
6031 vcont_builder_restart (&vcont_builder);
6032
6033 /* Threads first. */
6034 ALL_NON_EXITED_THREADS (tp)
6035 {
6036 struct private_thread_info *remote_thr = tp->priv;
6037
6038 if (!tp->executing || remote_thr->vcont_resumed)
6039 continue;
6040
6041 gdb_assert (!thread_is_in_step_over_chain (tp));
6042
6043 if (!remote_thr->last_resume_step
6044 && remote_thr->last_resume_sig == GDB_SIGNAL_0
6045 && tp->inf->priv->may_wildcard_vcont)
6046 {
6047 /* We'll send a wildcard resume instead. */
6048 remote_thr->vcont_resumed = 1;
6049 continue;
6050 }
6051
6052 vcont_builder_push_action (&vcont_builder, tp->ptid,
6053 remote_thr->last_resume_step,
6054 remote_thr->last_resume_sig);
6055 remote_thr->vcont_resumed = 1;
6056 }
6057
6058 /* Now check whether we can send any process-wide wildcard. This is
6059 to avoid sending a global wildcard in the case nothing is
6060 supposed to be resumed. */
6061 any_process_wildcard = 0;
6062
6063 ALL_NON_EXITED_INFERIORS (inf)
6064 {
6065 if (inf->priv->may_wildcard_vcont)
6066 {
6067 any_process_wildcard = 1;
6068 break;
6069 }
6070 }
6071
6072 if (any_process_wildcard)
6073 {
6074 /* If all processes are wildcard-able, then send a single "c"
6075 action, otherwise, send an "all (-1) threads of process"
6076 continue action for each running process, if any. */
6077 if (may_global_wildcard_vcont)
6078 {
6079 vcont_builder_push_action (&vcont_builder, minus_one_ptid,
6080 0, GDB_SIGNAL_0);
6081 }
6082 else
6083 {
6084 ALL_NON_EXITED_INFERIORS (inf)
6085 {
6086 if (inf->priv->may_wildcard_vcont)
6087 {
6088 vcont_builder_push_action (&vcont_builder,
6089 pid_to_ptid (inf->pid),
6090 0, GDB_SIGNAL_0);
6091 }
6092 }
6093 }
6094 }
6095
6096 vcont_builder_flush (&vcont_builder);
6097 }
6098
6099 \f
6100
6101 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6102 thread, all threads of a remote process, or all threads of all
6103 processes. */
6104
6105 static void
6106 remote_stop_ns (ptid_t ptid)
6107 {
6108 struct remote_state *rs = get_remote_state ();
6109 char *p = rs->buf;
6110 char *endp = rs->buf + get_remote_packet_size ();
6111
6112 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
6113 remote_vcont_probe (rs);
6114
6115 if (!rs->supports_vCont.t)
6116 error (_("Remote server does not support stopping threads"));
6117
6118 if (ptid_equal (ptid, minus_one_ptid)
6119 || (!remote_multi_process_p (rs) && ptid_is_pid (ptid)))
6120 p += xsnprintf (p, endp - p, "vCont;t");
6121 else
6122 {
6123 ptid_t nptid;
6124
6125 p += xsnprintf (p, endp - p, "vCont;t:");
6126
6127 if (ptid_is_pid (ptid))
6128 /* All (-1) threads of process. */
6129 nptid = ptid_build (ptid_get_pid (ptid), -1, 0);
6130 else
6131 {
6132 /* Small optimization: if we already have a stop reply for
6133 this thread, no use in telling the stub we want this
6134 stopped. */
6135 if (peek_stop_reply (ptid))
6136 return;
6137
6138 nptid = ptid;
6139 }
6140
6141 write_ptid (p, endp, nptid);
6142 }
6143
6144 /* In non-stop, we get an immediate OK reply. The stop reply will
6145 come in asynchronously by notification. */
6146 putpkt (rs->buf);
6147 getpkt (&rs->buf, &rs->buf_size, 0);
6148 if (strcmp (rs->buf, "OK") != 0)
6149 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid), rs->buf);
6150 }
6151
6152 /* All-stop version of target_interrupt. Sends a break or a ^C to
6153 interrupt the remote target. It is undefined which thread of which
6154 process reports the interrupt. */
6155
6156 static void
6157 remote_interrupt_as (void)
6158 {
6159 struct remote_state *rs = get_remote_state ();
6160
6161 rs->ctrlc_pending_p = 1;
6162
6163 /* If the inferior is stopped already, but the core didn't know
6164 about it yet, just ignore the request. The cached wait status
6165 will be collected in remote_wait. */
6166 if (rs->cached_wait_status)
6167 return;
6168
6169 /* Send interrupt_sequence to remote target. */
6170 send_interrupt_sequence ();
6171 }
6172
6173 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6174 the remote target. It is undefined which thread of which process
6175 reports the interrupt. Throws an error if the packet is not
6176 supported by the server. */
6177
6178 static void
6179 remote_interrupt_ns (void)
6180 {
6181 struct remote_state *rs = get_remote_state ();
6182 char *p = rs->buf;
6183 char *endp = rs->buf + get_remote_packet_size ();
6184
6185 xsnprintf (p, endp - p, "vCtrlC");
6186
6187 /* In non-stop, we get an immediate OK reply. The stop reply will
6188 come in asynchronously by notification. */
6189 putpkt (rs->buf);
6190 getpkt (&rs->buf, &rs->buf_size, 0);
6191
6192 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vCtrlC]))
6193 {
6194 case PACKET_OK:
6195 break;
6196 case PACKET_UNKNOWN:
6197 error (_("No support for interrupting the remote target."));
6198 case PACKET_ERROR:
6199 error (_("Interrupting target failed: %s"), rs->buf);
6200 }
6201 }
6202
6203 /* Implement the to_stop function for the remote targets. */
6204
6205 static void
6206 remote_stop (struct target_ops *self, ptid_t ptid)
6207 {
6208 if (remote_debug)
6209 fprintf_unfiltered (gdb_stdlog, "remote_stop called\n");
6210
6211 if (target_is_non_stop_p ())
6212 remote_stop_ns (ptid);
6213 else
6214 {
6215 /* We don't currently have a way to transparently pause the
6216 remote target in all-stop mode. Interrupt it instead. */
6217 remote_interrupt_as ();
6218 }
6219 }
6220
6221 /* Implement the to_interrupt function for the remote targets. */
6222
6223 static void
6224 remote_interrupt (struct target_ops *self, ptid_t ptid)
6225 {
6226 struct remote_state *rs = get_remote_state ();
6227
6228 if (remote_debug)
6229 fprintf_unfiltered (gdb_stdlog, "remote_interrupt called\n");
6230
6231 if (target_is_non_stop_p ())
6232 remote_interrupt_ns ();
6233 else
6234 remote_interrupt_as ();
6235 }
6236
6237 /* Implement the to_pass_ctrlc function for the remote targets. */
6238
6239 static void
6240 remote_pass_ctrlc (struct target_ops *self)
6241 {
6242 struct remote_state *rs = get_remote_state ();
6243
6244 if (remote_debug)
6245 fprintf_unfiltered (gdb_stdlog, "remote_pass_ctrlc called\n");
6246
6247 /* If we're starting up, we're not fully synced yet. Quit
6248 immediately. */
6249 if (rs->starting_up)
6250 quit ();
6251 /* If ^C has already been sent once, offer to disconnect. */
6252 else if (rs->ctrlc_pending_p)
6253 interrupt_query ();
6254 else
6255 target_interrupt (inferior_ptid);
6256 }
6257
6258 /* Ask the user what to do when an interrupt is received. */
6259
6260 static void
6261 interrupt_query (void)
6262 {
6263 struct remote_state *rs = get_remote_state ();
6264
6265 if (rs->waiting_for_stop_reply && rs->ctrlc_pending_p)
6266 {
6267 if (query (_("The target is not responding to interrupt requests.\n"
6268 "Stop debugging it? ")))
6269 {
6270 remote_unpush_target ();
6271 throw_error (TARGET_CLOSE_ERROR, _("Disconnected from target."));
6272 }
6273 }
6274 else
6275 {
6276 if (query (_("Interrupted while waiting for the program.\n"
6277 "Give up waiting? ")))
6278 quit ();
6279 }
6280 }
6281
6282 /* Enable/disable target terminal ownership. Most targets can use
6283 terminal groups to control terminal ownership. Remote targets are
6284 different in that explicit transfer of ownership to/from GDB/target
6285 is required. */
6286
6287 static void
6288 remote_terminal_inferior (struct target_ops *self)
6289 {
6290 /* NOTE: At this point we could also register our selves as the
6291 recipient of all input. Any characters typed could then be
6292 passed on down to the target. */
6293 }
6294
6295 static void
6296 remote_terminal_ours (struct target_ops *self)
6297 {
6298 }
6299
6300 static void
6301 remote_console_output (char *msg)
6302 {
6303 char *p;
6304
6305 for (p = msg; p[0] && p[1]; p += 2)
6306 {
6307 char tb[2];
6308 char c = fromhex (p[0]) * 16 + fromhex (p[1]);
6309
6310 tb[0] = c;
6311 tb[1] = 0;
6312 fputs_unfiltered (tb, gdb_stdtarg);
6313 }
6314 gdb_flush (gdb_stdtarg);
6315 }
6316
6317 DEF_VEC_O(cached_reg_t);
6318
6319 typedef struct stop_reply
6320 {
6321 struct notif_event base;
6322
6323 /* The identifier of the thread about this event */
6324 ptid_t ptid;
6325
6326 /* The remote state this event is associated with. When the remote
6327 connection, represented by a remote_state object, is closed,
6328 all the associated stop_reply events should be released. */
6329 struct remote_state *rs;
6330
6331 struct target_waitstatus ws;
6332
6333 /* The architecture associated with the expedited registers. */
6334 gdbarch *arch;
6335
6336 /* Expedited registers. This makes remote debugging a bit more
6337 efficient for those targets that provide critical registers as
6338 part of their normal status mechanism (as another roundtrip to
6339 fetch them is avoided). */
6340 VEC(cached_reg_t) *regcache;
6341
6342 enum target_stop_reason stop_reason;
6343
6344 CORE_ADDR watch_data_address;
6345
6346 int core;
6347 } *stop_reply_p;
6348
6349 DECLARE_QUEUE_P (stop_reply_p);
6350 DEFINE_QUEUE_P (stop_reply_p);
6351 /* The list of already fetched and acknowledged stop events. This
6352 queue is used for notification Stop, and other notifications
6353 don't need queue for their events, because the notification events
6354 of Stop can't be consumed immediately, so that events should be
6355 queued first, and be consumed by remote_wait_{ns,as} one per
6356 time. Other notifications can consume their events immediately,
6357 so queue is not needed for them. */
6358 static QUEUE (stop_reply_p) *stop_reply_queue;
6359
6360 static void
6361 stop_reply_xfree (struct stop_reply *r)
6362 {
6363 notif_event_xfree ((struct notif_event *) r);
6364 }
6365
6366 /* Return the length of the stop reply queue. */
6367
6368 static int
6369 stop_reply_queue_length (void)
6370 {
6371 return QUEUE_length (stop_reply_p, stop_reply_queue);
6372 }
6373
6374 static void
6375 remote_notif_stop_parse (struct notif_client *self, char *buf,
6376 struct notif_event *event)
6377 {
6378 remote_parse_stop_reply (buf, (struct stop_reply *) event);
6379 }
6380
6381 static void
6382 remote_notif_stop_ack (struct notif_client *self, char *buf,
6383 struct notif_event *event)
6384 {
6385 struct stop_reply *stop_reply = (struct stop_reply *) event;
6386
6387 /* acknowledge */
6388 putpkt (self->ack_command);
6389
6390 if (stop_reply->ws.kind == TARGET_WAITKIND_IGNORE)
6391 /* We got an unknown stop reply. */
6392 error (_("Unknown stop reply"));
6393
6394 push_stop_reply (stop_reply);
6395 }
6396
6397 static int
6398 remote_notif_stop_can_get_pending_events (struct notif_client *self)
6399 {
6400 /* We can't get pending events in remote_notif_process for
6401 notification stop, and we have to do this in remote_wait_ns
6402 instead. If we fetch all queued events from stub, remote stub
6403 may exit and we have no chance to process them back in
6404 remote_wait_ns. */
6405 mark_async_event_handler (remote_async_inferior_event_token);
6406 return 0;
6407 }
6408
6409 static void
6410 stop_reply_dtr (struct notif_event *event)
6411 {
6412 struct stop_reply *r = (struct stop_reply *) event;
6413 cached_reg_t *reg;
6414 int ix;
6415
6416 for (ix = 0;
6417 VEC_iterate (cached_reg_t, r->regcache, ix, reg);
6418 ix++)
6419 xfree (reg->data);
6420
6421 VEC_free (cached_reg_t, r->regcache);
6422 }
6423
6424 static struct notif_event *
6425 remote_notif_stop_alloc_reply (void)
6426 {
6427 /* We cast to a pointer to the "base class". */
6428 struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply);
6429
6430 r->dtr = stop_reply_dtr;
6431
6432 return r;
6433 }
6434
6435 /* A client of notification Stop. */
6436
6437 struct notif_client notif_client_stop =
6438 {
6439 "Stop",
6440 "vStopped",
6441 remote_notif_stop_parse,
6442 remote_notif_stop_ack,
6443 remote_notif_stop_can_get_pending_events,
6444 remote_notif_stop_alloc_reply,
6445 REMOTE_NOTIF_STOP,
6446 };
6447
6448 /* A parameter to pass data in and out. */
6449
6450 struct queue_iter_param
6451 {
6452 void *input;
6453 struct stop_reply *output;
6454 };
6455
6456 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6457 the pid of the process that owns the threads we want to check, or
6458 -1 if we want to check all threads. */
6459
6460 static int
6461 is_pending_fork_parent (struct target_waitstatus *ws, int event_pid,
6462 ptid_t thread_ptid)
6463 {
6464 if (ws->kind == TARGET_WAITKIND_FORKED
6465 || ws->kind == TARGET_WAITKIND_VFORKED)
6466 {
6467 if (event_pid == -1 || event_pid == ptid_get_pid (thread_ptid))
6468 return 1;
6469 }
6470
6471 return 0;
6472 }
6473
6474 /* Return the thread's pending status used to determine whether the
6475 thread is a fork parent stopped at a fork event. */
6476
6477 static struct target_waitstatus *
6478 thread_pending_fork_status (struct thread_info *thread)
6479 {
6480 if (thread->suspend.waitstatus_pending_p)
6481 return &thread->suspend.waitstatus;
6482 else
6483 return &thread->pending_follow;
6484 }
6485
6486 /* Determine if THREAD is a pending fork parent thread. */
6487
6488 static int
6489 is_pending_fork_parent_thread (struct thread_info *thread)
6490 {
6491 struct target_waitstatus *ws = thread_pending_fork_status (thread);
6492 int pid = -1;
6493
6494 return is_pending_fork_parent (ws, pid, thread->ptid);
6495 }
6496
6497 /* Check whether EVENT is a fork event, and if it is, remove the
6498 fork child from the context list passed in DATA. */
6499
6500 static int
6501 remove_child_of_pending_fork (QUEUE (stop_reply_p) *q,
6502 QUEUE_ITER (stop_reply_p) *iter,
6503 stop_reply_p event,
6504 void *data)
6505 {
6506 struct queue_iter_param *param = (struct queue_iter_param *) data;
6507 struct threads_listing_context *context
6508 = (struct threads_listing_context *) param->input;
6509
6510 if (event->ws.kind == TARGET_WAITKIND_FORKED
6511 || event->ws.kind == TARGET_WAITKIND_VFORKED
6512 || event->ws.kind == TARGET_WAITKIND_THREAD_EXITED)
6513 threads_listing_context_remove (&event->ws, context);
6514
6515 return 1;
6516 }
6517
6518 /* If CONTEXT contains any fork child threads that have not been
6519 reported yet, remove them from the CONTEXT list. If such a
6520 thread exists it is because we are stopped at a fork catchpoint
6521 and have not yet called follow_fork, which will set up the
6522 host-side data structures for the new process. */
6523
6524 static void
6525 remove_new_fork_children (struct threads_listing_context *context)
6526 {
6527 struct thread_info * thread;
6528 int pid = -1;
6529 struct notif_client *notif = &notif_client_stop;
6530 struct queue_iter_param param;
6531
6532 /* For any threads stopped at a fork event, remove the corresponding
6533 fork child threads from the CONTEXT list. */
6534 ALL_NON_EXITED_THREADS (thread)
6535 {
6536 struct target_waitstatus *ws = thread_pending_fork_status (thread);
6537
6538 if (is_pending_fork_parent (ws, pid, thread->ptid))
6539 {
6540 threads_listing_context_remove (ws, context);
6541 }
6542 }
6543
6544 /* Check for any pending fork events (not reported or processed yet)
6545 in process PID and remove those fork child threads from the
6546 CONTEXT list as well. */
6547 remote_notif_get_pending_events (notif);
6548 param.input = context;
6549 param.output = NULL;
6550 QUEUE_iterate (stop_reply_p, stop_reply_queue,
6551 remove_child_of_pending_fork, &param);
6552 }
6553
6554 /* Check whether EVENT would prevent a global or process wildcard
6555 vCont action. */
6556
6557 static int
6558 check_pending_event_prevents_wildcard_vcont_callback
6559 (QUEUE (stop_reply_p) *q,
6560 QUEUE_ITER (stop_reply_p) *iter,
6561 stop_reply_p event,
6562 void *data)
6563 {
6564 struct inferior *inf;
6565 int *may_global_wildcard_vcont = (int *) data;
6566
6567 if (event->ws.kind == TARGET_WAITKIND_NO_RESUMED
6568 || event->ws.kind == TARGET_WAITKIND_NO_HISTORY)
6569 return 1;
6570
6571 if (event->ws.kind == TARGET_WAITKIND_FORKED
6572 || event->ws.kind == TARGET_WAITKIND_VFORKED)
6573 *may_global_wildcard_vcont = 0;
6574
6575 inf = find_inferior_ptid (event->ptid);
6576
6577 /* This may be the first time we heard about this process.
6578 Regardless, we must not do a global wildcard resume, otherwise
6579 we'd resume this process too. */
6580 *may_global_wildcard_vcont = 0;
6581 if (inf != NULL)
6582 inf->priv->may_wildcard_vcont = 0;
6583
6584 return 1;
6585 }
6586
6587 /* Check whether any event pending in the vStopped queue would prevent
6588 a global or process wildcard vCont action. Clear
6589 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6590 and clear the event inferior's may_wildcard_vcont flag if we can't
6591 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6592
6593 static void
6594 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard)
6595 {
6596 struct notif_client *notif = &notif_client_stop;
6597
6598 remote_notif_get_pending_events (notif);
6599 QUEUE_iterate (stop_reply_p, stop_reply_queue,
6600 check_pending_event_prevents_wildcard_vcont_callback,
6601 may_global_wildcard);
6602 }
6603
6604 /* Remove stop replies in the queue if its pid is equal to the given
6605 inferior's pid. */
6606
6607 static int
6608 remove_stop_reply_for_inferior (QUEUE (stop_reply_p) *q,
6609 QUEUE_ITER (stop_reply_p) *iter,
6610 stop_reply_p event,
6611 void *data)
6612 {
6613 struct queue_iter_param *param = (struct queue_iter_param *) data;
6614 struct inferior *inf = (struct inferior *) param->input;
6615
6616 if (ptid_get_pid (event->ptid) == inf->pid)
6617 {
6618 stop_reply_xfree (event);
6619 QUEUE_remove_elem (stop_reply_p, q, iter);
6620 }
6621
6622 return 1;
6623 }
6624
6625 /* Discard all pending stop replies of inferior INF. */
6626
6627 static void
6628 discard_pending_stop_replies (struct inferior *inf)
6629 {
6630 struct queue_iter_param param;
6631 struct stop_reply *reply;
6632 struct remote_state *rs = get_remote_state ();
6633 struct remote_notif_state *rns = rs->notif_state;
6634
6635 /* This function can be notified when an inferior exists. When the
6636 target is not remote, the notification state is NULL. */
6637 if (rs->remote_desc == NULL)
6638 return;
6639
6640 reply = (struct stop_reply *) rns->pending_event[notif_client_stop.id];
6641
6642 /* Discard the in-flight notification. */
6643 if (reply != NULL && ptid_get_pid (reply->ptid) == inf->pid)
6644 {
6645 stop_reply_xfree (reply);
6646 rns->pending_event[notif_client_stop.id] = NULL;
6647 }
6648
6649 param.input = inf;
6650 param.output = NULL;
6651 /* Discard the stop replies we have already pulled with
6652 vStopped. */
6653 QUEUE_iterate (stop_reply_p, stop_reply_queue,
6654 remove_stop_reply_for_inferior, &param);
6655 }
6656
6657 /* If its remote state is equal to the given remote state,
6658 remove EVENT from the stop reply queue. */
6659
6660 static int
6661 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p) *q,
6662 QUEUE_ITER (stop_reply_p) *iter,
6663 stop_reply_p event,
6664 void *data)
6665 {
6666 struct queue_iter_param *param = (struct queue_iter_param *) data;
6667 struct remote_state *rs = (struct remote_state *) param->input;
6668
6669 if (event->rs == rs)
6670 {
6671 stop_reply_xfree (event);
6672 QUEUE_remove_elem (stop_reply_p, q, iter);
6673 }
6674
6675 return 1;
6676 }
6677
6678 /* Discard the stop replies for RS in stop_reply_queue. */
6679
6680 static void
6681 discard_pending_stop_replies_in_queue (struct remote_state *rs)
6682 {
6683 struct queue_iter_param param;
6684
6685 param.input = rs;
6686 param.output = NULL;
6687 /* Discard the stop replies we have already pulled with
6688 vStopped. */
6689 QUEUE_iterate (stop_reply_p, stop_reply_queue,
6690 remove_stop_reply_of_remote_state, &param);
6691 }
6692
6693 /* A parameter to pass data in and out. */
6694
6695 static int
6696 remote_notif_remove_once_on_match (QUEUE (stop_reply_p) *q,
6697 QUEUE_ITER (stop_reply_p) *iter,
6698 stop_reply_p event,
6699 void *data)
6700 {
6701 struct queue_iter_param *param = (struct queue_iter_param *) data;
6702 ptid_t *ptid = (ptid_t *) param->input;
6703
6704 if (ptid_match (event->ptid, *ptid))
6705 {
6706 param->output = event;
6707 QUEUE_remove_elem (stop_reply_p, q, iter);
6708 return 0;
6709 }
6710
6711 return 1;
6712 }
6713
6714 /* Remove the first reply in 'stop_reply_queue' which matches
6715 PTID. */
6716
6717 static struct stop_reply *
6718 remote_notif_remove_queued_reply (ptid_t ptid)
6719 {
6720 struct queue_iter_param param;
6721
6722 param.input = &ptid;
6723 param.output = NULL;
6724
6725 QUEUE_iterate (stop_reply_p, stop_reply_queue,
6726 remote_notif_remove_once_on_match, &param);
6727 if (notif_debug)
6728 fprintf_unfiltered (gdb_stdlog,
6729 "notif: discard queued event: 'Stop' in %s\n",
6730 target_pid_to_str (ptid));
6731
6732 return param.output;
6733 }
6734
6735 /* Look for a queued stop reply belonging to PTID. If one is found,
6736 remove it from the queue, and return it. Returns NULL if none is
6737 found. If there are still queued events left to process, tell the
6738 event loop to get back to target_wait soon. */
6739
6740 static struct stop_reply *
6741 queued_stop_reply (ptid_t ptid)
6742 {
6743 struct stop_reply *r = remote_notif_remove_queued_reply (ptid);
6744
6745 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
6746 /* There's still at least an event left. */
6747 mark_async_event_handler (remote_async_inferior_event_token);
6748
6749 return r;
6750 }
6751
6752 /* Push a fully parsed stop reply in the stop reply queue. Since we
6753 know that we now have at least one queued event left to pass to the
6754 core side, tell the event loop to get back to target_wait soon. */
6755
6756 static void
6757 push_stop_reply (struct stop_reply *new_event)
6758 {
6759 QUEUE_enque (stop_reply_p, stop_reply_queue, new_event);
6760
6761 if (notif_debug)
6762 fprintf_unfiltered (gdb_stdlog,
6763 "notif: push 'Stop' %s to queue %d\n",
6764 target_pid_to_str (new_event->ptid),
6765 QUEUE_length (stop_reply_p,
6766 stop_reply_queue));
6767
6768 mark_async_event_handler (remote_async_inferior_event_token);
6769 }
6770
6771 static int
6772 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p) *q,
6773 QUEUE_ITER (stop_reply_p) *iter,
6774 struct stop_reply *event,
6775 void *data)
6776 {
6777 ptid_t *ptid = (ptid_t *) data;
6778
6779 return !(ptid_equal (*ptid, event->ptid)
6780 && event->ws.kind == TARGET_WAITKIND_STOPPED);
6781 }
6782
6783 /* Returns true if we have a stop reply for PTID. */
6784
6785 static int
6786 peek_stop_reply (ptid_t ptid)
6787 {
6788 return !QUEUE_iterate (stop_reply_p, stop_reply_queue,
6789 stop_reply_match_ptid_and_ws, &ptid);
6790 }
6791
6792 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6793 starting with P and ending with PEND matches PREFIX. */
6794
6795 static int
6796 strprefix (const char *p, const char *pend, const char *prefix)
6797 {
6798 for ( ; p < pend; p++, prefix++)
6799 if (*p != *prefix)
6800 return 0;
6801 return *prefix == '\0';
6802 }
6803
6804 /* Parse the stop reply in BUF. Either the function succeeds, and the
6805 result is stored in EVENT, or throws an error. */
6806
6807 static void
6808 remote_parse_stop_reply (char *buf, struct stop_reply *event)
6809 {
6810 remote_arch_state *rsa = NULL;
6811 ULONGEST addr;
6812 const char *p;
6813 int skipregs = 0;
6814
6815 event->ptid = null_ptid;
6816 event->rs = get_remote_state ();
6817 event->ws.kind = TARGET_WAITKIND_IGNORE;
6818 event->ws.value.integer = 0;
6819 event->stop_reason = TARGET_STOPPED_BY_NO_REASON;
6820 event->regcache = NULL;
6821 event->core = -1;
6822
6823 switch (buf[0])
6824 {
6825 case 'T': /* Status with PC, SP, FP, ... */
6826 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6827 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6828 ss = signal number
6829 n... = register number
6830 r... = register contents
6831 */
6832
6833 p = &buf[3]; /* after Txx */
6834 while (*p)
6835 {
6836 const char *p1;
6837 int fieldsize;
6838
6839 p1 = strchr (p, ':');
6840 if (p1 == NULL)
6841 error (_("Malformed packet(a) (missing colon): %s\n\
6842 Packet: '%s'\n"),
6843 p, buf);
6844 if (p == p1)
6845 error (_("Malformed packet(a) (missing register number): %s\n\
6846 Packet: '%s'\n"),
6847 p, buf);
6848
6849 /* Some "registers" are actually extended stop information.
6850 Note if you're adding a new entry here: GDB 7.9 and
6851 earlier assume that all register "numbers" that start
6852 with an hex digit are real register numbers. Make sure
6853 the server only sends such a packet if it knows the
6854 client understands it. */
6855
6856 if (strprefix (p, p1, "thread"))
6857 event->ptid = read_ptid (++p1, &p);
6858 else if (strprefix (p, p1, "syscall_entry"))
6859 {
6860 ULONGEST sysno;
6861
6862 event->ws.kind = TARGET_WAITKIND_SYSCALL_ENTRY;
6863 p = unpack_varlen_hex (++p1, &sysno);
6864 event->ws.value.syscall_number = (int) sysno;
6865 }
6866 else if (strprefix (p, p1, "syscall_return"))
6867 {
6868 ULONGEST sysno;
6869
6870 event->ws.kind = TARGET_WAITKIND_SYSCALL_RETURN;
6871 p = unpack_varlen_hex (++p1, &sysno);
6872 event->ws.value.syscall_number = (int) sysno;
6873 }
6874 else if (strprefix (p, p1, "watch")
6875 || strprefix (p, p1, "rwatch")
6876 || strprefix (p, p1, "awatch"))
6877 {
6878 event->stop_reason = TARGET_STOPPED_BY_WATCHPOINT;
6879 p = unpack_varlen_hex (++p1, &addr);
6880 event->watch_data_address = (CORE_ADDR) addr;
6881 }
6882 else if (strprefix (p, p1, "swbreak"))
6883 {
6884 event->stop_reason = TARGET_STOPPED_BY_SW_BREAKPOINT;
6885
6886 /* Make sure the stub doesn't forget to indicate support
6887 with qSupported. */
6888 if (packet_support (PACKET_swbreak_feature) != PACKET_ENABLE)
6889 error (_("Unexpected swbreak stop reason"));
6890
6891 /* The value part is documented as "must be empty",
6892 though we ignore it, in case we ever decide to make
6893 use of it in a backward compatible way. */
6894 p = strchrnul (p1 + 1, ';');
6895 }
6896 else if (strprefix (p, p1, "hwbreak"))
6897 {
6898 event->stop_reason = TARGET_STOPPED_BY_HW_BREAKPOINT;
6899
6900 /* Make sure the stub doesn't forget to indicate support
6901 with qSupported. */
6902 if (packet_support (PACKET_hwbreak_feature) != PACKET_ENABLE)
6903 error (_("Unexpected hwbreak stop reason"));
6904
6905 /* See above. */
6906 p = strchrnul (p1 + 1, ';');
6907 }
6908 else if (strprefix (p, p1, "library"))
6909 {
6910 event->ws.kind = TARGET_WAITKIND_LOADED;
6911 p = strchrnul (p1 + 1, ';');
6912 }
6913 else if (strprefix (p, p1, "replaylog"))
6914 {
6915 event->ws.kind = TARGET_WAITKIND_NO_HISTORY;
6916 /* p1 will indicate "begin" or "end", but it makes
6917 no difference for now, so ignore it. */
6918 p = strchrnul (p1 + 1, ';');
6919 }
6920 else if (strprefix (p, p1, "core"))
6921 {
6922 ULONGEST c;
6923
6924 p = unpack_varlen_hex (++p1, &c);
6925 event->core = c;
6926 }
6927 else if (strprefix (p, p1, "fork"))
6928 {
6929 event->ws.value.related_pid = read_ptid (++p1, &p);
6930 event->ws.kind = TARGET_WAITKIND_FORKED;
6931 }
6932 else if (strprefix (p, p1, "vfork"))
6933 {
6934 event->ws.value.related_pid = read_ptid (++p1, &p);
6935 event->ws.kind = TARGET_WAITKIND_VFORKED;
6936 }
6937 else if (strprefix (p, p1, "vforkdone"))
6938 {
6939 event->ws.kind = TARGET_WAITKIND_VFORK_DONE;
6940 p = strchrnul (p1 + 1, ';');
6941 }
6942 else if (strprefix (p, p1, "exec"))
6943 {
6944 ULONGEST ignored;
6945 char pathname[PATH_MAX];
6946 int pathlen;
6947
6948 /* Determine the length of the execd pathname. */
6949 p = unpack_varlen_hex (++p1, &ignored);
6950 pathlen = (p - p1) / 2;
6951
6952 /* Save the pathname for event reporting and for
6953 the next run command. */
6954 hex2bin (p1, (gdb_byte *) pathname, pathlen);
6955 pathname[pathlen] = '\0';
6956
6957 /* This is freed during event handling. */
6958 event->ws.value.execd_pathname = xstrdup (pathname);
6959 event->ws.kind = TARGET_WAITKIND_EXECD;
6960
6961 /* Skip the registers included in this packet, since
6962 they may be for an architecture different from the
6963 one used by the original program. */
6964 skipregs = 1;
6965 }
6966 else if (strprefix (p, p1, "create"))
6967 {
6968 event->ws.kind = TARGET_WAITKIND_THREAD_CREATED;
6969 p = strchrnul (p1 + 1, ';');
6970 }
6971 else
6972 {
6973 ULONGEST pnum;
6974 const char *p_temp;
6975
6976 if (skipregs)
6977 {
6978 p = strchrnul (p1 + 1, ';');
6979 p++;
6980 continue;
6981 }
6982
6983 /* Maybe a real ``P'' register number. */
6984 p_temp = unpack_varlen_hex (p, &pnum);
6985 /* If the first invalid character is the colon, we got a
6986 register number. Otherwise, it's an unknown stop
6987 reason. */
6988 if (p_temp == p1)
6989 {
6990 /* If we haven't parsed the event's thread yet, find
6991 it now, in order to find the architecture of the
6992 reported expedited registers. */
6993 if (event->ptid == null_ptid)
6994 {
6995 const char *thr = strstr (p1 + 1, ";thread:");
6996 if (thr != NULL)
6997 event->ptid = read_ptid (thr + strlen (";thread:"),
6998 NULL);
6999 else
7000 event->ptid = magic_null_ptid;
7001 }
7002
7003 if (rsa == NULL)
7004 {
7005 inferior *inf = (event->ptid == null_ptid
7006 ? NULL
7007 : find_inferior_ptid (event->ptid));
7008 /* If this is the first time we learn anything
7009 about this process, skip the registers
7010 included in this packet, since we don't yet
7011 know which architecture to use to parse them.
7012 We'll determine the architecture later when
7013 we process the stop reply and retrieve the
7014 target description, via
7015 remote_notice_new_inferior ->
7016 post_create_inferior. */
7017 if (inf == NULL)
7018 {
7019 p = strchrnul (p1 + 1, ';');
7020 p++;
7021 continue;
7022 }
7023
7024 event->arch = inf->gdbarch;
7025 rsa = get_remote_arch_state (event->arch);
7026 }
7027
7028 packet_reg *reg
7029 = packet_reg_from_pnum (event->arch, rsa, pnum);
7030 cached_reg_t cached_reg;
7031
7032 if (reg == NULL)
7033 error (_("Remote sent bad register number %s: %s\n\
7034 Packet: '%s'\n"),
7035 hex_string (pnum), p, buf);
7036
7037 cached_reg.num = reg->regnum;
7038 cached_reg.data = (gdb_byte *)
7039 xmalloc (register_size (event->arch, reg->regnum));
7040
7041 p = p1 + 1;
7042 fieldsize = hex2bin (p, cached_reg.data,
7043 register_size (event->arch, reg->regnum));
7044 p += 2 * fieldsize;
7045 if (fieldsize < register_size (event->arch, reg->regnum))
7046 warning (_("Remote reply is too short: %s"), buf);
7047
7048 VEC_safe_push (cached_reg_t, event->regcache, &cached_reg);
7049 }
7050 else
7051 {
7052 /* Not a number. Silently skip unknown optional
7053 info. */
7054 p = strchrnul (p1 + 1, ';');
7055 }
7056 }
7057
7058 if (*p != ';')
7059 error (_("Remote register badly formatted: %s\nhere: %s"),
7060 buf, p);
7061 ++p;
7062 }
7063
7064 if (event->ws.kind != TARGET_WAITKIND_IGNORE)
7065 break;
7066
7067 /* fall through */
7068 case 'S': /* Old style status, just signal only. */
7069 {
7070 int sig;
7071
7072 event->ws.kind = TARGET_WAITKIND_STOPPED;
7073 sig = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
7074 if (GDB_SIGNAL_FIRST <= sig && sig < GDB_SIGNAL_LAST)
7075 event->ws.value.sig = (enum gdb_signal) sig;
7076 else
7077 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7078 }
7079 break;
7080 case 'w': /* Thread exited. */
7081 {
7082 const char *p;
7083 ULONGEST value;
7084
7085 event->ws.kind = TARGET_WAITKIND_THREAD_EXITED;
7086 p = unpack_varlen_hex (&buf[1], &value);
7087 event->ws.value.integer = value;
7088 if (*p != ';')
7089 error (_("stop reply packet badly formatted: %s"), buf);
7090 event->ptid = read_ptid (++p, NULL);
7091 break;
7092 }
7093 case 'W': /* Target exited. */
7094 case 'X':
7095 {
7096 const char *p;
7097 int pid;
7098 ULONGEST value;
7099
7100 /* GDB used to accept only 2 hex chars here. Stubs should
7101 only send more if they detect GDB supports multi-process
7102 support. */
7103 p = unpack_varlen_hex (&buf[1], &value);
7104
7105 if (buf[0] == 'W')
7106 {
7107 /* The remote process exited. */
7108 event->ws.kind = TARGET_WAITKIND_EXITED;
7109 event->ws.value.integer = value;
7110 }
7111 else
7112 {
7113 /* The remote process exited with a signal. */
7114 event->ws.kind = TARGET_WAITKIND_SIGNALLED;
7115 if (GDB_SIGNAL_FIRST <= value && value < GDB_SIGNAL_LAST)
7116 event->ws.value.sig = (enum gdb_signal) value;
7117 else
7118 event->ws.value.sig = GDB_SIGNAL_UNKNOWN;
7119 }
7120
7121 /* If no process is specified, assume inferior_ptid. */
7122 pid = ptid_get_pid (inferior_ptid);
7123 if (*p == '\0')
7124 ;
7125 else if (*p == ';')
7126 {
7127 p++;
7128
7129 if (*p == '\0')
7130 ;
7131 else if (startswith (p, "process:"))
7132 {
7133 ULONGEST upid;
7134
7135 p += sizeof ("process:") - 1;
7136 unpack_varlen_hex (p, &upid);
7137 pid = upid;
7138 }
7139 else
7140 error (_("unknown stop reply packet: %s"), buf);
7141 }
7142 else
7143 error (_("unknown stop reply packet: %s"), buf);
7144 event->ptid = pid_to_ptid (pid);
7145 }
7146 break;
7147 case 'N':
7148 event->ws.kind = TARGET_WAITKIND_NO_RESUMED;
7149 event->ptid = minus_one_ptid;
7150 break;
7151 }
7152
7153 if (target_is_non_stop_p () && ptid_equal (event->ptid, null_ptid))
7154 error (_("No process or thread specified in stop reply: %s"), buf);
7155 }
7156
7157 /* When the stub wants to tell GDB about a new notification reply, it
7158 sends a notification (%Stop, for example). Those can come it at
7159 any time, hence, we have to make sure that any pending
7160 putpkt/getpkt sequence we're making is finished, before querying
7161 the stub for more events with the corresponding ack command
7162 (vStopped, for example). E.g., if we started a vStopped sequence
7163 immediately upon receiving the notification, something like this
7164 could happen:
7165
7166 1.1) --> Hg 1
7167 1.2) <-- OK
7168 1.3) --> g
7169 1.4) <-- %Stop
7170 1.5) --> vStopped
7171 1.6) <-- (registers reply to step #1.3)
7172
7173 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7174 query.
7175
7176 To solve this, whenever we parse a %Stop notification successfully,
7177 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7178 doing whatever we were doing:
7179
7180 2.1) --> Hg 1
7181 2.2) <-- OK
7182 2.3) --> g
7183 2.4) <-- %Stop
7184 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7185 2.5) <-- (registers reply to step #2.3)
7186
7187 Eventualy after step #2.5, we return to the event loop, which
7188 notices there's an event on the
7189 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7190 associated callback --- the function below. At this point, we're
7191 always safe to start a vStopped sequence. :
7192
7193 2.6) --> vStopped
7194 2.7) <-- T05 thread:2
7195 2.8) --> vStopped
7196 2.9) --> OK
7197 */
7198
7199 void
7200 remote_notif_get_pending_events (struct notif_client *nc)
7201 {
7202 struct remote_state *rs = get_remote_state ();
7203
7204 if (rs->notif_state->pending_event[nc->id] != NULL)
7205 {
7206 if (notif_debug)
7207 fprintf_unfiltered (gdb_stdlog,
7208 "notif: process: '%s' ack pending event\n",
7209 nc->name);
7210
7211 /* acknowledge */
7212 nc->ack (nc, rs->buf, rs->notif_state->pending_event[nc->id]);
7213 rs->notif_state->pending_event[nc->id] = NULL;
7214
7215 while (1)
7216 {
7217 getpkt (&rs->buf, &rs->buf_size, 0);
7218 if (strcmp (rs->buf, "OK") == 0)
7219 break;
7220 else
7221 remote_notif_ack (nc, rs->buf);
7222 }
7223 }
7224 else
7225 {
7226 if (notif_debug)
7227 fprintf_unfiltered (gdb_stdlog,
7228 "notif: process: '%s' no pending reply\n",
7229 nc->name);
7230 }
7231 }
7232
7233 /* Called when it is decided that STOP_REPLY holds the info of the
7234 event that is to be returned to the core. This function always
7235 destroys STOP_REPLY. */
7236
7237 static ptid_t
7238 process_stop_reply (struct stop_reply *stop_reply,
7239 struct target_waitstatus *status)
7240 {
7241 ptid_t ptid;
7242
7243 *status = stop_reply->ws;
7244 ptid = stop_reply->ptid;
7245
7246 /* If no thread/process was reported by the stub, assume the current
7247 inferior. */
7248 if (ptid_equal (ptid, null_ptid))
7249 ptid = inferior_ptid;
7250
7251 if (status->kind != TARGET_WAITKIND_EXITED
7252 && status->kind != TARGET_WAITKIND_SIGNALLED
7253 && status->kind != TARGET_WAITKIND_NO_RESUMED)
7254 {
7255 struct private_thread_info *remote_thr;
7256
7257 /* Expedited registers. */
7258 if (stop_reply->regcache)
7259 {
7260 struct regcache *regcache
7261 = get_thread_arch_regcache (ptid, stop_reply->arch);
7262 cached_reg_t *reg;
7263 int ix;
7264
7265 for (ix = 0;
7266 VEC_iterate (cached_reg_t, stop_reply->regcache, ix, reg);
7267 ix++)
7268 {
7269 regcache_raw_supply (regcache, reg->num, reg->data);
7270 xfree (reg->data);
7271 }
7272
7273 VEC_free (cached_reg_t, stop_reply->regcache);
7274 }
7275
7276 remote_notice_new_inferior (ptid, 0);
7277 remote_thr = get_private_info_ptid (ptid);
7278 remote_thr->core = stop_reply->core;
7279 remote_thr->stop_reason = stop_reply->stop_reason;
7280 remote_thr->watch_data_address = stop_reply->watch_data_address;
7281 remote_thr->vcont_resumed = 0;
7282 }
7283
7284 stop_reply_xfree (stop_reply);
7285 return ptid;
7286 }
7287
7288 /* The non-stop mode version of target_wait. */
7289
7290 static ptid_t
7291 remote_wait_ns (ptid_t ptid, struct target_waitstatus *status, int options)
7292 {
7293 struct remote_state *rs = get_remote_state ();
7294 struct stop_reply *stop_reply;
7295 int ret;
7296 int is_notif = 0;
7297
7298 /* If in non-stop mode, get out of getpkt even if a
7299 notification is received. */
7300
7301 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7302 0 /* forever */, &is_notif);
7303 while (1)
7304 {
7305 if (ret != -1 && !is_notif)
7306 switch (rs->buf[0])
7307 {
7308 case 'E': /* Error of some sort. */
7309 /* We're out of sync with the target now. Did it continue
7310 or not? We can't tell which thread it was in non-stop,
7311 so just ignore this. */
7312 warning (_("Remote failure reply: %s"), rs->buf);
7313 break;
7314 case 'O': /* Console output. */
7315 remote_console_output (rs->buf + 1);
7316 break;
7317 default:
7318 warning (_("Invalid remote reply: %s"), rs->buf);
7319 break;
7320 }
7321
7322 /* Acknowledge a pending stop reply that may have arrived in the
7323 mean time. */
7324 if (rs->notif_state->pending_event[notif_client_stop.id] != NULL)
7325 remote_notif_get_pending_events (&notif_client_stop);
7326
7327 /* If indeed we noticed a stop reply, we're done. */
7328 stop_reply = queued_stop_reply (ptid);
7329 if (stop_reply != NULL)
7330 return process_stop_reply (stop_reply, status);
7331
7332 /* Still no event. If we're just polling for an event, then
7333 return to the event loop. */
7334 if (options & TARGET_WNOHANG)
7335 {
7336 status->kind = TARGET_WAITKIND_IGNORE;
7337 return minus_one_ptid;
7338 }
7339
7340 /* Otherwise do a blocking wait. */
7341 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7342 1 /* forever */, &is_notif);
7343 }
7344 }
7345
7346 /* Wait until the remote machine stops, then return, storing status in
7347 STATUS just as `wait' would. */
7348
7349 static ptid_t
7350 remote_wait_as (ptid_t ptid, struct target_waitstatus *status, int options)
7351 {
7352 struct remote_state *rs = get_remote_state ();
7353 ptid_t event_ptid = null_ptid;
7354 char *buf;
7355 struct stop_reply *stop_reply;
7356
7357 again:
7358
7359 status->kind = TARGET_WAITKIND_IGNORE;
7360 status->value.integer = 0;
7361
7362 stop_reply = queued_stop_reply (ptid);
7363 if (stop_reply != NULL)
7364 return process_stop_reply (stop_reply, status);
7365
7366 if (rs->cached_wait_status)
7367 /* Use the cached wait status, but only once. */
7368 rs->cached_wait_status = 0;
7369 else
7370 {
7371 int ret;
7372 int is_notif;
7373 int forever = ((options & TARGET_WNOHANG) == 0
7374 && wait_forever_enabled_p);
7375
7376 if (!rs->waiting_for_stop_reply)
7377 {
7378 status->kind = TARGET_WAITKIND_NO_RESUMED;
7379 return minus_one_ptid;
7380 }
7381
7382 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7383 _never_ wait for ever -> test on target_is_async_p().
7384 However, before we do that we need to ensure that the caller
7385 knows how to take the target into/out of async mode. */
7386 ret = getpkt_or_notif_sane (&rs->buf, &rs->buf_size,
7387 forever, &is_notif);
7388
7389 /* GDB gets a notification. Return to core as this event is
7390 not interesting. */
7391 if (ret != -1 && is_notif)
7392 return minus_one_ptid;
7393
7394 if (ret == -1 && (options & TARGET_WNOHANG) != 0)
7395 return minus_one_ptid;
7396 }
7397
7398 buf = rs->buf;
7399
7400 /* Assume that the target has acknowledged Ctrl-C unless we receive
7401 an 'F' or 'O' packet. */
7402 if (buf[0] != 'F' && buf[0] != 'O')
7403 rs->ctrlc_pending_p = 0;
7404
7405 switch (buf[0])
7406 {
7407 case 'E': /* Error of some sort. */
7408 /* We're out of sync with the target now. Did it continue or
7409 not? Not is more likely, so report a stop. */
7410 rs->waiting_for_stop_reply = 0;
7411
7412 warning (_("Remote failure reply: %s"), buf);
7413 status->kind = TARGET_WAITKIND_STOPPED;
7414 status->value.sig = GDB_SIGNAL_0;
7415 break;
7416 case 'F': /* File-I/O request. */
7417 /* GDB may access the inferior memory while handling the File-I/O
7418 request, but we don't want GDB accessing memory while waiting
7419 for a stop reply. See the comments in putpkt_binary. Set
7420 waiting_for_stop_reply to 0 temporarily. */
7421 rs->waiting_for_stop_reply = 0;
7422 remote_fileio_request (buf, rs->ctrlc_pending_p);
7423 rs->ctrlc_pending_p = 0;
7424 /* GDB handled the File-I/O request, and the target is running
7425 again. Keep waiting for events. */
7426 rs->waiting_for_stop_reply = 1;
7427 break;
7428 case 'N': case 'T': case 'S': case 'X': case 'W':
7429 {
7430 struct stop_reply *stop_reply;
7431
7432 /* There is a stop reply to handle. */
7433 rs->waiting_for_stop_reply = 0;
7434
7435 stop_reply
7436 = (struct stop_reply *) remote_notif_parse (&notif_client_stop,
7437 rs->buf);
7438
7439 event_ptid = process_stop_reply (stop_reply, status);
7440 break;
7441 }
7442 case 'O': /* Console output. */
7443 remote_console_output (buf + 1);
7444 break;
7445 case '\0':
7446 if (rs->last_sent_signal != GDB_SIGNAL_0)
7447 {
7448 /* Zero length reply means that we tried 'S' or 'C' and the
7449 remote system doesn't support it. */
7450 target_terminal::ours_for_output ();
7451 printf_filtered
7452 ("Can't send signals to this remote system. %s not sent.\n",
7453 gdb_signal_to_name (rs->last_sent_signal));
7454 rs->last_sent_signal = GDB_SIGNAL_0;
7455 target_terminal::inferior ();
7456
7457 strcpy (buf, rs->last_sent_step ? "s" : "c");
7458 putpkt (buf);
7459 break;
7460 }
7461 /* else fallthrough */
7462 default:
7463 warning (_("Invalid remote reply: %s"), buf);
7464 break;
7465 }
7466
7467 if (status->kind == TARGET_WAITKIND_NO_RESUMED)
7468 return minus_one_ptid;
7469 else if (status->kind == TARGET_WAITKIND_IGNORE)
7470 {
7471 /* Nothing interesting happened. If we're doing a non-blocking
7472 poll, we're done. Otherwise, go back to waiting. */
7473 if (options & TARGET_WNOHANG)
7474 return minus_one_ptid;
7475 else
7476 goto again;
7477 }
7478 else if (status->kind != TARGET_WAITKIND_EXITED
7479 && status->kind != TARGET_WAITKIND_SIGNALLED)
7480 {
7481 if (!ptid_equal (event_ptid, null_ptid))
7482 record_currthread (rs, event_ptid);
7483 else
7484 event_ptid = inferior_ptid;
7485 }
7486 else
7487 /* A process exit. Invalidate our notion of current thread. */
7488 record_currthread (rs, minus_one_ptid);
7489
7490 return event_ptid;
7491 }
7492
7493 /* Wait until the remote machine stops, then return, storing status in
7494 STATUS just as `wait' would. */
7495
7496 static ptid_t
7497 remote_wait (struct target_ops *ops,
7498 ptid_t ptid, struct target_waitstatus *status, int options)
7499 {
7500 ptid_t event_ptid;
7501
7502 if (target_is_non_stop_p ())
7503 event_ptid = remote_wait_ns (ptid, status, options);
7504 else
7505 event_ptid = remote_wait_as (ptid, status, options);
7506
7507 if (target_is_async_p ())
7508 {
7509 /* If there are are events left in the queue tell the event loop
7510 to return here. */
7511 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
7512 mark_async_event_handler (remote_async_inferior_event_token);
7513 }
7514
7515 return event_ptid;
7516 }
7517
7518 /* Fetch a single register using a 'p' packet. */
7519
7520 static int
7521 fetch_register_using_p (struct regcache *regcache, struct packet_reg *reg)
7522 {
7523 struct gdbarch *gdbarch = regcache->arch ();
7524 struct remote_state *rs = get_remote_state ();
7525 char *buf, *p;
7526 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
7527 int i;
7528
7529 if (packet_support (PACKET_p) == PACKET_DISABLE)
7530 return 0;
7531
7532 if (reg->pnum == -1)
7533 return 0;
7534
7535 p = rs->buf;
7536 *p++ = 'p';
7537 p += hexnumstr (p, reg->pnum);
7538 *p++ = '\0';
7539 putpkt (rs->buf);
7540 getpkt (&rs->buf, &rs->buf_size, 0);
7541
7542 buf = rs->buf;
7543
7544 switch (packet_ok (buf, &remote_protocol_packets[PACKET_p]))
7545 {
7546 case PACKET_OK:
7547 break;
7548 case PACKET_UNKNOWN:
7549 return 0;
7550 case PACKET_ERROR:
7551 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7552 gdbarch_register_name (regcache->arch (),
7553 reg->regnum),
7554 buf);
7555 }
7556
7557 /* If this register is unfetchable, tell the regcache. */
7558 if (buf[0] == 'x')
7559 {
7560 regcache_raw_supply (regcache, reg->regnum, NULL);
7561 return 1;
7562 }
7563
7564 /* Otherwise, parse and supply the value. */
7565 p = buf;
7566 i = 0;
7567 while (p[0] != 0)
7568 {
7569 if (p[1] == 0)
7570 error (_("fetch_register_using_p: early buf termination"));
7571
7572 regp[i++] = fromhex (p[0]) * 16 + fromhex (p[1]);
7573 p += 2;
7574 }
7575 regcache_raw_supply (regcache, reg->regnum, regp);
7576 return 1;
7577 }
7578
7579 /* Fetch the registers included in the target's 'g' packet. */
7580
7581 static int
7582 send_g_packet (void)
7583 {
7584 struct remote_state *rs = get_remote_state ();
7585 int buf_len;
7586
7587 xsnprintf (rs->buf, get_remote_packet_size (), "g");
7588 remote_send (&rs->buf, &rs->buf_size);
7589
7590 /* We can get out of synch in various cases. If the first character
7591 in the buffer is not a hex character, assume that has happened
7592 and try to fetch another packet to read. */
7593 while ((rs->buf[0] < '0' || rs->buf[0] > '9')
7594 && (rs->buf[0] < 'A' || rs->buf[0] > 'F')
7595 && (rs->buf[0] < 'a' || rs->buf[0] > 'f')
7596 && rs->buf[0] != 'x') /* New: unavailable register value. */
7597 {
7598 if (remote_debug)
7599 fprintf_unfiltered (gdb_stdlog,
7600 "Bad register packet; fetching a new packet\n");
7601 getpkt (&rs->buf, &rs->buf_size, 0);
7602 }
7603
7604 buf_len = strlen (rs->buf);
7605
7606 /* Sanity check the received packet. */
7607 if (buf_len % 2 != 0)
7608 error (_("Remote 'g' packet reply is of odd length: %s"), rs->buf);
7609
7610 return buf_len / 2;
7611 }
7612
7613 static void
7614 process_g_packet (struct regcache *regcache)
7615 {
7616 struct gdbarch *gdbarch = regcache->arch ();
7617 struct remote_state *rs = get_remote_state ();
7618 remote_arch_state *rsa = get_remote_arch_state (gdbarch);
7619 int i, buf_len;
7620 char *p;
7621 char *regs;
7622
7623 buf_len = strlen (rs->buf);
7624
7625 /* Further sanity checks, with knowledge of the architecture. */
7626 if (buf_len > 2 * rsa->sizeof_g_packet)
7627 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7628 "bytes): %s"), rsa->sizeof_g_packet, buf_len / 2, rs->buf);
7629
7630 /* Save the size of the packet sent to us by the target. It is used
7631 as a heuristic when determining the max size of packets that the
7632 target can safely receive. */
7633 if (rsa->actual_register_packet_size == 0)
7634 rsa->actual_register_packet_size = buf_len;
7635
7636 /* If this is smaller than we guessed the 'g' packet would be,
7637 update our records. A 'g' reply that doesn't include a register's
7638 value implies either that the register is not available, or that
7639 the 'p' packet must be used. */
7640 if (buf_len < 2 * rsa->sizeof_g_packet)
7641 {
7642 long sizeof_g_packet = buf_len / 2;
7643
7644 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
7645 {
7646 long offset = rsa->regs[i].offset;
7647 long reg_size = register_size (gdbarch, i);
7648
7649 if (rsa->regs[i].pnum == -1)
7650 continue;
7651
7652 if (offset >= sizeof_g_packet)
7653 rsa->regs[i].in_g_packet = 0;
7654 else if (offset + reg_size > sizeof_g_packet)
7655 error (_("Truncated register %d in remote 'g' packet"), i);
7656 else
7657 rsa->regs[i].in_g_packet = 1;
7658 }
7659
7660 /* Looks valid enough, we can assume this is the correct length
7661 for a 'g' packet. It's important not to adjust
7662 rsa->sizeof_g_packet if we have truncated registers otherwise
7663 this "if" won't be run the next time the method is called
7664 with a packet of the same size and one of the internal errors
7665 below will trigger instead. */
7666 rsa->sizeof_g_packet = sizeof_g_packet;
7667 }
7668
7669 regs = (char *) alloca (rsa->sizeof_g_packet);
7670
7671 /* Unimplemented registers read as all bits zero. */
7672 memset (regs, 0, rsa->sizeof_g_packet);
7673
7674 /* Reply describes registers byte by byte, each byte encoded as two
7675 hex characters. Suck them all up, then supply them to the
7676 register cacheing/storage mechanism. */
7677
7678 p = rs->buf;
7679 for (i = 0; i < rsa->sizeof_g_packet; i++)
7680 {
7681 if (p[0] == 0 || p[1] == 0)
7682 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7683 internal_error (__FILE__, __LINE__,
7684 _("unexpected end of 'g' packet reply"));
7685
7686 if (p[0] == 'x' && p[1] == 'x')
7687 regs[i] = 0; /* 'x' */
7688 else
7689 regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
7690 p += 2;
7691 }
7692
7693 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
7694 {
7695 struct packet_reg *r = &rsa->regs[i];
7696 long reg_size = register_size (gdbarch, i);
7697
7698 if (r->in_g_packet)
7699 {
7700 if ((r->offset + reg_size) * 2 > strlen (rs->buf))
7701 /* This shouldn't happen - we adjusted in_g_packet above. */
7702 internal_error (__FILE__, __LINE__,
7703 _("unexpected end of 'g' packet reply"));
7704 else if (rs->buf[r->offset * 2] == 'x')
7705 {
7706 gdb_assert (r->offset * 2 < strlen (rs->buf));
7707 /* The register isn't available, mark it as such (at
7708 the same time setting the value to zero). */
7709 regcache_raw_supply (regcache, r->regnum, NULL);
7710 }
7711 else
7712 regcache_raw_supply (regcache, r->regnum,
7713 regs + r->offset);
7714 }
7715 }
7716 }
7717
7718 static void
7719 fetch_registers_using_g (struct regcache *regcache)
7720 {
7721 send_g_packet ();
7722 process_g_packet (regcache);
7723 }
7724
7725 /* Make the remote selected traceframe match GDB's selected
7726 traceframe. */
7727
7728 static void
7729 set_remote_traceframe (void)
7730 {
7731 int newnum;
7732 struct remote_state *rs = get_remote_state ();
7733
7734 if (rs->remote_traceframe_number == get_traceframe_number ())
7735 return;
7736
7737 /* Avoid recursion, remote_trace_find calls us again. */
7738 rs->remote_traceframe_number = get_traceframe_number ();
7739
7740 newnum = target_trace_find (tfind_number,
7741 get_traceframe_number (), 0, 0, NULL);
7742
7743 /* Should not happen. If it does, all bets are off. */
7744 if (newnum != get_traceframe_number ())
7745 warning (_("could not set remote traceframe"));
7746 }
7747
7748 static void
7749 remote_fetch_registers (struct target_ops *ops,
7750 struct regcache *regcache, int regnum)
7751 {
7752 struct gdbarch *gdbarch = regcache->arch ();
7753 remote_arch_state *rsa = get_remote_arch_state (gdbarch);
7754 int i;
7755
7756 set_remote_traceframe ();
7757 set_general_thread (regcache_get_ptid (regcache));
7758
7759 if (regnum >= 0)
7760 {
7761 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
7762
7763 gdb_assert (reg != NULL);
7764
7765 /* If this register might be in the 'g' packet, try that first -
7766 we are likely to read more than one register. If this is the
7767 first 'g' packet, we might be overly optimistic about its
7768 contents, so fall back to 'p'. */
7769 if (reg->in_g_packet)
7770 {
7771 fetch_registers_using_g (regcache);
7772 if (reg->in_g_packet)
7773 return;
7774 }
7775
7776 if (fetch_register_using_p (regcache, reg))
7777 return;
7778
7779 /* This register is not available. */
7780 regcache_raw_supply (regcache, reg->regnum, NULL);
7781
7782 return;
7783 }
7784
7785 fetch_registers_using_g (regcache);
7786
7787 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
7788 if (!rsa->regs[i].in_g_packet)
7789 if (!fetch_register_using_p (regcache, &rsa->regs[i]))
7790 {
7791 /* This register is not available. */
7792 regcache_raw_supply (regcache, i, NULL);
7793 }
7794 }
7795
7796 /* Prepare to store registers. Since we may send them all (using a
7797 'G' request), we have to read out the ones we don't want to change
7798 first. */
7799
7800 static void
7801 remote_prepare_to_store (struct target_ops *self, struct regcache *regcache)
7802 {
7803 remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
7804 int i;
7805
7806 /* Make sure the entire registers array is valid. */
7807 switch (packet_support (PACKET_P))
7808 {
7809 case PACKET_DISABLE:
7810 case PACKET_SUPPORT_UNKNOWN:
7811 /* Make sure all the necessary registers are cached. */
7812 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
7813 if (rsa->regs[i].in_g_packet)
7814 regcache_raw_update (regcache, rsa->regs[i].regnum);
7815 break;
7816 case PACKET_ENABLE:
7817 break;
7818 }
7819 }
7820
7821 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7822 packet was not recognized. */
7823
7824 static int
7825 store_register_using_P (const struct regcache *regcache,
7826 struct packet_reg *reg)
7827 {
7828 struct gdbarch *gdbarch = regcache->arch ();
7829 struct remote_state *rs = get_remote_state ();
7830 /* Try storing a single register. */
7831 char *buf = rs->buf;
7832 gdb_byte *regp = (gdb_byte *) alloca (register_size (gdbarch, reg->regnum));
7833 char *p;
7834
7835 if (packet_support (PACKET_P) == PACKET_DISABLE)
7836 return 0;
7837
7838 if (reg->pnum == -1)
7839 return 0;
7840
7841 xsnprintf (buf, get_remote_packet_size (), "P%s=", phex_nz (reg->pnum, 0));
7842 p = buf + strlen (buf);
7843 regcache_raw_collect (regcache, reg->regnum, regp);
7844 bin2hex (regp, p, register_size (gdbarch, reg->regnum));
7845 putpkt (rs->buf);
7846 getpkt (&rs->buf, &rs->buf_size, 0);
7847
7848 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_P]))
7849 {
7850 case PACKET_OK:
7851 return 1;
7852 case PACKET_ERROR:
7853 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7854 gdbarch_register_name (gdbarch, reg->regnum), rs->buf);
7855 case PACKET_UNKNOWN:
7856 return 0;
7857 default:
7858 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
7859 }
7860 }
7861
7862 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7863 contents of the register cache buffer. FIXME: ignores errors. */
7864
7865 static void
7866 store_registers_using_G (const struct regcache *regcache)
7867 {
7868 struct remote_state *rs = get_remote_state ();
7869 remote_arch_state *rsa = get_remote_arch_state (regcache->arch ());
7870 gdb_byte *regs;
7871 char *p;
7872
7873 /* Extract all the registers in the regcache copying them into a
7874 local buffer. */
7875 {
7876 int i;
7877
7878 regs = (gdb_byte *) alloca (rsa->sizeof_g_packet);
7879 memset (regs, 0, rsa->sizeof_g_packet);
7880 for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++)
7881 {
7882 struct packet_reg *r = &rsa->regs[i];
7883
7884 if (r->in_g_packet)
7885 regcache_raw_collect (regcache, r->regnum, regs + r->offset);
7886 }
7887 }
7888
7889 /* Command describes registers byte by byte,
7890 each byte encoded as two hex characters. */
7891 p = rs->buf;
7892 *p++ = 'G';
7893 bin2hex (regs, p, rsa->sizeof_g_packet);
7894 putpkt (rs->buf);
7895 getpkt (&rs->buf, &rs->buf_size, 0);
7896 if (packet_check_result (rs->buf) == PACKET_ERROR)
7897 error (_("Could not write registers; remote failure reply '%s'"),
7898 rs->buf);
7899 }
7900
7901 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7902 of the register cache buffer. FIXME: ignores errors. */
7903
7904 static void
7905 remote_store_registers (struct target_ops *ops,
7906 struct regcache *regcache, int regnum)
7907 {
7908 struct gdbarch *gdbarch = regcache->arch ();
7909 remote_arch_state *rsa = get_remote_arch_state (gdbarch);
7910 int i;
7911
7912 set_remote_traceframe ();
7913 set_general_thread (regcache_get_ptid (regcache));
7914
7915 if (regnum >= 0)
7916 {
7917 packet_reg *reg = packet_reg_from_regnum (gdbarch, rsa, regnum);
7918
7919 gdb_assert (reg != NULL);
7920
7921 /* Always prefer to store registers using the 'P' packet if
7922 possible; we often change only a small number of registers.
7923 Sometimes we change a larger number; we'd need help from a
7924 higher layer to know to use 'G'. */
7925 if (store_register_using_P (regcache, reg))
7926 return;
7927
7928 /* For now, don't complain if we have no way to write the
7929 register. GDB loses track of unavailable registers too
7930 easily. Some day, this may be an error. We don't have
7931 any way to read the register, either... */
7932 if (!reg->in_g_packet)
7933 return;
7934
7935 store_registers_using_G (regcache);
7936 return;
7937 }
7938
7939 store_registers_using_G (regcache);
7940
7941 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
7942 if (!rsa->regs[i].in_g_packet)
7943 if (!store_register_using_P (regcache, &rsa->regs[i]))
7944 /* See above for why we do not issue an error here. */
7945 continue;
7946 }
7947 \f
7948
7949 /* Return the number of hex digits in num. */
7950
7951 static int
7952 hexnumlen (ULONGEST num)
7953 {
7954 int i;
7955
7956 for (i = 0; num != 0; i++)
7957 num >>= 4;
7958
7959 return std::max (i, 1);
7960 }
7961
7962 /* Set BUF to the minimum number of hex digits representing NUM. */
7963
7964 static int
7965 hexnumstr (char *buf, ULONGEST num)
7966 {
7967 int len = hexnumlen (num);
7968
7969 return hexnumnstr (buf, num, len);
7970 }
7971
7972
7973 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7974
7975 static int
7976 hexnumnstr (char *buf, ULONGEST num, int width)
7977 {
7978 int i;
7979
7980 buf[width] = '\0';
7981
7982 for (i = width - 1; i >= 0; i--)
7983 {
7984 buf[i] = "0123456789abcdef"[(num & 0xf)];
7985 num >>= 4;
7986 }
7987
7988 return width;
7989 }
7990
7991 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7992
7993 static CORE_ADDR
7994 remote_address_masked (CORE_ADDR addr)
7995 {
7996 unsigned int address_size = remote_address_size;
7997
7998 /* If "remoteaddresssize" was not set, default to target address size. */
7999 if (!address_size)
8000 address_size = gdbarch_addr_bit (target_gdbarch ());
8001
8002 if (address_size > 0
8003 && address_size < (sizeof (ULONGEST) * 8))
8004 {
8005 /* Only create a mask when that mask can safely be constructed
8006 in a ULONGEST variable. */
8007 ULONGEST mask = 1;
8008
8009 mask = (mask << address_size) - 1;
8010 addr &= mask;
8011 }
8012 return addr;
8013 }
8014
8015 /* Determine whether the remote target supports binary downloading.
8016 This is accomplished by sending a no-op memory write of zero length
8017 to the target at the specified address. It does not suffice to send
8018 the whole packet, since many stubs strip the eighth bit and
8019 subsequently compute a wrong checksum, which causes real havoc with
8020 remote_write_bytes.
8021
8022 NOTE: This can still lose if the serial line is not eight-bit
8023 clean. In cases like this, the user should clear "remote
8024 X-packet". */
8025
8026 static void
8027 check_binary_download (CORE_ADDR addr)
8028 {
8029 struct remote_state *rs = get_remote_state ();
8030
8031 switch (packet_support (PACKET_X))
8032 {
8033 case PACKET_DISABLE:
8034 break;
8035 case PACKET_ENABLE:
8036 break;
8037 case PACKET_SUPPORT_UNKNOWN:
8038 {
8039 char *p;
8040
8041 p = rs->buf;
8042 *p++ = 'X';
8043 p += hexnumstr (p, (ULONGEST) addr);
8044 *p++ = ',';
8045 p += hexnumstr (p, (ULONGEST) 0);
8046 *p++ = ':';
8047 *p = '\0';
8048
8049 putpkt_binary (rs->buf, (int) (p - rs->buf));
8050 getpkt (&rs->buf, &rs->buf_size, 0);
8051
8052 if (rs->buf[0] == '\0')
8053 {
8054 if (remote_debug)
8055 fprintf_unfiltered (gdb_stdlog,
8056 "binary downloading NOT "
8057 "supported by target\n");
8058 remote_protocol_packets[PACKET_X].support = PACKET_DISABLE;
8059 }
8060 else
8061 {
8062 if (remote_debug)
8063 fprintf_unfiltered (gdb_stdlog,
8064 "binary downloading supported by target\n");
8065 remote_protocol_packets[PACKET_X].support = PACKET_ENABLE;
8066 }
8067 break;
8068 }
8069 }
8070 }
8071
8072 /* Helper function to resize the payload in order to try to get a good
8073 alignment. We try to write an amount of data such that the next write will
8074 start on an address aligned on REMOTE_ALIGN_WRITES. */
8075
8076 static int
8077 align_for_efficient_write (int todo, CORE_ADDR memaddr)
8078 {
8079 return ((memaddr + todo) & ~(REMOTE_ALIGN_WRITES - 1)) - memaddr;
8080 }
8081
8082 /* Write memory data directly to the remote machine.
8083 This does not inform the data cache; the data cache uses this.
8084 HEADER is the starting part of the packet.
8085 MEMADDR is the address in the remote memory space.
8086 MYADDR is the address of the buffer in our space.
8087 LEN_UNITS is the number of addressable units to write.
8088 UNIT_SIZE is the length in bytes of an addressable unit.
8089 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8090 should send data as binary ('X'), or hex-encoded ('M').
8091
8092 The function creates packet of the form
8093 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8094
8095 where encoding of <DATA> is terminated by PACKET_FORMAT.
8096
8097 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8098 are omitted.
8099
8100 Return the transferred status, error or OK (an
8101 'enum target_xfer_status' value). Save the number of addressable units
8102 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8103
8104 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8105 exchange between gdb and the stub could look like (?? in place of the
8106 checksum):
8107
8108 -> $m1000,4#??
8109 <- aaaabbbbccccdddd
8110
8111 -> $M1000,3:eeeeffffeeee#??
8112 <- OK
8113
8114 -> $m1000,4#??
8115 <- eeeeffffeeeedddd */
8116
8117 static enum target_xfer_status
8118 remote_write_bytes_aux (const char *header, CORE_ADDR memaddr,
8119 const gdb_byte *myaddr, ULONGEST len_units,
8120 int unit_size, ULONGEST *xfered_len_units,
8121 char packet_format, int use_length)
8122 {
8123 struct remote_state *rs = get_remote_state ();
8124 char *p;
8125 char *plen = NULL;
8126 int plenlen = 0;
8127 int todo_units;
8128 int units_written;
8129 int payload_capacity_bytes;
8130 int payload_length_bytes;
8131
8132 if (packet_format != 'X' && packet_format != 'M')
8133 internal_error (__FILE__, __LINE__,
8134 _("remote_write_bytes_aux: bad packet format"));
8135
8136 if (len_units == 0)
8137 return TARGET_XFER_EOF;
8138
8139 payload_capacity_bytes = get_memory_write_packet_size ();
8140
8141 /* The packet buffer will be large enough for the payload;
8142 get_memory_packet_size ensures this. */
8143 rs->buf[0] = '\0';
8144
8145 /* Compute the size of the actual payload by subtracting out the
8146 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8147
8148 payload_capacity_bytes -= strlen ("$,:#NN");
8149 if (!use_length)
8150 /* The comma won't be used. */
8151 payload_capacity_bytes += 1;
8152 payload_capacity_bytes -= strlen (header);
8153 payload_capacity_bytes -= hexnumlen (memaddr);
8154
8155 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8156
8157 strcat (rs->buf, header);
8158 p = rs->buf + strlen (header);
8159
8160 /* Compute a best guess of the number of bytes actually transfered. */
8161 if (packet_format == 'X')
8162 {
8163 /* Best guess at number of bytes that will fit. */
8164 todo_units = std::min (len_units,
8165 (ULONGEST) payload_capacity_bytes / unit_size);
8166 if (use_length)
8167 payload_capacity_bytes -= hexnumlen (todo_units);
8168 todo_units = std::min (todo_units, payload_capacity_bytes / unit_size);
8169 }
8170 else
8171 {
8172 /* Number of bytes that will fit. */
8173 todo_units
8174 = std::min (len_units,
8175 (ULONGEST) (payload_capacity_bytes / unit_size) / 2);
8176 if (use_length)
8177 payload_capacity_bytes -= hexnumlen (todo_units);
8178 todo_units = std::min (todo_units,
8179 (payload_capacity_bytes / unit_size) / 2);
8180 }
8181
8182 if (todo_units <= 0)
8183 internal_error (__FILE__, __LINE__,
8184 _("minimum packet size too small to write data"));
8185
8186 /* If we already need another packet, then try to align the end
8187 of this packet to a useful boundary. */
8188 if (todo_units > 2 * REMOTE_ALIGN_WRITES && todo_units < len_units)
8189 todo_units = align_for_efficient_write (todo_units, memaddr);
8190
8191 /* Append "<memaddr>". */
8192 memaddr = remote_address_masked (memaddr);
8193 p += hexnumstr (p, (ULONGEST) memaddr);
8194
8195 if (use_length)
8196 {
8197 /* Append ",". */
8198 *p++ = ',';
8199
8200 /* Append the length and retain its location and size. It may need to be
8201 adjusted once the packet body has been created. */
8202 plen = p;
8203 plenlen = hexnumstr (p, (ULONGEST) todo_units);
8204 p += plenlen;
8205 }
8206
8207 /* Append ":". */
8208 *p++ = ':';
8209 *p = '\0';
8210
8211 /* Append the packet body. */
8212 if (packet_format == 'X')
8213 {
8214 /* Binary mode. Send target system values byte by byte, in
8215 increasing byte addresses. Only escape certain critical
8216 characters. */
8217 payload_length_bytes =
8218 remote_escape_output (myaddr, todo_units, unit_size, (gdb_byte *) p,
8219 &units_written, payload_capacity_bytes);
8220
8221 /* If not all TODO units fit, then we'll need another packet. Make
8222 a second try to keep the end of the packet aligned. Don't do
8223 this if the packet is tiny. */
8224 if (units_written < todo_units && units_written > 2 * REMOTE_ALIGN_WRITES)
8225 {
8226 int new_todo_units;
8227
8228 new_todo_units = align_for_efficient_write (units_written, memaddr);
8229
8230 if (new_todo_units != units_written)
8231 payload_length_bytes =
8232 remote_escape_output (myaddr, new_todo_units, unit_size,
8233 (gdb_byte *) p, &units_written,
8234 payload_capacity_bytes);
8235 }
8236
8237 p += payload_length_bytes;
8238 if (use_length && units_written < todo_units)
8239 {
8240 /* Escape chars have filled up the buffer prematurely,
8241 and we have actually sent fewer units than planned.
8242 Fix-up the length field of the packet. Use the same
8243 number of characters as before. */
8244 plen += hexnumnstr (plen, (ULONGEST) units_written,
8245 plenlen);
8246 *plen = ':'; /* overwrite \0 from hexnumnstr() */
8247 }
8248 }
8249 else
8250 {
8251 /* Normal mode: Send target system values byte by byte, in
8252 increasing byte addresses. Each byte is encoded as a two hex
8253 value. */
8254 p += 2 * bin2hex (myaddr, p, todo_units * unit_size);
8255 units_written = todo_units;
8256 }
8257
8258 putpkt_binary (rs->buf, (int) (p - rs->buf));
8259 getpkt (&rs->buf, &rs->buf_size, 0);
8260
8261 if (rs->buf[0] == 'E')
8262 return TARGET_XFER_E_IO;
8263
8264 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8265 send fewer units than we'd planned. */
8266 *xfered_len_units = (ULONGEST) units_written;
8267 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8268 }
8269
8270 /* Write memory data directly to the remote machine.
8271 This does not inform the data cache; the data cache uses this.
8272 MEMADDR is the address in the remote memory space.
8273 MYADDR is the address of the buffer in our space.
8274 LEN is the number of bytes.
8275
8276 Return the transferred status, error or OK (an
8277 'enum target_xfer_status' value). Save the number of bytes
8278 transferred in *XFERED_LEN. Only transfer a single packet. */
8279
8280 static enum target_xfer_status
8281 remote_write_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, ULONGEST len,
8282 int unit_size, ULONGEST *xfered_len)
8283 {
8284 const char *packet_format = NULL;
8285
8286 /* Check whether the target supports binary download. */
8287 check_binary_download (memaddr);
8288
8289 switch (packet_support (PACKET_X))
8290 {
8291 case PACKET_ENABLE:
8292 packet_format = "X";
8293 break;
8294 case PACKET_DISABLE:
8295 packet_format = "M";
8296 break;
8297 case PACKET_SUPPORT_UNKNOWN:
8298 internal_error (__FILE__, __LINE__,
8299 _("remote_write_bytes: bad internal state"));
8300 default:
8301 internal_error (__FILE__, __LINE__, _("bad switch"));
8302 }
8303
8304 return remote_write_bytes_aux (packet_format,
8305 memaddr, myaddr, len, unit_size, xfered_len,
8306 packet_format[0], 1);
8307 }
8308
8309 /* Read memory data directly from the remote machine.
8310 This does not use the data cache; the data cache uses this.
8311 MEMADDR is the address in the remote memory space.
8312 MYADDR is the address of the buffer in our space.
8313 LEN_UNITS is the number of addressable memory units to read..
8314 UNIT_SIZE is the length in bytes of an addressable unit.
8315
8316 Return the transferred status, error or OK (an
8317 'enum target_xfer_status' value). Save the number of bytes
8318 transferred in *XFERED_LEN_UNITS.
8319
8320 See the comment of remote_write_bytes_aux for an example of
8321 memory read/write exchange between gdb and the stub. */
8322
8323 static enum target_xfer_status
8324 remote_read_bytes_1 (CORE_ADDR memaddr, gdb_byte *myaddr, ULONGEST len_units,
8325 int unit_size, ULONGEST *xfered_len_units)
8326 {
8327 struct remote_state *rs = get_remote_state ();
8328 int buf_size_bytes; /* Max size of packet output buffer. */
8329 char *p;
8330 int todo_units;
8331 int decoded_bytes;
8332
8333 buf_size_bytes = get_memory_read_packet_size ();
8334 /* The packet buffer will be large enough for the payload;
8335 get_memory_packet_size ensures this. */
8336
8337 /* Number of units that will fit. */
8338 todo_units = std::min (len_units,
8339 (ULONGEST) (buf_size_bytes / unit_size) / 2);
8340
8341 /* Construct "m"<memaddr>","<len>". */
8342 memaddr = remote_address_masked (memaddr);
8343 p = rs->buf;
8344 *p++ = 'm';
8345 p += hexnumstr (p, (ULONGEST) memaddr);
8346 *p++ = ',';
8347 p += hexnumstr (p, (ULONGEST) todo_units);
8348 *p = '\0';
8349 putpkt (rs->buf);
8350 getpkt (&rs->buf, &rs->buf_size, 0);
8351 if (rs->buf[0] == 'E'
8352 && isxdigit (rs->buf[1]) && isxdigit (rs->buf[2])
8353 && rs->buf[3] == '\0')
8354 return TARGET_XFER_E_IO;
8355 /* Reply describes memory byte by byte, each byte encoded as two hex
8356 characters. */
8357 p = rs->buf;
8358 decoded_bytes = hex2bin (p, myaddr, todo_units * unit_size);
8359 /* Return what we have. Let higher layers handle partial reads. */
8360 *xfered_len_units = (ULONGEST) (decoded_bytes / unit_size);
8361 return (*xfered_len_units != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
8362 }
8363
8364 /* Using the set of read-only target sections of remote, read live
8365 read-only memory.
8366
8367 For interface/parameters/return description see target.h,
8368 to_xfer_partial. */
8369
8370 static enum target_xfer_status
8371 remote_xfer_live_readonly_partial (struct target_ops *ops, gdb_byte *readbuf,
8372 ULONGEST memaddr, ULONGEST len,
8373 int unit_size, ULONGEST *xfered_len)
8374 {
8375 struct target_section *secp;
8376 struct target_section_table *table;
8377
8378 secp = target_section_by_addr (ops, memaddr);
8379 if (secp != NULL
8380 && (bfd_get_section_flags (secp->the_bfd_section->owner,
8381 secp->the_bfd_section)
8382 & SEC_READONLY))
8383 {
8384 struct target_section *p;
8385 ULONGEST memend = memaddr + len;
8386
8387 table = target_get_section_table (ops);
8388
8389 for (p = table->sections; p < table->sections_end; p++)
8390 {
8391 if (memaddr >= p->addr)
8392 {
8393 if (memend <= p->endaddr)
8394 {
8395 /* Entire transfer is within this section. */
8396 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8397 xfered_len);
8398 }
8399 else if (memaddr >= p->endaddr)
8400 {
8401 /* This section ends before the transfer starts. */
8402 continue;
8403 }
8404 else
8405 {
8406 /* This section overlaps the transfer. Just do half. */
8407 len = p->endaddr - memaddr;
8408 return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
8409 xfered_len);
8410 }
8411 }
8412 }
8413 }
8414
8415 return TARGET_XFER_EOF;
8416 }
8417
8418 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8419 first if the requested memory is unavailable in traceframe.
8420 Otherwise, fall back to remote_read_bytes_1. */
8421
8422 static enum target_xfer_status
8423 remote_read_bytes (struct target_ops *ops, CORE_ADDR memaddr,
8424 gdb_byte *myaddr, ULONGEST len, int unit_size,
8425 ULONGEST *xfered_len)
8426 {
8427 if (len == 0)
8428 return TARGET_XFER_EOF;
8429
8430 if (get_traceframe_number () != -1)
8431 {
8432 std::vector<mem_range> available;
8433
8434 /* If we fail to get the set of available memory, then the
8435 target does not support querying traceframe info, and so we
8436 attempt reading from the traceframe anyway (assuming the
8437 target implements the old QTro packet then). */
8438 if (traceframe_available_memory (&available, memaddr, len))
8439 {
8440 if (available.empty () || available[0].start != memaddr)
8441 {
8442 enum target_xfer_status res;
8443
8444 /* Don't read into the traceframe's available
8445 memory. */
8446 if (!available.empty ())
8447 {
8448 LONGEST oldlen = len;
8449
8450 len = available[0].start - memaddr;
8451 gdb_assert (len <= oldlen);
8452 }
8453
8454 /* This goes through the topmost target again. */
8455 res = remote_xfer_live_readonly_partial (ops, myaddr, memaddr,
8456 len, unit_size, xfered_len);
8457 if (res == TARGET_XFER_OK)
8458 return TARGET_XFER_OK;
8459 else
8460 {
8461 /* No use trying further, we know some memory starting
8462 at MEMADDR isn't available. */
8463 *xfered_len = len;
8464 return (*xfered_len != 0) ?
8465 TARGET_XFER_UNAVAILABLE : TARGET_XFER_EOF;
8466 }
8467 }
8468
8469 /* Don't try to read more than how much is available, in
8470 case the target implements the deprecated QTro packet to
8471 cater for older GDBs (the target's knowledge of read-only
8472 sections may be outdated by now). */
8473 len = available[0].length;
8474 }
8475 }
8476
8477 return remote_read_bytes_1 (memaddr, myaddr, len, unit_size, xfered_len);
8478 }
8479
8480 \f
8481
8482 /* Sends a packet with content determined by the printf format string
8483 FORMAT and the remaining arguments, then gets the reply. Returns
8484 whether the packet was a success, a failure, or unknown. */
8485
8486 static enum packet_result remote_send_printf (const char *format, ...)
8487 ATTRIBUTE_PRINTF (1, 2);
8488
8489 static enum packet_result
8490 remote_send_printf (const char *format, ...)
8491 {
8492 struct remote_state *rs = get_remote_state ();
8493 int max_size = get_remote_packet_size ();
8494 va_list ap;
8495
8496 va_start (ap, format);
8497
8498 rs->buf[0] = '\0';
8499 if (vsnprintf (rs->buf, max_size, format, ap) >= max_size)
8500 internal_error (__FILE__, __LINE__, _("Too long remote packet."));
8501
8502 if (putpkt (rs->buf) < 0)
8503 error (_("Communication problem with target."));
8504
8505 rs->buf[0] = '\0';
8506 getpkt (&rs->buf, &rs->buf_size, 0);
8507
8508 return packet_check_result (rs->buf);
8509 }
8510
8511 /* Flash writing can take quite some time. We'll set
8512 effectively infinite timeout for flash operations.
8513 In future, we'll need to decide on a better approach. */
8514 static const int remote_flash_timeout = 1000;
8515
8516 static void
8517 remote_flash_erase (struct target_ops *ops,
8518 ULONGEST address, LONGEST length)
8519 {
8520 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
8521 enum packet_result ret;
8522 scoped_restore restore_timeout
8523 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8524
8525 ret = remote_send_printf ("vFlashErase:%s,%s",
8526 phex (address, addr_size),
8527 phex (length, 4));
8528 switch (ret)
8529 {
8530 case PACKET_UNKNOWN:
8531 error (_("Remote target does not support flash erase"));
8532 case PACKET_ERROR:
8533 error (_("Error erasing flash with vFlashErase packet"));
8534 default:
8535 break;
8536 }
8537 }
8538
8539 static enum target_xfer_status
8540 remote_flash_write (struct target_ops *ops, ULONGEST address,
8541 ULONGEST length, ULONGEST *xfered_len,
8542 const gdb_byte *data)
8543 {
8544 scoped_restore restore_timeout
8545 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8546 return remote_write_bytes_aux ("vFlashWrite:", address, data, length, 1,
8547 xfered_len,'X', 0);
8548 }
8549
8550 static void
8551 remote_flash_done (struct target_ops *ops)
8552 {
8553 int ret;
8554
8555 scoped_restore restore_timeout
8556 = make_scoped_restore (&remote_timeout, remote_flash_timeout);
8557
8558 ret = remote_send_printf ("vFlashDone");
8559
8560 switch (ret)
8561 {
8562 case PACKET_UNKNOWN:
8563 error (_("Remote target does not support vFlashDone"));
8564 case PACKET_ERROR:
8565 error (_("Error finishing flash operation"));
8566 default:
8567 break;
8568 }
8569 }
8570
8571 static void
8572 remote_files_info (struct target_ops *ignore)
8573 {
8574 puts_filtered ("Debugging a target over a serial line.\n");
8575 }
8576 \f
8577 /* Stuff for dealing with the packets which are part of this protocol.
8578 See comment at top of file for details. */
8579
8580 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8581 error to higher layers. Called when a serial error is detected.
8582 The exception message is STRING, followed by a colon and a blank,
8583 the system error message for errno at function entry and final dot
8584 for output compatibility with throw_perror_with_name. */
8585
8586 static void
8587 unpush_and_perror (const char *string)
8588 {
8589 int saved_errno = errno;
8590
8591 remote_unpush_target ();
8592 throw_error (TARGET_CLOSE_ERROR, "%s: %s.", string,
8593 safe_strerror (saved_errno));
8594 }
8595
8596 /* Read a single character from the remote end. The current quit
8597 handler is overridden to avoid quitting in the middle of packet
8598 sequence, as that would break communication with the remote server.
8599 See remote_serial_quit_handler for more detail. */
8600
8601 static int
8602 readchar (int timeout)
8603 {
8604 int ch;
8605 struct remote_state *rs = get_remote_state ();
8606
8607 {
8608 scoped_restore restore_quit
8609 = make_scoped_restore (&quit_handler, remote_serial_quit_handler);
8610
8611 rs->got_ctrlc_during_io = 0;
8612
8613 ch = serial_readchar (rs->remote_desc, timeout);
8614
8615 if (rs->got_ctrlc_during_io)
8616 set_quit_flag ();
8617 }
8618
8619 if (ch >= 0)
8620 return ch;
8621
8622 switch ((enum serial_rc) ch)
8623 {
8624 case SERIAL_EOF:
8625 remote_unpush_target ();
8626 throw_error (TARGET_CLOSE_ERROR, _("Remote connection closed"));
8627 /* no return */
8628 case SERIAL_ERROR:
8629 unpush_and_perror (_("Remote communication error. "
8630 "Target disconnected."));
8631 /* no return */
8632 case SERIAL_TIMEOUT:
8633 break;
8634 }
8635 return ch;
8636 }
8637
8638 /* Wrapper for serial_write that closes the target and throws if
8639 writing fails. The current quit handler is overridden to avoid
8640 quitting in the middle of packet sequence, as that would break
8641 communication with the remote server. See
8642 remote_serial_quit_handler for more detail. */
8643
8644 static void
8645 remote_serial_write (const char *str, int len)
8646 {
8647 struct remote_state *rs = get_remote_state ();
8648
8649 scoped_restore restore_quit
8650 = make_scoped_restore (&quit_handler, remote_serial_quit_handler);
8651
8652 rs->got_ctrlc_during_io = 0;
8653
8654 if (serial_write (rs->remote_desc, str, len))
8655 {
8656 unpush_and_perror (_("Remote communication error. "
8657 "Target disconnected."));
8658 }
8659
8660 if (rs->got_ctrlc_during_io)
8661 set_quit_flag ();
8662 }
8663
8664 /* Send the command in *BUF to the remote machine, and read the reply
8665 into *BUF. Report an error if we get an error reply. Resize
8666 *BUF using xrealloc if necessary to hold the result, and update
8667 *SIZEOF_BUF. */
8668
8669 static void
8670 remote_send (char **buf,
8671 long *sizeof_buf)
8672 {
8673 putpkt (*buf);
8674 getpkt (buf, sizeof_buf, 0);
8675
8676 if ((*buf)[0] == 'E')
8677 error (_("Remote failure reply: %s"), *buf);
8678 }
8679
8680 /* Return a string representing an escaped version of BUF, of len N.
8681 E.g. \n is converted to \\n, \t to \\t, etc. */
8682
8683 static std::string
8684 escape_buffer (const char *buf, int n)
8685 {
8686 string_file stb;
8687
8688 stb.putstrn (buf, n, '\\');
8689 return std::move (stb.string ());
8690 }
8691
8692 /* Display a null-terminated packet on stdout, for debugging, using C
8693 string notation. */
8694
8695 static void
8696 print_packet (const char *buf)
8697 {
8698 puts_filtered ("\"");
8699 fputstr_filtered (buf, '"', gdb_stdout);
8700 puts_filtered ("\"");
8701 }
8702
8703 int
8704 putpkt (const char *buf)
8705 {
8706 return putpkt_binary (buf, strlen (buf));
8707 }
8708
8709 /* Send a packet to the remote machine, with error checking. The data
8710 of the packet is in BUF. The string in BUF can be at most
8711 get_remote_packet_size () - 5 to account for the $, # and checksum,
8712 and for a possible /0 if we are debugging (remote_debug) and want
8713 to print the sent packet as a string. */
8714
8715 static int
8716 putpkt_binary (const char *buf, int cnt)
8717 {
8718 struct remote_state *rs = get_remote_state ();
8719 int i;
8720 unsigned char csum = 0;
8721 gdb::def_vector<char> data (cnt + 6);
8722 char *buf2 = data.data ();
8723
8724 int ch;
8725 int tcount = 0;
8726 char *p;
8727
8728 /* Catch cases like trying to read memory or listing threads while
8729 we're waiting for a stop reply. The remote server wouldn't be
8730 ready to handle this request, so we'd hang and timeout. We don't
8731 have to worry about this in synchronous mode, because in that
8732 case it's not possible to issue a command while the target is
8733 running. This is not a problem in non-stop mode, because in that
8734 case, the stub is always ready to process serial input. */
8735 if (!target_is_non_stop_p ()
8736 && target_is_async_p ()
8737 && rs->waiting_for_stop_reply)
8738 {
8739 error (_("Cannot execute this command while the target is running.\n"
8740 "Use the \"interrupt\" command to stop the target\n"
8741 "and then try again."));
8742 }
8743
8744 /* We're sending out a new packet. Make sure we don't look at a
8745 stale cached response. */
8746 rs->cached_wait_status = 0;
8747
8748 /* Copy the packet into buffer BUF2, encapsulating it
8749 and giving it a checksum. */
8750
8751 p = buf2;
8752 *p++ = '$';
8753
8754 for (i = 0; i < cnt; i++)
8755 {
8756 csum += buf[i];
8757 *p++ = buf[i];
8758 }
8759 *p++ = '#';
8760 *p++ = tohex ((csum >> 4) & 0xf);
8761 *p++ = tohex (csum & 0xf);
8762
8763 /* Send it over and over until we get a positive ack. */
8764
8765 while (1)
8766 {
8767 int started_error_output = 0;
8768
8769 if (remote_debug)
8770 {
8771 *p = '\0';
8772
8773 int len = (int) (p - buf2);
8774
8775 std::string str
8776 = escape_buffer (buf2, std::min (len, REMOTE_DEBUG_MAX_CHAR));
8777
8778 fprintf_unfiltered (gdb_stdlog, "Sending packet: %s", str.c_str ());
8779
8780 if (str.length () > REMOTE_DEBUG_MAX_CHAR)
8781 {
8782 fprintf_unfiltered (gdb_stdlog, "[%zu bytes omitted]",
8783 str.length () - REMOTE_DEBUG_MAX_CHAR);
8784 }
8785
8786 fprintf_unfiltered (gdb_stdlog, "...");
8787
8788 gdb_flush (gdb_stdlog);
8789 }
8790 remote_serial_write (buf2, p - buf2);
8791
8792 /* If this is a no acks version of the remote protocol, send the
8793 packet and move on. */
8794 if (rs->noack_mode)
8795 break;
8796
8797 /* Read until either a timeout occurs (-2) or '+' is read.
8798 Handle any notification that arrives in the mean time. */
8799 while (1)
8800 {
8801 ch = readchar (remote_timeout);
8802
8803 if (remote_debug)
8804 {
8805 switch (ch)
8806 {
8807 case '+':
8808 case '-':
8809 case SERIAL_TIMEOUT:
8810 case '$':
8811 case '%':
8812 if (started_error_output)
8813 {
8814 putchar_unfiltered ('\n');
8815 started_error_output = 0;
8816 }
8817 }
8818 }
8819
8820 switch (ch)
8821 {
8822 case '+':
8823 if (remote_debug)
8824 fprintf_unfiltered (gdb_stdlog, "Ack\n");
8825 return 1;
8826 case '-':
8827 if (remote_debug)
8828 fprintf_unfiltered (gdb_stdlog, "Nak\n");
8829 /* FALLTHROUGH */
8830 case SERIAL_TIMEOUT:
8831 tcount++;
8832 if (tcount > 3)
8833 return 0;
8834 break; /* Retransmit buffer. */
8835 case '$':
8836 {
8837 if (remote_debug)
8838 fprintf_unfiltered (gdb_stdlog,
8839 "Packet instead of Ack, ignoring it\n");
8840 /* It's probably an old response sent because an ACK
8841 was lost. Gobble up the packet and ack it so it
8842 doesn't get retransmitted when we resend this
8843 packet. */
8844 skip_frame ();
8845 remote_serial_write ("+", 1);
8846 continue; /* Now, go look for +. */
8847 }
8848
8849 case '%':
8850 {
8851 int val;
8852
8853 /* If we got a notification, handle it, and go back to looking
8854 for an ack. */
8855 /* We've found the start of a notification. Now
8856 collect the data. */
8857 val = read_frame (&rs->buf, &rs->buf_size);
8858 if (val >= 0)
8859 {
8860 if (remote_debug)
8861 {
8862 std::string str = escape_buffer (rs->buf, val);
8863
8864 fprintf_unfiltered (gdb_stdlog,
8865 " Notification received: %s\n",
8866 str.c_str ());
8867 }
8868 handle_notification (rs->notif_state, rs->buf);
8869 /* We're in sync now, rewait for the ack. */
8870 tcount = 0;
8871 }
8872 else
8873 {
8874 if (remote_debug)
8875 {
8876 if (!started_error_output)
8877 {
8878 started_error_output = 1;
8879 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
8880 }
8881 fputc_unfiltered (ch & 0177, gdb_stdlog);
8882 fprintf_unfiltered (gdb_stdlog, "%s", rs->buf);
8883 }
8884 }
8885 continue;
8886 }
8887 /* fall-through */
8888 default:
8889 if (remote_debug)
8890 {
8891 if (!started_error_output)
8892 {
8893 started_error_output = 1;
8894 fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
8895 }
8896 fputc_unfiltered (ch & 0177, gdb_stdlog);
8897 }
8898 continue;
8899 }
8900 break; /* Here to retransmit. */
8901 }
8902
8903 #if 0
8904 /* This is wrong. If doing a long backtrace, the user should be
8905 able to get out next time we call QUIT, without anything as
8906 violent as interrupt_query. If we want to provide a way out of
8907 here without getting to the next QUIT, it should be based on
8908 hitting ^C twice as in remote_wait. */
8909 if (quit_flag)
8910 {
8911 quit_flag = 0;
8912 interrupt_query ();
8913 }
8914 #endif
8915 }
8916
8917 return 0;
8918 }
8919
8920 /* Come here after finding the start of a frame when we expected an
8921 ack. Do our best to discard the rest of this packet. */
8922
8923 static void
8924 skip_frame (void)
8925 {
8926 int c;
8927
8928 while (1)
8929 {
8930 c = readchar (remote_timeout);
8931 switch (c)
8932 {
8933 case SERIAL_TIMEOUT:
8934 /* Nothing we can do. */
8935 return;
8936 case '#':
8937 /* Discard the two bytes of checksum and stop. */
8938 c = readchar (remote_timeout);
8939 if (c >= 0)
8940 c = readchar (remote_timeout);
8941
8942 return;
8943 case '*': /* Run length encoding. */
8944 /* Discard the repeat count. */
8945 c = readchar (remote_timeout);
8946 if (c < 0)
8947 return;
8948 break;
8949 default:
8950 /* A regular character. */
8951 break;
8952 }
8953 }
8954 }
8955
8956 /* Come here after finding the start of the frame. Collect the rest
8957 into *BUF, verifying the checksum, length, and handling run-length
8958 compression. NUL terminate the buffer. If there is not enough room,
8959 expand *BUF using xrealloc.
8960
8961 Returns -1 on error, number of characters in buffer (ignoring the
8962 trailing NULL) on success. (could be extended to return one of the
8963 SERIAL status indications). */
8964
8965 static long
8966 read_frame (char **buf_p,
8967 long *sizeof_buf)
8968 {
8969 unsigned char csum;
8970 long bc;
8971 int c;
8972 char *buf = *buf_p;
8973 struct remote_state *rs = get_remote_state ();
8974
8975 csum = 0;
8976 bc = 0;
8977
8978 while (1)
8979 {
8980 c = readchar (remote_timeout);
8981 switch (c)
8982 {
8983 case SERIAL_TIMEOUT:
8984 if (remote_debug)
8985 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog);
8986 return -1;
8987 case '$':
8988 if (remote_debug)
8989 fputs_filtered ("Saw new packet start in middle of old one\n",
8990 gdb_stdlog);
8991 return -1; /* Start a new packet, count retries. */
8992 case '#':
8993 {
8994 unsigned char pktcsum;
8995 int check_0 = 0;
8996 int check_1 = 0;
8997
8998 buf[bc] = '\0';
8999
9000 check_0 = readchar (remote_timeout);
9001 if (check_0 >= 0)
9002 check_1 = readchar (remote_timeout);
9003
9004 if (check_0 == SERIAL_TIMEOUT || check_1 == SERIAL_TIMEOUT)
9005 {
9006 if (remote_debug)
9007 fputs_filtered ("Timeout in checksum, retrying\n",
9008 gdb_stdlog);
9009 return -1;
9010 }
9011 else if (check_0 < 0 || check_1 < 0)
9012 {
9013 if (remote_debug)
9014 fputs_filtered ("Communication error in checksum\n",
9015 gdb_stdlog);
9016 return -1;
9017 }
9018
9019 /* Don't recompute the checksum; with no ack packets we
9020 don't have any way to indicate a packet retransmission
9021 is necessary. */
9022 if (rs->noack_mode)
9023 return bc;
9024
9025 pktcsum = (fromhex (check_0) << 4) | fromhex (check_1);
9026 if (csum == pktcsum)
9027 return bc;
9028
9029 if (remote_debug)
9030 {
9031 std::string str = escape_buffer (buf, bc);
9032
9033 fprintf_unfiltered (gdb_stdlog,
9034 "Bad checksum, sentsum=0x%x, "
9035 "csum=0x%x, buf=%s\n",
9036 pktcsum, csum, str.c_str ());
9037 }
9038 /* Number of characters in buffer ignoring trailing
9039 NULL. */
9040 return -1;
9041 }
9042 case '*': /* Run length encoding. */
9043 {
9044 int repeat;
9045
9046 csum += c;
9047 c = readchar (remote_timeout);
9048 csum += c;
9049 repeat = c - ' ' + 3; /* Compute repeat count. */
9050
9051 /* The character before ``*'' is repeated. */
9052
9053 if (repeat > 0 && repeat <= 255 && bc > 0)
9054 {
9055 if (bc + repeat - 1 >= *sizeof_buf - 1)
9056 {
9057 /* Make some more room in the buffer. */
9058 *sizeof_buf += repeat;
9059 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
9060 buf = *buf_p;
9061 }
9062
9063 memset (&buf[bc], buf[bc - 1], repeat);
9064 bc += repeat;
9065 continue;
9066 }
9067
9068 buf[bc] = '\0';
9069 printf_filtered (_("Invalid run length encoding: %s\n"), buf);
9070 return -1;
9071 }
9072 default:
9073 if (bc >= *sizeof_buf - 1)
9074 {
9075 /* Make some more room in the buffer. */
9076 *sizeof_buf *= 2;
9077 *buf_p = (char *) xrealloc (*buf_p, *sizeof_buf);
9078 buf = *buf_p;
9079 }
9080
9081 buf[bc++] = c;
9082 csum += c;
9083 continue;
9084 }
9085 }
9086 }
9087
9088 /* Read a packet from the remote machine, with error checking, and
9089 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9090 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9091 rather than timing out; this is used (in synchronous mode) to wait
9092 for a target that is is executing user code to stop. */
9093 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9094 don't have to change all the calls to getpkt to deal with the
9095 return value, because at the moment I don't know what the right
9096 thing to do it for those. */
9097 void
9098 getpkt (char **buf,
9099 long *sizeof_buf,
9100 int forever)
9101 {
9102 getpkt_sane (buf, sizeof_buf, forever);
9103 }
9104
9105
9106 /* Read a packet from the remote machine, with error checking, and
9107 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9108 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9109 rather than timing out; this is used (in synchronous mode) to wait
9110 for a target that is is executing user code to stop. If FOREVER ==
9111 0, this function is allowed to time out gracefully and return an
9112 indication of this to the caller. Otherwise return the number of
9113 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9114 enough reason to return to the caller. *IS_NOTIF is an output
9115 boolean that indicates whether *BUF holds a notification or not
9116 (a regular packet). */
9117
9118 static int
9119 getpkt_or_notif_sane_1 (char **buf, long *sizeof_buf, int forever,
9120 int expecting_notif, int *is_notif)
9121 {
9122 struct remote_state *rs = get_remote_state ();
9123 int c;
9124 int tries;
9125 int timeout;
9126 int val = -1;
9127
9128 /* We're reading a new response. Make sure we don't look at a
9129 previously cached response. */
9130 rs->cached_wait_status = 0;
9131
9132 strcpy (*buf, "timeout");
9133
9134 if (forever)
9135 timeout = watchdog > 0 ? watchdog : -1;
9136 else if (expecting_notif)
9137 timeout = 0; /* There should already be a char in the buffer. If
9138 not, bail out. */
9139 else
9140 timeout = remote_timeout;
9141
9142 #define MAX_TRIES 3
9143
9144 /* Process any number of notifications, and then return when
9145 we get a packet. */
9146 for (;;)
9147 {
9148 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9149 times. */
9150 for (tries = 1; tries <= MAX_TRIES; tries++)
9151 {
9152 /* This can loop forever if the remote side sends us
9153 characters continuously, but if it pauses, we'll get
9154 SERIAL_TIMEOUT from readchar because of timeout. Then
9155 we'll count that as a retry.
9156
9157 Note that even when forever is set, we will only wait
9158 forever prior to the start of a packet. After that, we
9159 expect characters to arrive at a brisk pace. They should
9160 show up within remote_timeout intervals. */
9161 do
9162 c = readchar (timeout);
9163 while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
9164
9165 if (c == SERIAL_TIMEOUT)
9166 {
9167 if (expecting_notif)
9168 return -1; /* Don't complain, it's normal to not get
9169 anything in this case. */
9170
9171 if (forever) /* Watchdog went off? Kill the target. */
9172 {
9173 remote_unpush_target ();
9174 throw_error (TARGET_CLOSE_ERROR,
9175 _("Watchdog timeout has expired. "
9176 "Target detached."));
9177 }
9178 if (remote_debug)
9179 fputs_filtered ("Timed out.\n", gdb_stdlog);
9180 }
9181 else
9182 {
9183 /* We've found the start of a packet or notification.
9184 Now collect the data. */
9185 val = read_frame (buf, sizeof_buf);
9186 if (val >= 0)
9187 break;
9188 }
9189
9190 remote_serial_write ("-", 1);
9191 }
9192
9193 if (tries > MAX_TRIES)
9194 {
9195 /* We have tried hard enough, and just can't receive the
9196 packet/notification. Give up. */
9197 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9198
9199 /* Skip the ack char if we're in no-ack mode. */
9200 if (!rs->noack_mode)
9201 remote_serial_write ("+", 1);
9202 return -1;
9203 }
9204
9205 /* If we got an ordinary packet, return that to our caller. */
9206 if (c == '$')
9207 {
9208 if (remote_debug)
9209 {
9210 std::string str
9211 = escape_buffer (*buf,
9212 std::min (val, REMOTE_DEBUG_MAX_CHAR));
9213
9214 fprintf_unfiltered (gdb_stdlog, "Packet received: %s",
9215 str.c_str ());
9216
9217 if (str.length () > REMOTE_DEBUG_MAX_CHAR)
9218 {
9219 fprintf_unfiltered (gdb_stdlog, "[%zu bytes omitted]",
9220 str.length () - REMOTE_DEBUG_MAX_CHAR);
9221 }
9222
9223 fprintf_unfiltered (gdb_stdlog, "\n");
9224 }
9225
9226 /* Skip the ack char if we're in no-ack mode. */
9227 if (!rs->noack_mode)
9228 remote_serial_write ("+", 1);
9229 if (is_notif != NULL)
9230 *is_notif = 0;
9231 return val;
9232 }
9233
9234 /* If we got a notification, handle it, and go back to looking
9235 for a packet. */
9236 else
9237 {
9238 gdb_assert (c == '%');
9239
9240 if (remote_debug)
9241 {
9242 std::string str = escape_buffer (*buf, val);
9243
9244 fprintf_unfiltered (gdb_stdlog,
9245 " Notification received: %s\n",
9246 str.c_str ());
9247 }
9248 if (is_notif != NULL)
9249 *is_notif = 1;
9250
9251 handle_notification (rs->notif_state, *buf);
9252
9253 /* Notifications require no acknowledgement. */
9254
9255 if (expecting_notif)
9256 return val;
9257 }
9258 }
9259 }
9260
9261 static int
9262 getpkt_sane (char **buf, long *sizeof_buf, int forever)
9263 {
9264 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 0, NULL);
9265 }
9266
9267 static int
9268 getpkt_or_notif_sane (char **buf, long *sizeof_buf, int forever,
9269 int *is_notif)
9270 {
9271 return getpkt_or_notif_sane_1 (buf, sizeof_buf, forever, 1,
9272 is_notif);
9273 }
9274
9275 /* Check whether EVENT is a fork event for the process specified
9276 by the pid passed in DATA, and if it is, kill the fork child. */
9277
9278 static int
9279 kill_child_of_pending_fork (QUEUE (stop_reply_p) *q,
9280 QUEUE_ITER (stop_reply_p) *iter,
9281 stop_reply_p event,
9282 void *data)
9283 {
9284 struct queue_iter_param *param = (struct queue_iter_param *) data;
9285 int parent_pid = *(int *) param->input;
9286
9287 if (is_pending_fork_parent (&event->ws, parent_pid, event->ptid))
9288 {
9289 struct remote_state *rs = get_remote_state ();
9290 int child_pid = ptid_get_pid (event->ws.value.related_pid);
9291 int res;
9292
9293 res = remote_vkill (child_pid, rs);
9294 if (res != 0)
9295 error (_("Can't kill fork child process %d"), child_pid);
9296 }
9297
9298 return 1;
9299 }
9300
9301 /* Kill any new fork children of process PID that haven't been
9302 processed by follow_fork. */
9303
9304 static void
9305 kill_new_fork_children (int pid, struct remote_state *rs)
9306 {
9307 struct thread_info *thread;
9308 struct notif_client *notif = &notif_client_stop;
9309 struct queue_iter_param param;
9310
9311 /* Kill the fork child threads of any threads in process PID
9312 that are stopped at a fork event. */
9313 ALL_NON_EXITED_THREADS (thread)
9314 {
9315 struct target_waitstatus *ws = &thread->pending_follow;
9316
9317 if (is_pending_fork_parent (ws, pid, thread->ptid))
9318 {
9319 struct remote_state *rs = get_remote_state ();
9320 int child_pid = ptid_get_pid (ws->value.related_pid);
9321 int res;
9322
9323 res = remote_vkill (child_pid, rs);
9324 if (res != 0)
9325 error (_("Can't kill fork child process %d"), child_pid);
9326 }
9327 }
9328
9329 /* Check for any pending fork events (not reported or processed yet)
9330 in process PID and kill those fork child threads as well. */
9331 remote_notif_get_pending_events (notif);
9332 param.input = &pid;
9333 param.output = NULL;
9334 QUEUE_iterate (stop_reply_p, stop_reply_queue,
9335 kill_child_of_pending_fork, &param);
9336 }
9337
9338 \f
9339 /* Target hook to kill the current inferior. */
9340
9341 static void
9342 remote_kill (struct target_ops *ops)
9343 {
9344 int res = -1;
9345 int pid = ptid_get_pid (inferior_ptid);
9346 struct remote_state *rs = get_remote_state ();
9347
9348 if (packet_support (PACKET_vKill) != PACKET_DISABLE)
9349 {
9350 /* If we're stopped while forking and we haven't followed yet,
9351 kill the child task. We need to do this before killing the
9352 parent task because if this is a vfork then the parent will
9353 be sleeping. */
9354 kill_new_fork_children (pid, rs);
9355
9356 res = remote_vkill (pid, rs);
9357 if (res == 0)
9358 {
9359 target_mourn_inferior (inferior_ptid);
9360 return;
9361 }
9362 }
9363
9364 /* If we are in 'target remote' mode and we are killing the only
9365 inferior, then we will tell gdbserver to exit and unpush the
9366 target. */
9367 if (res == -1 && !remote_multi_process_p (rs)
9368 && number_of_live_inferiors () == 1)
9369 {
9370 remote_kill_k ();
9371
9372 /* We've killed the remote end, we get to mourn it. If we are
9373 not in extended mode, mourning the inferior also unpushes
9374 remote_ops from the target stack, which closes the remote
9375 connection. */
9376 target_mourn_inferior (inferior_ptid);
9377
9378 return;
9379 }
9380
9381 error (_("Can't kill process"));
9382 }
9383
9384 /* Send a kill request to the target using the 'vKill' packet. */
9385
9386 static int
9387 remote_vkill (int pid, struct remote_state *rs)
9388 {
9389 if (packet_support (PACKET_vKill) == PACKET_DISABLE)
9390 return -1;
9391
9392 /* Tell the remote target to detach. */
9393 xsnprintf (rs->buf, get_remote_packet_size (), "vKill;%x", pid);
9394 putpkt (rs->buf);
9395 getpkt (&rs->buf, &rs->buf_size, 0);
9396
9397 switch (packet_ok (rs->buf,
9398 &remote_protocol_packets[PACKET_vKill]))
9399 {
9400 case PACKET_OK:
9401 return 0;
9402 case PACKET_ERROR:
9403 return 1;
9404 case PACKET_UNKNOWN:
9405 return -1;
9406 default:
9407 internal_error (__FILE__, __LINE__, _("Bad result from packet_ok"));
9408 }
9409 }
9410
9411 /* Send a kill request to the target using the 'k' packet. */
9412
9413 static void
9414 remote_kill_k (void)
9415 {
9416 /* Catch errors so the user can quit from gdb even when we
9417 aren't on speaking terms with the remote system. */
9418 TRY
9419 {
9420 putpkt ("k");
9421 }
9422 CATCH (ex, RETURN_MASK_ERROR)
9423 {
9424 if (ex.error == TARGET_CLOSE_ERROR)
9425 {
9426 /* If we got an (EOF) error that caused the target
9427 to go away, then we're done, that's what we wanted.
9428 "k" is susceptible to cause a premature EOF, given
9429 that the remote server isn't actually required to
9430 reply to "k", and it can happen that it doesn't
9431 even get to reply ACK to the "k". */
9432 return;
9433 }
9434
9435 /* Otherwise, something went wrong. We didn't actually kill
9436 the target. Just propagate the exception, and let the
9437 user or higher layers decide what to do. */
9438 throw_exception (ex);
9439 }
9440 END_CATCH
9441 }
9442
9443 static void
9444 remote_mourn (struct target_ops *target)
9445 {
9446 struct remote_state *rs = get_remote_state ();
9447
9448 /* In 'target remote' mode with one inferior, we close the connection. */
9449 if (!rs->extended && number_of_live_inferiors () <= 1)
9450 {
9451 unpush_target (target);
9452
9453 /* remote_close takes care of doing most of the clean up. */
9454 generic_mourn_inferior ();
9455 return;
9456 }
9457
9458 /* In case we got here due to an error, but we're going to stay
9459 connected. */
9460 rs->waiting_for_stop_reply = 0;
9461
9462 /* If the current general thread belonged to the process we just
9463 detached from or has exited, the remote side current general
9464 thread becomes undefined. Considering a case like this:
9465
9466 - We just got here due to a detach.
9467 - The process that we're detaching from happens to immediately
9468 report a global breakpoint being hit in non-stop mode, in the
9469 same thread we had selected before.
9470 - GDB attaches to this process again.
9471 - This event happens to be the next event we handle.
9472
9473 GDB would consider that the current general thread didn't need to
9474 be set on the stub side (with Hg), since for all it knew,
9475 GENERAL_THREAD hadn't changed.
9476
9477 Notice that although in all-stop mode, the remote server always
9478 sets the current thread to the thread reporting the stop event,
9479 that doesn't happen in non-stop mode; in non-stop, the stub *must
9480 not* change the current thread when reporting a breakpoint hit,
9481 due to the decoupling of event reporting and event handling.
9482
9483 To keep things simple, we always invalidate our notion of the
9484 current thread. */
9485 record_currthread (rs, minus_one_ptid);
9486
9487 /* Call common code to mark the inferior as not running. */
9488 generic_mourn_inferior ();
9489
9490 if (!have_inferiors ())
9491 {
9492 if (!remote_multi_process_p (rs))
9493 {
9494 /* Check whether the target is running now - some remote stubs
9495 automatically restart after kill. */
9496 putpkt ("?");
9497 getpkt (&rs->buf, &rs->buf_size, 0);
9498
9499 if (rs->buf[0] == 'S' || rs->buf[0] == 'T')
9500 {
9501 /* Assume that the target has been restarted. Set
9502 inferior_ptid so that bits of core GDB realizes
9503 there's something here, e.g., so that the user can
9504 say "kill" again. */
9505 inferior_ptid = magic_null_ptid;
9506 }
9507 }
9508 }
9509 }
9510
9511 static int
9512 extended_remote_supports_disable_randomization (struct target_ops *self)
9513 {
9514 return packet_support (PACKET_QDisableRandomization) == PACKET_ENABLE;
9515 }
9516
9517 static void
9518 extended_remote_disable_randomization (int val)
9519 {
9520 struct remote_state *rs = get_remote_state ();
9521 char *reply;
9522
9523 xsnprintf (rs->buf, get_remote_packet_size (), "QDisableRandomization:%x",
9524 val);
9525 putpkt (rs->buf);
9526 reply = remote_get_noisy_reply ();
9527 if (*reply == '\0')
9528 error (_("Target does not support QDisableRandomization."));
9529 if (strcmp (reply, "OK") != 0)
9530 error (_("Bogus QDisableRandomization reply from target: %s"), reply);
9531 }
9532
9533 static int
9534 extended_remote_run (const std::string &args)
9535 {
9536 struct remote_state *rs = get_remote_state ();
9537 int len;
9538 const char *remote_exec_file = get_remote_exec_file ();
9539
9540 /* If the user has disabled vRun support, or we have detected that
9541 support is not available, do not try it. */
9542 if (packet_support (PACKET_vRun) == PACKET_DISABLE)
9543 return -1;
9544
9545 strcpy (rs->buf, "vRun;");
9546 len = strlen (rs->buf);
9547
9548 if (strlen (remote_exec_file) * 2 + len >= get_remote_packet_size ())
9549 error (_("Remote file name too long for run packet"));
9550 len += 2 * bin2hex ((gdb_byte *) remote_exec_file, rs->buf + len,
9551 strlen (remote_exec_file));
9552
9553 if (!args.empty ())
9554 {
9555 int i;
9556
9557 gdb_argv argv (args.c_str ());
9558 for (i = 0; argv[i] != NULL; i++)
9559 {
9560 if (strlen (argv[i]) * 2 + 1 + len >= get_remote_packet_size ())
9561 error (_("Argument list too long for run packet"));
9562 rs->buf[len++] = ';';
9563 len += 2 * bin2hex ((gdb_byte *) argv[i], rs->buf + len,
9564 strlen (argv[i]));
9565 }
9566 }
9567
9568 rs->buf[len++] = '\0';
9569
9570 putpkt (rs->buf);
9571 getpkt (&rs->buf, &rs->buf_size, 0);
9572
9573 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_vRun]))
9574 {
9575 case PACKET_OK:
9576 /* We have a wait response. All is well. */
9577 return 0;
9578 case PACKET_UNKNOWN:
9579 return -1;
9580 case PACKET_ERROR:
9581 if (remote_exec_file[0] == '\0')
9582 error (_("Running the default executable on the remote target failed; "
9583 "try \"set remote exec-file\"?"));
9584 else
9585 error (_("Running \"%s\" on the remote target failed"),
9586 remote_exec_file);
9587 default:
9588 gdb_assert_not_reached (_("bad switch"));
9589 }
9590 }
9591
9592 /* Helper function to send set/unset environment packets. ACTION is
9593 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9594 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9595 sent. */
9596
9597 static void
9598 send_environment_packet (struct remote_state *rs,
9599 const char *action,
9600 const char *packet,
9601 const char *value)
9602 {
9603 /* Convert the environment variable to an hex string, which
9604 is the best format to be transmitted over the wire. */
9605 std::string encoded_value = bin2hex ((const gdb_byte *) value,
9606 strlen (value));
9607
9608 xsnprintf (rs->buf, get_remote_packet_size (),
9609 "%s:%s", packet, encoded_value.c_str ());
9610
9611 putpkt (rs->buf);
9612 getpkt (&rs->buf, &rs->buf_size, 0);
9613 if (strcmp (rs->buf, "OK") != 0)
9614 warning (_("Unable to %s environment variable '%s' on remote."),
9615 action, value);
9616 }
9617
9618 /* Helper function to handle the QEnvironment* packets. */
9619
9620 static void
9621 extended_remote_environment_support (struct remote_state *rs)
9622 {
9623 if (packet_support (PACKET_QEnvironmentReset) != PACKET_DISABLE)
9624 {
9625 putpkt ("QEnvironmentReset");
9626 getpkt (&rs->buf, &rs->buf_size, 0);
9627 if (strcmp (rs->buf, "OK") != 0)
9628 warning (_("Unable to reset environment on remote."));
9629 }
9630
9631 gdb_environ *e = &current_inferior ()->environment;
9632
9633 if (packet_support (PACKET_QEnvironmentHexEncoded) != PACKET_DISABLE)
9634 for (const std::string &el : e->user_set_env ())
9635 send_environment_packet (rs, "set", "QEnvironmentHexEncoded",
9636 el.c_str ());
9637
9638 if (packet_support (PACKET_QEnvironmentUnset) != PACKET_DISABLE)
9639 for (const std::string &el : e->user_unset_env ())
9640 send_environment_packet (rs, "unset", "QEnvironmentUnset", el.c_str ());
9641 }
9642
9643 /* Helper function to set the current working directory for the
9644 inferior in the remote target. */
9645
9646 static void
9647 extended_remote_set_inferior_cwd (struct remote_state *rs)
9648 {
9649 if (packet_support (PACKET_QSetWorkingDir) != PACKET_DISABLE)
9650 {
9651 const char *inferior_cwd = get_inferior_cwd ();
9652
9653 if (inferior_cwd != NULL)
9654 {
9655 std::string hexpath = bin2hex ((const gdb_byte *) inferior_cwd,
9656 strlen (inferior_cwd));
9657
9658 xsnprintf (rs->buf, get_remote_packet_size (),
9659 "QSetWorkingDir:%s", hexpath.c_str ());
9660 }
9661 else
9662 {
9663 /* An empty inferior_cwd means that the user wants us to
9664 reset the remote server's inferior's cwd. */
9665 xsnprintf (rs->buf, get_remote_packet_size (),
9666 "QSetWorkingDir:");
9667 }
9668
9669 putpkt (rs->buf);
9670 getpkt (&rs->buf, &rs->buf_size, 0);
9671 if (packet_ok (rs->buf,
9672 &remote_protocol_packets[PACKET_QSetWorkingDir])
9673 != PACKET_OK)
9674 error (_("\
9675 Remote replied unexpectedly while setting the inferior's working\n\
9676 directory: %s"),
9677 rs->buf);
9678
9679 }
9680 }
9681
9682 /* In the extended protocol we want to be able to do things like
9683 "run" and have them basically work as expected. So we need
9684 a special create_inferior function. We support changing the
9685 executable file and the command line arguments, but not the
9686 environment. */
9687
9688 static void
9689 extended_remote_create_inferior (struct target_ops *ops,
9690 const char *exec_file,
9691 const std::string &args,
9692 char **env, int from_tty)
9693 {
9694 int run_worked;
9695 char *stop_reply;
9696 struct remote_state *rs = get_remote_state ();
9697 const char *remote_exec_file = get_remote_exec_file ();
9698
9699 /* If running asynchronously, register the target file descriptor
9700 with the event loop. */
9701 if (target_can_async_p ())
9702 target_async (1);
9703
9704 /* Disable address space randomization if requested (and supported). */
9705 if (extended_remote_supports_disable_randomization (ops))
9706 extended_remote_disable_randomization (disable_randomization);
9707
9708 /* If startup-with-shell is on, we inform gdbserver to start the
9709 remote inferior using a shell. */
9710 if (packet_support (PACKET_QStartupWithShell) != PACKET_DISABLE)
9711 {
9712 xsnprintf (rs->buf, get_remote_packet_size (),
9713 "QStartupWithShell:%d", startup_with_shell ? 1 : 0);
9714 putpkt (rs->buf);
9715 getpkt (&rs->buf, &rs->buf_size, 0);
9716 if (strcmp (rs->buf, "OK") != 0)
9717 error (_("\
9718 Remote replied unexpectedly while setting startup-with-shell: %s"),
9719 rs->buf);
9720 }
9721
9722 extended_remote_environment_support (rs);
9723
9724 extended_remote_set_inferior_cwd (rs);
9725
9726 /* Now restart the remote server. */
9727 run_worked = extended_remote_run (args) != -1;
9728 if (!run_worked)
9729 {
9730 /* vRun was not supported. Fail if we need it to do what the
9731 user requested. */
9732 if (remote_exec_file[0])
9733 error (_("Remote target does not support \"set remote exec-file\""));
9734 if (!args.empty ())
9735 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9736
9737 /* Fall back to "R". */
9738 extended_remote_restart ();
9739 }
9740
9741 if (!have_inferiors ())
9742 {
9743 /* Clean up from the last time we ran, before we mark the target
9744 running again. This will mark breakpoints uninserted, and
9745 get_offsets may insert breakpoints. */
9746 init_thread_list ();
9747 init_wait_for_inferior ();
9748 }
9749
9750 /* vRun's success return is a stop reply. */
9751 stop_reply = run_worked ? rs->buf : NULL;
9752 add_current_inferior_and_thread (stop_reply);
9753
9754 /* Get updated offsets, if the stub uses qOffsets. */
9755 get_offsets ();
9756 }
9757 \f
9758
9759 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9760 the list of conditions (in agent expression bytecode format), if any, the
9761 target needs to evaluate. The output is placed into the packet buffer
9762 started from BUF and ended at BUF_END. */
9763
9764 static int
9765 remote_add_target_side_condition (struct gdbarch *gdbarch,
9766 struct bp_target_info *bp_tgt, char *buf,
9767 char *buf_end)
9768 {
9769 if (bp_tgt->conditions.empty ())
9770 return 0;
9771
9772 buf += strlen (buf);
9773 xsnprintf (buf, buf_end - buf, "%s", ";");
9774 buf++;
9775
9776 /* Send conditions to the target. */
9777 for (agent_expr *aexpr : bp_tgt->conditions)
9778 {
9779 xsnprintf (buf, buf_end - buf, "X%x,", aexpr->len);
9780 buf += strlen (buf);
9781 for (int i = 0; i < aexpr->len; ++i)
9782 buf = pack_hex_byte (buf, aexpr->buf[i]);
9783 *buf = '\0';
9784 }
9785 return 0;
9786 }
9787
9788 static void
9789 remote_add_target_side_commands (struct gdbarch *gdbarch,
9790 struct bp_target_info *bp_tgt, char *buf)
9791 {
9792 if (bp_tgt->tcommands.empty ())
9793 return;
9794
9795 buf += strlen (buf);
9796
9797 sprintf (buf, ";cmds:%x,", bp_tgt->persist);
9798 buf += strlen (buf);
9799
9800 /* Concatenate all the agent expressions that are commands into the
9801 cmds parameter. */
9802 for (agent_expr *aexpr : bp_tgt->tcommands)
9803 {
9804 sprintf (buf, "X%x,", aexpr->len);
9805 buf += strlen (buf);
9806 for (int i = 0; i < aexpr->len; ++i)
9807 buf = pack_hex_byte (buf, aexpr->buf[i]);
9808 *buf = '\0';
9809 }
9810 }
9811
9812 /* Insert a breakpoint. On targets that have software breakpoint
9813 support, we ask the remote target to do the work; on targets
9814 which don't, we insert a traditional memory breakpoint. */
9815
9816 static int
9817 remote_insert_breakpoint (struct target_ops *ops,
9818 struct gdbarch *gdbarch,
9819 struct bp_target_info *bp_tgt)
9820 {
9821 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9822 If it succeeds, then set the support to PACKET_ENABLE. If it
9823 fails, and the user has explicitly requested the Z support then
9824 report an error, otherwise, mark it disabled and go on. */
9825
9826 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
9827 {
9828 CORE_ADDR addr = bp_tgt->reqstd_address;
9829 struct remote_state *rs;
9830 char *p, *endbuf;
9831 int bpsize;
9832
9833 /* Make sure the remote is pointing at the right process, if
9834 necessary. */
9835 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9836 set_general_process ();
9837
9838 rs = get_remote_state ();
9839 p = rs->buf;
9840 endbuf = rs->buf + get_remote_packet_size ();
9841
9842 *(p++) = 'Z';
9843 *(p++) = '0';
9844 *(p++) = ',';
9845 addr = (ULONGEST) remote_address_masked (addr);
9846 p += hexnumstr (p, addr);
9847 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
9848
9849 if (remote_supports_cond_breakpoints (ops))
9850 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
9851
9852 if (remote_can_run_breakpoint_commands (ops))
9853 remote_add_target_side_commands (gdbarch, bp_tgt, p);
9854
9855 putpkt (rs->buf);
9856 getpkt (&rs->buf, &rs->buf_size, 0);
9857
9858 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0]))
9859 {
9860 case PACKET_ERROR:
9861 return -1;
9862 case PACKET_OK:
9863 return 0;
9864 case PACKET_UNKNOWN:
9865 break;
9866 }
9867 }
9868
9869 /* If this breakpoint has target-side commands but this stub doesn't
9870 support Z0 packets, throw error. */
9871 if (!bp_tgt->tcommands.empty ())
9872 throw_error (NOT_SUPPORTED_ERROR, _("\
9873 Target doesn't support breakpoints that have target side commands."));
9874
9875 return memory_insert_breakpoint (ops, gdbarch, bp_tgt);
9876 }
9877
9878 static int
9879 remote_remove_breakpoint (struct target_ops *ops,
9880 struct gdbarch *gdbarch,
9881 struct bp_target_info *bp_tgt,
9882 enum remove_bp_reason reason)
9883 {
9884 CORE_ADDR addr = bp_tgt->placed_address;
9885 struct remote_state *rs = get_remote_state ();
9886
9887 if (packet_support (PACKET_Z0) != PACKET_DISABLE)
9888 {
9889 char *p = rs->buf;
9890 char *endbuf = rs->buf + get_remote_packet_size ();
9891
9892 /* Make sure the remote is pointing at the right process, if
9893 necessary. */
9894 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9895 set_general_process ();
9896
9897 *(p++) = 'z';
9898 *(p++) = '0';
9899 *(p++) = ',';
9900
9901 addr = (ULONGEST) remote_address_masked (bp_tgt->placed_address);
9902 p += hexnumstr (p, addr);
9903 xsnprintf (p, endbuf - p, ",%d", bp_tgt->kind);
9904
9905 putpkt (rs->buf);
9906 getpkt (&rs->buf, &rs->buf_size, 0);
9907
9908 return (rs->buf[0] == 'E');
9909 }
9910
9911 return memory_remove_breakpoint (ops, gdbarch, bp_tgt, reason);
9912 }
9913
9914 static enum Z_packet_type
9915 watchpoint_to_Z_packet (int type)
9916 {
9917 switch (type)
9918 {
9919 case hw_write:
9920 return Z_PACKET_WRITE_WP;
9921 break;
9922 case hw_read:
9923 return Z_PACKET_READ_WP;
9924 break;
9925 case hw_access:
9926 return Z_PACKET_ACCESS_WP;
9927 break;
9928 default:
9929 internal_error (__FILE__, __LINE__,
9930 _("hw_bp_to_z: bad watchpoint type %d"), type);
9931 }
9932 }
9933
9934 static int
9935 remote_insert_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
9936 enum target_hw_bp_type type, struct expression *cond)
9937 {
9938 struct remote_state *rs = get_remote_state ();
9939 char *endbuf = rs->buf + get_remote_packet_size ();
9940 char *p;
9941 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
9942
9943 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
9944 return 1;
9945
9946 /* Make sure the remote is pointing at the right process, if
9947 necessary. */
9948 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9949 set_general_process ();
9950
9951 xsnprintf (rs->buf, endbuf - rs->buf, "Z%x,", packet);
9952 p = strchr (rs->buf, '\0');
9953 addr = remote_address_masked (addr);
9954 p += hexnumstr (p, (ULONGEST) addr);
9955 xsnprintf (p, endbuf - p, ",%x", len);
9956
9957 putpkt (rs->buf);
9958 getpkt (&rs->buf, &rs->buf_size, 0);
9959
9960 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
9961 {
9962 case PACKET_ERROR:
9963 return -1;
9964 case PACKET_UNKNOWN:
9965 return 1;
9966 case PACKET_OK:
9967 return 0;
9968 }
9969 internal_error (__FILE__, __LINE__,
9970 _("remote_insert_watchpoint: reached end of function"));
9971 }
9972
9973 static int
9974 remote_watchpoint_addr_within_range (struct target_ops *target, CORE_ADDR addr,
9975 CORE_ADDR start, int length)
9976 {
9977 CORE_ADDR diff = remote_address_masked (addr - start);
9978
9979 return diff < length;
9980 }
9981
9982
9983 static int
9984 remote_remove_watchpoint (struct target_ops *self, CORE_ADDR addr, int len,
9985 enum target_hw_bp_type type, struct expression *cond)
9986 {
9987 struct remote_state *rs = get_remote_state ();
9988 char *endbuf = rs->buf + get_remote_packet_size ();
9989 char *p;
9990 enum Z_packet_type packet = watchpoint_to_Z_packet (type);
9991
9992 if (packet_support (PACKET_Z0 + packet) == PACKET_DISABLE)
9993 return -1;
9994
9995 /* Make sure the remote is pointing at the right process, if
9996 necessary. */
9997 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9998 set_general_process ();
9999
10000 xsnprintf (rs->buf, endbuf - rs->buf, "z%x,", packet);
10001 p = strchr (rs->buf, '\0');
10002 addr = remote_address_masked (addr);
10003 p += hexnumstr (p, (ULONGEST) addr);
10004 xsnprintf (p, endbuf - p, ",%x", len);
10005 putpkt (rs->buf);
10006 getpkt (&rs->buf, &rs->buf_size, 0);
10007
10008 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z0 + packet]))
10009 {
10010 case PACKET_ERROR:
10011 case PACKET_UNKNOWN:
10012 return -1;
10013 case PACKET_OK:
10014 return 0;
10015 }
10016 internal_error (__FILE__, __LINE__,
10017 _("remote_remove_watchpoint: reached end of function"));
10018 }
10019
10020
10021 int remote_hw_watchpoint_limit = -1;
10022 int remote_hw_watchpoint_length_limit = -1;
10023 int remote_hw_breakpoint_limit = -1;
10024
10025 static int
10026 remote_region_ok_for_hw_watchpoint (struct target_ops *self,
10027 CORE_ADDR addr, int len)
10028 {
10029 if (remote_hw_watchpoint_length_limit == 0)
10030 return 0;
10031 else if (remote_hw_watchpoint_length_limit < 0)
10032 return 1;
10033 else if (len <= remote_hw_watchpoint_length_limit)
10034 return 1;
10035 else
10036 return 0;
10037 }
10038
10039 static int
10040 remote_check_watch_resources (struct target_ops *self,
10041 enum bptype type, int cnt, int ot)
10042 {
10043 if (type == bp_hardware_breakpoint)
10044 {
10045 if (remote_hw_breakpoint_limit == 0)
10046 return 0;
10047 else if (remote_hw_breakpoint_limit < 0)
10048 return 1;
10049 else if (cnt <= remote_hw_breakpoint_limit)
10050 return 1;
10051 }
10052 else
10053 {
10054 if (remote_hw_watchpoint_limit == 0)
10055 return 0;
10056 else if (remote_hw_watchpoint_limit < 0)
10057 return 1;
10058 else if (ot)
10059 return -1;
10060 else if (cnt <= remote_hw_watchpoint_limit)
10061 return 1;
10062 }
10063 return -1;
10064 }
10065
10066 /* The to_stopped_by_sw_breakpoint method of target remote. */
10067
10068 static int
10069 remote_stopped_by_sw_breakpoint (struct target_ops *ops)
10070 {
10071 struct thread_info *thread = inferior_thread ();
10072
10073 return (thread->priv != NULL
10074 && thread->priv->stop_reason == TARGET_STOPPED_BY_SW_BREAKPOINT);
10075 }
10076
10077 /* The to_supports_stopped_by_sw_breakpoint method of target
10078 remote. */
10079
10080 static int
10081 remote_supports_stopped_by_sw_breakpoint (struct target_ops *ops)
10082 {
10083 return (packet_support (PACKET_swbreak_feature) == PACKET_ENABLE);
10084 }
10085
10086 /* The to_stopped_by_hw_breakpoint method of target remote. */
10087
10088 static int
10089 remote_stopped_by_hw_breakpoint (struct target_ops *ops)
10090 {
10091 struct thread_info *thread = inferior_thread ();
10092
10093 return (thread->priv != NULL
10094 && thread->priv->stop_reason == TARGET_STOPPED_BY_HW_BREAKPOINT);
10095 }
10096
10097 /* The to_supports_stopped_by_hw_breakpoint method of target
10098 remote. */
10099
10100 static int
10101 remote_supports_stopped_by_hw_breakpoint (struct target_ops *ops)
10102 {
10103 return (packet_support (PACKET_hwbreak_feature) == PACKET_ENABLE);
10104 }
10105
10106 static int
10107 remote_stopped_by_watchpoint (struct target_ops *ops)
10108 {
10109 struct thread_info *thread = inferior_thread ();
10110
10111 return (thread->priv != NULL
10112 && thread->priv->stop_reason == TARGET_STOPPED_BY_WATCHPOINT);
10113 }
10114
10115 static int
10116 remote_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
10117 {
10118 struct thread_info *thread = inferior_thread ();
10119
10120 if (thread->priv != NULL
10121 && thread->priv->stop_reason == TARGET_STOPPED_BY_WATCHPOINT)
10122 {
10123 *addr_p = thread->priv->watch_data_address;
10124 return 1;
10125 }
10126
10127 return 0;
10128 }
10129
10130
10131 static int
10132 remote_insert_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
10133 struct bp_target_info *bp_tgt)
10134 {
10135 CORE_ADDR addr = bp_tgt->reqstd_address;
10136 struct remote_state *rs;
10137 char *p, *endbuf;
10138 char *message;
10139
10140 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10141 return -1;
10142
10143 /* Make sure the remote is pointing at the right process, if
10144 necessary. */
10145 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10146 set_general_process ();
10147
10148 rs = get_remote_state ();
10149 p = rs->buf;
10150 endbuf = rs->buf + get_remote_packet_size ();
10151
10152 *(p++) = 'Z';
10153 *(p++) = '1';
10154 *(p++) = ',';
10155
10156 addr = remote_address_masked (addr);
10157 p += hexnumstr (p, (ULONGEST) addr);
10158 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10159
10160 if (remote_supports_cond_breakpoints (self))
10161 remote_add_target_side_condition (gdbarch, bp_tgt, p, endbuf);
10162
10163 if (remote_can_run_breakpoint_commands (self))
10164 remote_add_target_side_commands (gdbarch, bp_tgt, p);
10165
10166 putpkt (rs->buf);
10167 getpkt (&rs->buf, &rs->buf_size, 0);
10168
10169 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10170 {
10171 case PACKET_ERROR:
10172 if (rs->buf[1] == '.')
10173 {
10174 message = strchr (rs->buf + 2, '.');
10175 if (message)
10176 error (_("Remote failure reply: %s"), message + 1);
10177 }
10178 return -1;
10179 case PACKET_UNKNOWN:
10180 return -1;
10181 case PACKET_OK:
10182 return 0;
10183 }
10184 internal_error (__FILE__, __LINE__,
10185 _("remote_insert_hw_breakpoint: reached end of function"));
10186 }
10187
10188
10189 static int
10190 remote_remove_hw_breakpoint (struct target_ops *self, struct gdbarch *gdbarch,
10191 struct bp_target_info *bp_tgt)
10192 {
10193 CORE_ADDR addr;
10194 struct remote_state *rs = get_remote_state ();
10195 char *p = rs->buf;
10196 char *endbuf = rs->buf + get_remote_packet_size ();
10197
10198 if (packet_support (PACKET_Z1) == PACKET_DISABLE)
10199 return -1;
10200
10201 /* Make sure the remote is pointing at the right process, if
10202 necessary. */
10203 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10204 set_general_process ();
10205
10206 *(p++) = 'z';
10207 *(p++) = '1';
10208 *(p++) = ',';
10209
10210 addr = remote_address_masked (bp_tgt->placed_address);
10211 p += hexnumstr (p, (ULONGEST) addr);
10212 xsnprintf (p, endbuf - p, ",%x", bp_tgt->kind);
10213
10214 putpkt (rs->buf);
10215 getpkt (&rs->buf, &rs->buf_size, 0);
10216
10217 switch (packet_ok (rs->buf, &remote_protocol_packets[PACKET_Z1]))
10218 {
10219 case PACKET_ERROR:
10220 case PACKET_UNKNOWN:
10221 return -1;
10222 case PACKET_OK:
10223 return 0;
10224 }
10225 internal_error (__FILE__, __LINE__,
10226 _("remote_remove_hw_breakpoint: reached end of function"));
10227 }
10228
10229 /* Verify memory using the "qCRC:" request. */
10230
10231 static int
10232 remote_verify_memory (struct target_ops *ops,
10233 const gdb_byte *data, CORE_ADDR lma, ULONGEST size)
10234 {
10235 struct remote_state *rs = get_remote_state ();
10236 unsigned long host_crc, target_crc;
10237 char *tmp;
10238
10239 /* It doesn't make sense to use qCRC if the remote target is
10240 connected but not running. */
10241 if (target_has_execution && packet_support (PACKET_qCRC) != PACKET_DISABLE)
10242 {
10243 enum packet_result result;
10244
10245 /* Make sure the remote is pointing at the right process. */
10246 set_general_process ();
10247
10248 /* FIXME: assumes lma can fit into long. */
10249 xsnprintf (rs->buf, get_remote_packet_size (), "qCRC:%lx,%lx",
10250 (long) lma, (long) size);
10251 putpkt (rs->buf);
10252
10253 /* Be clever; compute the host_crc before waiting for target
10254 reply. */
10255 host_crc = xcrc32 (data, size, 0xffffffff);
10256
10257 getpkt (&rs->buf, &rs->buf_size, 0);
10258
10259 result = packet_ok (rs->buf,
10260 &remote_protocol_packets[PACKET_qCRC]);
10261 if (result == PACKET_ERROR)
10262 return -1;
10263 else if (result == PACKET_OK)
10264 {
10265 for (target_crc = 0, tmp = &rs->buf[1]; *tmp; tmp++)
10266 target_crc = target_crc * 16 + fromhex (*tmp);
10267
10268 return (host_crc == target_crc);
10269 }
10270 }
10271
10272 return simple_verify_memory (ops, data, lma, size);
10273 }
10274
10275 /* compare-sections command
10276
10277 With no arguments, compares each loadable section in the exec bfd
10278 with the same memory range on the target, and reports mismatches.
10279 Useful for verifying the image on the target against the exec file. */
10280
10281 static void
10282 compare_sections_command (const char *args, int from_tty)
10283 {
10284 asection *s;
10285 gdb_byte *sectdata;
10286 const char *sectname;
10287 bfd_size_type size;
10288 bfd_vma lma;
10289 int matched = 0;
10290 int mismatched = 0;
10291 int res;
10292 int read_only = 0;
10293
10294 if (!exec_bfd)
10295 error (_("command cannot be used without an exec file"));
10296
10297 /* Make sure the remote is pointing at the right process. */
10298 set_general_process ();
10299
10300 if (args != NULL && strcmp (args, "-r") == 0)
10301 {
10302 read_only = 1;
10303 args = NULL;
10304 }
10305
10306 for (s = exec_bfd->sections; s; s = s->next)
10307 {
10308 if (!(s->flags & SEC_LOAD))
10309 continue; /* Skip non-loadable section. */
10310
10311 if (read_only && (s->flags & SEC_READONLY) == 0)
10312 continue; /* Skip writeable sections */
10313
10314 size = bfd_get_section_size (s);
10315 if (size == 0)
10316 continue; /* Skip zero-length section. */
10317
10318 sectname = bfd_get_section_name (exec_bfd, s);
10319 if (args && strcmp (args, sectname) != 0)
10320 continue; /* Not the section selected by user. */
10321
10322 matched = 1; /* Do this section. */
10323 lma = s->lma;
10324
10325 gdb::byte_vector sectdata (size);
10326 bfd_get_section_contents (exec_bfd, s, sectdata.data (), 0, size);
10327
10328 res = target_verify_memory (sectdata.data (), lma, size);
10329
10330 if (res == -1)
10331 error (_("target memory fault, section %s, range %s -- %s"), sectname,
10332 paddress (target_gdbarch (), lma),
10333 paddress (target_gdbarch (), lma + size));
10334
10335 printf_filtered ("Section %s, range %s -- %s: ", sectname,
10336 paddress (target_gdbarch (), lma),
10337 paddress (target_gdbarch (), lma + size));
10338 if (res)
10339 printf_filtered ("matched.\n");
10340 else
10341 {
10342 printf_filtered ("MIS-MATCHED!\n");
10343 mismatched++;
10344 }
10345 }
10346 if (mismatched > 0)
10347 warning (_("One or more sections of the target image does not match\n\
10348 the loaded file\n"));
10349 if (args && !matched)
10350 printf_filtered (_("No loaded section named '%s'.\n"), args);
10351 }
10352
10353 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10354 into remote target. The number of bytes written to the remote
10355 target is returned, or -1 for error. */
10356
10357 static enum target_xfer_status
10358 remote_write_qxfer (struct target_ops *ops, const char *object_name,
10359 const char *annex, const gdb_byte *writebuf,
10360 ULONGEST offset, LONGEST len, ULONGEST *xfered_len,
10361 struct packet_config *packet)
10362 {
10363 int i, buf_len;
10364 ULONGEST n;
10365 struct remote_state *rs = get_remote_state ();
10366 int max_size = get_memory_write_packet_size ();
10367
10368 if (packet->support == PACKET_DISABLE)
10369 return TARGET_XFER_E_IO;
10370
10371 /* Insert header. */
10372 i = snprintf (rs->buf, max_size,
10373 "qXfer:%s:write:%s:%s:",
10374 object_name, annex ? annex : "",
10375 phex_nz (offset, sizeof offset));
10376 max_size -= (i + 1);
10377
10378 /* Escape as much data as fits into rs->buf. */
10379 buf_len = remote_escape_output
10380 (writebuf, len, 1, (gdb_byte *) rs->buf + i, &max_size, max_size);
10381
10382 if (putpkt_binary (rs->buf, i + buf_len) < 0
10383 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
10384 || packet_ok (rs->buf, packet) != PACKET_OK)
10385 return TARGET_XFER_E_IO;
10386
10387 unpack_varlen_hex (rs->buf, &n);
10388
10389 *xfered_len = n;
10390 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
10391 }
10392
10393 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10394 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10395 number of bytes read is returned, or 0 for EOF, or -1 for error.
10396 The number of bytes read may be less than LEN without indicating an
10397 EOF. PACKET is checked and updated to indicate whether the remote
10398 target supports this object. */
10399
10400 static enum target_xfer_status
10401 remote_read_qxfer (struct target_ops *ops, const char *object_name,
10402 const char *annex,
10403 gdb_byte *readbuf, ULONGEST offset, LONGEST len,
10404 ULONGEST *xfered_len,
10405 struct packet_config *packet)
10406 {
10407 struct remote_state *rs = get_remote_state ();
10408 LONGEST i, n, packet_len;
10409
10410 if (packet->support == PACKET_DISABLE)
10411 return TARGET_XFER_E_IO;
10412
10413 /* Check whether we've cached an end-of-object packet that matches
10414 this request. */
10415 if (rs->finished_object)
10416 {
10417 if (strcmp (object_name, rs->finished_object) == 0
10418 && strcmp (annex ? annex : "", rs->finished_annex) == 0
10419 && offset == rs->finished_offset)
10420 return TARGET_XFER_EOF;
10421
10422
10423 /* Otherwise, we're now reading something different. Discard
10424 the cache. */
10425 xfree (rs->finished_object);
10426 xfree (rs->finished_annex);
10427 rs->finished_object = NULL;
10428 rs->finished_annex = NULL;
10429 }
10430
10431 /* Request only enough to fit in a single packet. The actual data
10432 may not, since we don't know how much of it will need to be escaped;
10433 the target is free to respond with slightly less data. We subtract
10434 five to account for the response type and the protocol frame. */
10435 n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
10436 snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10437 object_name, annex ? annex : "",
10438 phex_nz (offset, sizeof offset),
10439 phex_nz (n, sizeof n));
10440 i = putpkt (rs->buf);
10441 if (i < 0)
10442 return TARGET_XFER_E_IO;
10443
10444 rs->buf[0] = '\0';
10445 packet_len = getpkt_sane (&rs->buf, &rs->buf_size, 0);
10446 if (packet_len < 0 || packet_ok (rs->buf, packet) != PACKET_OK)
10447 return TARGET_XFER_E_IO;
10448
10449 if (rs->buf[0] != 'l' && rs->buf[0] != 'm')
10450 error (_("Unknown remote qXfer reply: %s"), rs->buf);
10451
10452 /* 'm' means there is (or at least might be) more data after this
10453 batch. That does not make sense unless there's at least one byte
10454 of data in this reply. */
10455 if (rs->buf[0] == 'm' && packet_len == 1)
10456 error (_("Remote qXfer reply contained no data."));
10457
10458 /* Got some data. */
10459 i = remote_unescape_input ((gdb_byte *) rs->buf + 1,
10460 packet_len - 1, readbuf, n);
10461
10462 /* 'l' is an EOF marker, possibly including a final block of data,
10463 or possibly empty. If we have the final block of a non-empty
10464 object, record this fact to bypass a subsequent partial read. */
10465 if (rs->buf[0] == 'l' && offset + i > 0)
10466 {
10467 rs->finished_object = xstrdup (object_name);
10468 rs->finished_annex = xstrdup (annex ? annex : "");
10469 rs->finished_offset = offset + i;
10470 }
10471
10472 if (i == 0)
10473 return TARGET_XFER_EOF;
10474 else
10475 {
10476 *xfered_len = i;
10477 return TARGET_XFER_OK;
10478 }
10479 }
10480
10481 static enum target_xfer_status
10482 remote_xfer_partial (struct target_ops *ops, enum target_object object,
10483 const char *annex, gdb_byte *readbuf,
10484 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
10485 ULONGEST *xfered_len)
10486 {
10487 struct remote_state *rs;
10488 int i;
10489 char *p2;
10490 char query_type;
10491 int unit_size = gdbarch_addressable_memory_unit_size (target_gdbarch ());
10492
10493 set_remote_traceframe ();
10494 set_general_thread (inferior_ptid);
10495
10496 rs = get_remote_state ();
10497
10498 /* Handle memory using the standard memory routines. */
10499 if (object == TARGET_OBJECT_MEMORY)
10500 {
10501 /* If the remote target is connected but not running, we should
10502 pass this request down to a lower stratum (e.g. the executable
10503 file). */
10504 if (!target_has_execution)
10505 return TARGET_XFER_EOF;
10506
10507 if (writebuf != NULL)
10508 return remote_write_bytes (offset, writebuf, len, unit_size,
10509 xfered_len);
10510 else
10511 return remote_read_bytes (ops, offset, readbuf, len, unit_size,
10512 xfered_len);
10513 }
10514
10515 /* Handle SPU memory using qxfer packets. */
10516 if (object == TARGET_OBJECT_SPU)
10517 {
10518 if (readbuf)
10519 return remote_read_qxfer (ops, "spu", annex, readbuf, offset, len,
10520 xfered_len, &remote_protocol_packets
10521 [PACKET_qXfer_spu_read]);
10522 else
10523 return remote_write_qxfer (ops, "spu", annex, writebuf, offset, len,
10524 xfered_len, &remote_protocol_packets
10525 [PACKET_qXfer_spu_write]);
10526 }
10527
10528 /* Handle extra signal info using qxfer packets. */
10529 if (object == TARGET_OBJECT_SIGNAL_INFO)
10530 {
10531 if (readbuf)
10532 return remote_read_qxfer (ops, "siginfo", annex, readbuf, offset, len,
10533 xfered_len, &remote_protocol_packets
10534 [PACKET_qXfer_siginfo_read]);
10535 else
10536 return remote_write_qxfer (ops, "siginfo", annex,
10537 writebuf, offset, len, xfered_len,
10538 &remote_protocol_packets
10539 [PACKET_qXfer_siginfo_write]);
10540 }
10541
10542 if (object == TARGET_OBJECT_STATIC_TRACE_DATA)
10543 {
10544 if (readbuf)
10545 return remote_read_qxfer (ops, "statictrace", annex,
10546 readbuf, offset, len, xfered_len,
10547 &remote_protocol_packets
10548 [PACKET_qXfer_statictrace_read]);
10549 else
10550 return TARGET_XFER_E_IO;
10551 }
10552
10553 /* Only handle flash writes. */
10554 if (writebuf != NULL)
10555 {
10556 switch (object)
10557 {
10558 case TARGET_OBJECT_FLASH:
10559 return remote_flash_write (ops, offset, len, xfered_len,
10560 writebuf);
10561
10562 default:
10563 return TARGET_XFER_E_IO;
10564 }
10565 }
10566
10567 /* Map pre-existing objects onto letters. DO NOT do this for new
10568 objects!!! Instead specify new query packets. */
10569 switch (object)
10570 {
10571 case TARGET_OBJECT_AVR:
10572 query_type = 'R';
10573 break;
10574
10575 case TARGET_OBJECT_AUXV:
10576 gdb_assert (annex == NULL);
10577 return remote_read_qxfer (ops, "auxv", annex, readbuf, offset, len,
10578 xfered_len,
10579 &remote_protocol_packets[PACKET_qXfer_auxv]);
10580
10581 case TARGET_OBJECT_AVAILABLE_FEATURES:
10582 return remote_read_qxfer
10583 (ops, "features", annex, readbuf, offset, len, xfered_len,
10584 &remote_protocol_packets[PACKET_qXfer_features]);
10585
10586 case TARGET_OBJECT_LIBRARIES:
10587 return remote_read_qxfer
10588 (ops, "libraries", annex, readbuf, offset, len, xfered_len,
10589 &remote_protocol_packets[PACKET_qXfer_libraries]);
10590
10591 case TARGET_OBJECT_LIBRARIES_SVR4:
10592 return remote_read_qxfer
10593 (ops, "libraries-svr4", annex, readbuf, offset, len, xfered_len,
10594 &remote_protocol_packets[PACKET_qXfer_libraries_svr4]);
10595
10596 case TARGET_OBJECT_MEMORY_MAP:
10597 gdb_assert (annex == NULL);
10598 return remote_read_qxfer (ops, "memory-map", annex, readbuf, offset, len,
10599 xfered_len,
10600 &remote_protocol_packets[PACKET_qXfer_memory_map]);
10601
10602 case TARGET_OBJECT_OSDATA:
10603 /* Should only get here if we're connected. */
10604 gdb_assert (rs->remote_desc);
10605 return remote_read_qxfer
10606 (ops, "osdata", annex, readbuf, offset, len, xfered_len,
10607 &remote_protocol_packets[PACKET_qXfer_osdata]);
10608
10609 case TARGET_OBJECT_THREADS:
10610 gdb_assert (annex == NULL);
10611 return remote_read_qxfer (ops, "threads", annex, readbuf, offset, len,
10612 xfered_len,
10613 &remote_protocol_packets[PACKET_qXfer_threads]);
10614
10615 case TARGET_OBJECT_TRACEFRAME_INFO:
10616 gdb_assert (annex == NULL);
10617 return remote_read_qxfer
10618 (ops, "traceframe-info", annex, readbuf, offset, len, xfered_len,
10619 &remote_protocol_packets[PACKET_qXfer_traceframe_info]);
10620
10621 case TARGET_OBJECT_FDPIC:
10622 return remote_read_qxfer (ops, "fdpic", annex, readbuf, offset, len,
10623 xfered_len,
10624 &remote_protocol_packets[PACKET_qXfer_fdpic]);
10625
10626 case TARGET_OBJECT_OPENVMS_UIB:
10627 return remote_read_qxfer (ops, "uib", annex, readbuf, offset, len,
10628 xfered_len,
10629 &remote_protocol_packets[PACKET_qXfer_uib]);
10630
10631 case TARGET_OBJECT_BTRACE:
10632 return remote_read_qxfer (ops, "btrace", annex, readbuf, offset, len,
10633 xfered_len,
10634 &remote_protocol_packets[PACKET_qXfer_btrace]);
10635
10636 case TARGET_OBJECT_BTRACE_CONF:
10637 return remote_read_qxfer (ops, "btrace-conf", annex, readbuf, offset,
10638 len, xfered_len,
10639 &remote_protocol_packets[PACKET_qXfer_btrace_conf]);
10640
10641 case TARGET_OBJECT_EXEC_FILE:
10642 return remote_read_qxfer (ops, "exec-file", annex, readbuf, offset,
10643 len, xfered_len,
10644 &remote_protocol_packets[PACKET_qXfer_exec_file]);
10645
10646 default:
10647 return TARGET_XFER_E_IO;
10648 }
10649
10650 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10651 large enough let the caller deal with it. */
10652 if (len < get_remote_packet_size ())
10653 return TARGET_XFER_E_IO;
10654 len = get_remote_packet_size ();
10655
10656 /* Except for querying the minimum buffer size, target must be open. */
10657 if (!rs->remote_desc)
10658 error (_("remote query is only available after target open"));
10659
10660 gdb_assert (annex != NULL);
10661 gdb_assert (readbuf != NULL);
10662
10663 p2 = rs->buf;
10664 *p2++ = 'q';
10665 *p2++ = query_type;
10666
10667 /* We used one buffer char for the remote protocol q command and
10668 another for the query type. As the remote protocol encapsulation
10669 uses 4 chars plus one extra in case we are debugging
10670 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10671 string. */
10672 i = 0;
10673 while (annex[i] && (i < (get_remote_packet_size () - 8)))
10674 {
10675 /* Bad caller may have sent forbidden characters. */
10676 gdb_assert (isprint (annex[i]) && annex[i] != '$' && annex[i] != '#');
10677 *p2++ = annex[i];
10678 i++;
10679 }
10680 *p2 = '\0';
10681 gdb_assert (annex[i] == '\0');
10682
10683 i = putpkt (rs->buf);
10684 if (i < 0)
10685 return TARGET_XFER_E_IO;
10686
10687 getpkt (&rs->buf, &rs->buf_size, 0);
10688 strcpy ((char *) readbuf, rs->buf);
10689
10690 *xfered_len = strlen ((char *) readbuf);
10691 return (*xfered_len != 0) ? TARGET_XFER_OK : TARGET_XFER_EOF;
10692 }
10693
10694 /* Implementation of to_get_memory_xfer_limit. */
10695
10696 static ULONGEST
10697 remote_get_memory_xfer_limit (struct target_ops *ops)
10698 {
10699 return get_memory_write_packet_size ();
10700 }
10701
10702 static int
10703 remote_search_memory (struct target_ops* ops,
10704 CORE_ADDR start_addr, ULONGEST search_space_len,
10705 const gdb_byte *pattern, ULONGEST pattern_len,
10706 CORE_ADDR *found_addrp)
10707 {
10708 int addr_size = gdbarch_addr_bit (target_gdbarch ()) / 8;
10709 struct remote_state *rs = get_remote_state ();
10710 int max_size = get_memory_write_packet_size ();
10711 struct packet_config *packet =
10712 &remote_protocol_packets[PACKET_qSearch_memory];
10713 /* Number of packet bytes used to encode the pattern;
10714 this could be more than PATTERN_LEN due to escape characters. */
10715 int escaped_pattern_len;
10716 /* Amount of pattern that was encodable in the packet. */
10717 int used_pattern_len;
10718 int i;
10719 int found;
10720 ULONGEST found_addr;
10721
10722 /* Don't go to the target if we don't have to.
10723 This is done before checking packet->support to avoid the possibility that
10724 a success for this edge case means the facility works in general. */
10725 if (pattern_len > search_space_len)
10726 return 0;
10727 if (pattern_len == 0)
10728 {
10729 *found_addrp = start_addr;
10730 return 1;
10731 }
10732
10733 /* If we already know the packet isn't supported, fall back to the simple
10734 way of searching memory. */
10735
10736 if (packet_config_support (packet) == PACKET_DISABLE)
10737 {
10738 /* Target doesn't provided special support, fall back and use the
10739 standard support (copy memory and do the search here). */
10740 return simple_search_memory (ops, start_addr, search_space_len,
10741 pattern, pattern_len, found_addrp);
10742 }
10743
10744 /* Make sure the remote is pointing at the right process. */
10745 set_general_process ();
10746
10747 /* Insert header. */
10748 i = snprintf (rs->buf, max_size,
10749 "qSearch:memory:%s;%s;",
10750 phex_nz (start_addr, addr_size),
10751 phex_nz (search_space_len, sizeof (search_space_len)));
10752 max_size -= (i + 1);
10753
10754 /* Escape as much data as fits into rs->buf. */
10755 escaped_pattern_len =
10756 remote_escape_output (pattern, pattern_len, 1, (gdb_byte *) rs->buf + i,
10757 &used_pattern_len, max_size);
10758
10759 /* Bail if the pattern is too large. */
10760 if (used_pattern_len != pattern_len)
10761 error (_("Pattern is too large to transmit to remote target."));
10762
10763 if (putpkt_binary (rs->buf, i + escaped_pattern_len) < 0
10764 || getpkt_sane (&rs->buf, &rs->buf_size, 0) < 0
10765 || packet_ok (rs->buf, packet) != PACKET_OK)
10766 {
10767 /* The request may not have worked because the command is not
10768 supported. If so, fall back to the simple way. */
10769 if (packet->support == PACKET_DISABLE)
10770 {
10771 return simple_search_memory (ops, start_addr, search_space_len,
10772 pattern, pattern_len, found_addrp);
10773 }
10774 return -1;
10775 }
10776
10777 if (rs->buf[0] == '0')
10778 found = 0;
10779 else if (rs->buf[0] == '1')
10780 {
10781 found = 1;
10782 if (rs->buf[1] != ',')
10783 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
10784 unpack_varlen_hex (rs->buf + 2, &found_addr);
10785 *found_addrp = found_addr;
10786 }
10787 else
10788 error (_("Unknown qSearch:memory reply: %s"), rs->buf);
10789
10790 return found;
10791 }
10792
10793 static void
10794 remote_rcmd (struct target_ops *self, const char *command,
10795 struct ui_file *outbuf)
10796 {
10797 struct remote_state *rs = get_remote_state ();
10798 char *p = rs->buf;
10799
10800 if (!rs->remote_desc)
10801 error (_("remote rcmd is only available after target open"));
10802
10803 /* Send a NULL command across as an empty command. */
10804 if (command == NULL)
10805 command = "";
10806
10807 /* The query prefix. */
10808 strcpy (rs->buf, "qRcmd,");
10809 p = strchr (rs->buf, '\0');
10810
10811 if ((strlen (rs->buf) + strlen (command) * 2 + 8/*misc*/)
10812 > get_remote_packet_size ())
10813 error (_("\"monitor\" command ``%s'' is too long."), command);
10814
10815 /* Encode the actual command. */
10816 bin2hex ((const gdb_byte *) command, p, strlen (command));
10817
10818 if (putpkt (rs->buf) < 0)
10819 error (_("Communication problem with target."));
10820
10821 /* get/display the response */
10822 while (1)
10823 {
10824 char *buf;
10825
10826 /* XXX - see also remote_get_noisy_reply(). */
10827 QUIT; /* Allow user to bail out with ^C. */
10828 rs->buf[0] = '\0';
10829 if (getpkt_sane (&rs->buf, &rs->buf_size, 0) == -1)
10830 {
10831 /* Timeout. Continue to (try to) read responses.
10832 This is better than stopping with an error, assuming the stub
10833 is still executing the (long) monitor command.
10834 If needed, the user can interrupt gdb using C-c, obtaining
10835 an effect similar to stop on timeout. */
10836 continue;
10837 }
10838 buf = rs->buf;
10839 if (buf[0] == '\0')
10840 error (_("Target does not support this command."));
10841 if (buf[0] == 'O' && buf[1] != 'K')
10842 {
10843 remote_console_output (buf + 1); /* 'O' message from stub. */
10844 continue;
10845 }
10846 if (strcmp (buf, "OK") == 0)
10847 break;
10848 if (strlen (buf) == 3 && buf[0] == 'E'
10849 && isdigit (buf[1]) && isdigit (buf[2]))
10850 {
10851 error (_("Protocol error with Rcmd"));
10852 }
10853 for (p = buf; p[0] != '\0' && p[1] != '\0'; p += 2)
10854 {
10855 char c = (fromhex (p[0]) << 4) + fromhex (p[1]);
10856
10857 fputc_unfiltered (c, outbuf);
10858 }
10859 break;
10860 }
10861 }
10862
10863 static std::vector<mem_region>
10864 remote_memory_map (struct target_ops *ops)
10865 {
10866 std::vector<mem_region> result;
10867 gdb::unique_xmalloc_ptr<char> text
10868 = target_read_stralloc (&current_target, TARGET_OBJECT_MEMORY_MAP, NULL);
10869
10870 if (text)
10871 result = parse_memory_map (text.get ());
10872
10873 return result;
10874 }
10875
10876 static void
10877 packet_command (const char *args, int from_tty)
10878 {
10879 struct remote_state *rs = get_remote_state ();
10880
10881 if (!rs->remote_desc)
10882 error (_("command can only be used with remote target"));
10883
10884 if (!args)
10885 error (_("remote-packet command requires packet text as argument"));
10886
10887 puts_filtered ("sending: ");
10888 print_packet (args);
10889 puts_filtered ("\n");
10890 putpkt (args);
10891
10892 getpkt (&rs->buf, &rs->buf_size, 0);
10893 puts_filtered ("received: ");
10894 print_packet (rs->buf);
10895 puts_filtered ("\n");
10896 }
10897
10898 #if 0
10899 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10900
10901 static void display_thread_info (struct gdb_ext_thread_info *info);
10902
10903 static void threadset_test_cmd (char *cmd, int tty);
10904
10905 static void threadalive_test (char *cmd, int tty);
10906
10907 static void threadlist_test_cmd (char *cmd, int tty);
10908
10909 int get_and_display_threadinfo (threadref *ref);
10910
10911 static void threadinfo_test_cmd (char *cmd, int tty);
10912
10913 static int thread_display_step (threadref *ref, void *context);
10914
10915 static void threadlist_update_test_cmd (char *cmd, int tty);
10916
10917 static void init_remote_threadtests (void);
10918
10919 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10920
10921 static void
10922 threadset_test_cmd (const char *cmd, int tty)
10923 {
10924 int sample_thread = SAMPLE_THREAD;
10925
10926 printf_filtered (_("Remote threadset test\n"));
10927 set_general_thread (sample_thread);
10928 }
10929
10930
10931 static void
10932 threadalive_test (const char *cmd, int tty)
10933 {
10934 int sample_thread = SAMPLE_THREAD;
10935 int pid = ptid_get_pid (inferior_ptid);
10936 ptid_t ptid = ptid_build (pid, sample_thread, 0);
10937
10938 if (remote_thread_alive (ptid))
10939 printf_filtered ("PASS: Thread alive test\n");
10940 else
10941 printf_filtered ("FAIL: Thread alive test\n");
10942 }
10943
10944 void output_threadid (char *title, threadref *ref);
10945
10946 void
10947 output_threadid (char *title, threadref *ref)
10948 {
10949 char hexid[20];
10950
10951 pack_threadid (&hexid[0], ref); /* Convert threead id into hex. */
10952 hexid[16] = 0;
10953 printf_filtered ("%s %s\n", title, (&hexid[0]));
10954 }
10955
10956 static void
10957 threadlist_test_cmd (const char *cmd, int tty)
10958 {
10959 int startflag = 1;
10960 threadref nextthread;
10961 int done, result_count;
10962 threadref threadlist[3];
10963
10964 printf_filtered ("Remote Threadlist test\n");
10965 if (!remote_get_threadlist (startflag, &nextthread, 3, &done,
10966 &result_count, &threadlist[0]))
10967 printf_filtered ("FAIL: threadlist test\n");
10968 else
10969 {
10970 threadref *scan = threadlist;
10971 threadref *limit = scan + result_count;
10972
10973 while (scan < limit)
10974 output_threadid (" thread ", scan++);
10975 }
10976 }
10977
10978 void
10979 display_thread_info (struct gdb_ext_thread_info *info)
10980 {
10981 output_threadid ("Threadid: ", &info->threadid);
10982 printf_filtered ("Name: %s\n ", info->shortname);
10983 printf_filtered ("State: %s\n", info->display);
10984 printf_filtered ("other: %s\n\n", info->more_display);
10985 }
10986
10987 int
10988 get_and_display_threadinfo (threadref *ref)
10989 {
10990 int result;
10991 int set;
10992 struct gdb_ext_thread_info threadinfo;
10993
10994 set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME
10995 | TAG_MOREDISPLAY | TAG_DISPLAY;
10996 if (0 != (result = remote_get_threadinfo (ref, set, &threadinfo)))
10997 display_thread_info (&threadinfo);
10998 return result;
10999 }
11000
11001 static void
11002 threadinfo_test_cmd (const char *cmd, int tty)
11003 {
11004 int athread = SAMPLE_THREAD;
11005 threadref thread;
11006 int set;
11007
11008 int_to_threadref (&thread, athread);
11009 printf_filtered ("Remote Threadinfo test\n");
11010 if (!get_and_display_threadinfo (&thread))
11011 printf_filtered ("FAIL cannot get thread info\n");
11012 }
11013
11014 static int
11015 thread_display_step (threadref *ref, void *context)
11016 {
11017 /* output_threadid(" threadstep ",ref); *//* simple test */
11018 return get_and_display_threadinfo (ref);
11019 }
11020
11021 static void
11022 threadlist_update_test_cmd (const char *cmd, int tty)
11023 {
11024 printf_filtered ("Remote Threadlist update test\n");
11025 remote_threadlist_iterator (thread_display_step, 0, CRAZY_MAX_THREADS);
11026 }
11027
11028 static void
11029 init_remote_threadtests (void)
11030 {
11031 add_com ("tlist", class_obscure, threadlist_test_cmd,
11032 _("Fetch and print the remote list of "
11033 "thread identifiers, one pkt only"));
11034 add_com ("tinfo", class_obscure, threadinfo_test_cmd,
11035 _("Fetch and display info about one thread"));
11036 add_com ("tset", class_obscure, threadset_test_cmd,
11037 _("Test setting to a different thread"));
11038 add_com ("tupd", class_obscure, threadlist_update_test_cmd,
11039 _("Iterate through updating all remote thread info"));
11040 add_com ("talive", class_obscure, threadalive_test,
11041 _(" Remote thread alive test "));
11042 }
11043
11044 #endif /* 0 */
11045
11046 /* Convert a thread ID to a string. Returns the string in a static
11047 buffer. */
11048
11049 static const char *
11050 remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
11051 {
11052 static char buf[64];
11053 struct remote_state *rs = get_remote_state ();
11054
11055 if (ptid_equal (ptid, null_ptid))
11056 return normal_pid_to_str (ptid);
11057 else if (ptid_is_pid (ptid))
11058 {
11059 /* Printing an inferior target id. */
11060
11061 /* When multi-process extensions are off, there's no way in the
11062 remote protocol to know the remote process id, if there's any
11063 at all. There's one exception --- when we're connected with
11064 target extended-remote, and we manually attached to a process
11065 with "attach PID". We don't record anywhere a flag that
11066 allows us to distinguish that case from the case of
11067 connecting with extended-remote and the stub already being
11068 attached to a process, and reporting yes to qAttached, hence
11069 no smart special casing here. */
11070 if (!remote_multi_process_p (rs))
11071 {
11072 xsnprintf (buf, sizeof buf, "Remote target");
11073 return buf;
11074 }
11075
11076 return normal_pid_to_str (ptid);
11077 }
11078 else
11079 {
11080 if (ptid_equal (magic_null_ptid, ptid))
11081 xsnprintf (buf, sizeof buf, "Thread <main>");
11082 else if (remote_multi_process_p (rs))
11083 if (ptid_get_lwp (ptid) == 0)
11084 return normal_pid_to_str (ptid);
11085 else
11086 xsnprintf (buf, sizeof buf, "Thread %d.%ld",
11087 ptid_get_pid (ptid), ptid_get_lwp (ptid));
11088 else
11089 xsnprintf (buf, sizeof buf, "Thread %ld",
11090 ptid_get_lwp (ptid));
11091 return buf;
11092 }
11093 }
11094
11095 /* Get the address of the thread local variable in OBJFILE which is
11096 stored at OFFSET within the thread local storage for thread PTID. */
11097
11098 static CORE_ADDR
11099 remote_get_thread_local_address (struct target_ops *ops,
11100 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
11101 {
11102 if (packet_support (PACKET_qGetTLSAddr) != PACKET_DISABLE)
11103 {
11104 struct remote_state *rs = get_remote_state ();
11105 char *p = rs->buf;
11106 char *endp = rs->buf + get_remote_packet_size ();
11107 enum packet_result result;
11108
11109 strcpy (p, "qGetTLSAddr:");
11110 p += strlen (p);
11111 p = write_ptid (p, endp, ptid);
11112 *p++ = ',';
11113 p += hexnumstr (p, offset);
11114 *p++ = ',';
11115 p += hexnumstr (p, lm);
11116 *p++ = '\0';
11117
11118 putpkt (rs->buf);
11119 getpkt (&rs->buf, &rs->buf_size, 0);
11120 result = packet_ok (rs->buf,
11121 &remote_protocol_packets[PACKET_qGetTLSAddr]);
11122 if (result == PACKET_OK)
11123 {
11124 ULONGEST result;
11125
11126 unpack_varlen_hex (rs->buf, &result);
11127 return result;
11128 }
11129 else if (result == PACKET_UNKNOWN)
11130 throw_error (TLS_GENERIC_ERROR,
11131 _("Remote target doesn't support qGetTLSAddr packet"));
11132 else
11133 throw_error (TLS_GENERIC_ERROR,
11134 _("Remote target failed to process qGetTLSAddr request"));
11135 }
11136 else
11137 throw_error (TLS_GENERIC_ERROR,
11138 _("TLS not supported or disabled on this target"));
11139 /* Not reached. */
11140 return 0;
11141 }
11142
11143 /* Provide thread local base, i.e. Thread Information Block address.
11144 Returns 1 if ptid is found and thread_local_base is non zero. */
11145
11146 static int
11147 remote_get_tib_address (struct target_ops *self, ptid_t ptid, CORE_ADDR *addr)
11148 {
11149 if (packet_support (PACKET_qGetTIBAddr) != PACKET_DISABLE)
11150 {
11151 struct remote_state *rs = get_remote_state ();
11152 char *p = rs->buf;
11153 char *endp = rs->buf + get_remote_packet_size ();
11154 enum packet_result result;
11155
11156 strcpy (p, "qGetTIBAddr:");
11157 p += strlen (p);
11158 p = write_ptid (p, endp, ptid);
11159 *p++ = '\0';
11160
11161 putpkt (rs->buf);
11162 getpkt (&rs->buf, &rs->buf_size, 0);
11163 result = packet_ok (rs->buf,
11164 &remote_protocol_packets[PACKET_qGetTIBAddr]);
11165 if (result == PACKET_OK)
11166 {
11167 ULONGEST result;
11168
11169 unpack_varlen_hex (rs->buf, &result);
11170 if (addr)
11171 *addr = (CORE_ADDR) result;
11172 return 1;
11173 }
11174 else if (result == PACKET_UNKNOWN)
11175 error (_("Remote target doesn't support qGetTIBAddr packet"));
11176 else
11177 error (_("Remote target failed to process qGetTIBAddr request"));
11178 }
11179 else
11180 error (_("qGetTIBAddr not supported or disabled on this target"));
11181 /* Not reached. */
11182 return 0;
11183 }
11184
11185 /* Support for inferring a target description based on the current
11186 architecture and the size of a 'g' packet. While the 'g' packet
11187 can have any size (since optional registers can be left off the
11188 end), some sizes are easily recognizable given knowledge of the
11189 approximate architecture. */
11190
11191 struct remote_g_packet_guess
11192 {
11193 int bytes;
11194 const struct target_desc *tdesc;
11195 };
11196 typedef struct remote_g_packet_guess remote_g_packet_guess_s;
11197 DEF_VEC_O(remote_g_packet_guess_s);
11198
11199 struct remote_g_packet_data
11200 {
11201 VEC(remote_g_packet_guess_s) *guesses;
11202 };
11203
11204 static struct gdbarch_data *remote_g_packet_data_handle;
11205
11206 static void *
11207 remote_g_packet_data_init (struct obstack *obstack)
11208 {
11209 return OBSTACK_ZALLOC (obstack, struct remote_g_packet_data);
11210 }
11211
11212 void
11213 register_remote_g_packet_guess (struct gdbarch *gdbarch, int bytes,
11214 const struct target_desc *tdesc)
11215 {
11216 struct remote_g_packet_data *data
11217 = ((struct remote_g_packet_data *)
11218 gdbarch_data (gdbarch, remote_g_packet_data_handle));
11219 struct remote_g_packet_guess new_guess, *guess;
11220 int ix;
11221
11222 gdb_assert (tdesc != NULL);
11223
11224 for (ix = 0;
11225 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
11226 ix++)
11227 if (guess->bytes == bytes)
11228 internal_error (__FILE__, __LINE__,
11229 _("Duplicate g packet description added for size %d"),
11230 bytes);
11231
11232 new_guess.bytes = bytes;
11233 new_guess.tdesc = tdesc;
11234 VEC_safe_push (remote_g_packet_guess_s, data->guesses, &new_guess);
11235 }
11236
11237 /* Return 1 if remote_read_description would do anything on this target
11238 and architecture, 0 otherwise. */
11239
11240 static int
11241 remote_read_description_p (struct target_ops *target)
11242 {
11243 struct remote_g_packet_data *data
11244 = ((struct remote_g_packet_data *)
11245 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11246
11247 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
11248 return 1;
11249
11250 return 0;
11251 }
11252
11253 static const struct target_desc *
11254 remote_read_description (struct target_ops *target)
11255 {
11256 struct remote_g_packet_data *data
11257 = ((struct remote_g_packet_data *)
11258 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle));
11259
11260 /* Do not try this during initial connection, when we do not know
11261 whether there is a running but stopped thread. */
11262 if (!target_has_execution || ptid_equal (inferior_ptid, null_ptid))
11263 return target->beneath->to_read_description (target->beneath);
11264
11265 if (!VEC_empty (remote_g_packet_guess_s, data->guesses))
11266 {
11267 struct remote_g_packet_guess *guess;
11268 int ix;
11269 int bytes = send_g_packet ();
11270
11271 for (ix = 0;
11272 VEC_iterate (remote_g_packet_guess_s, data->guesses, ix, guess);
11273 ix++)
11274 if (guess->bytes == bytes)
11275 return guess->tdesc;
11276
11277 /* We discard the g packet. A minor optimization would be to
11278 hold on to it, and fill the register cache once we have selected
11279 an architecture, but it's too tricky to do safely. */
11280 }
11281
11282 return target->beneath->to_read_description (target->beneath);
11283 }
11284
11285 /* Remote file transfer support. This is host-initiated I/O, not
11286 target-initiated; for target-initiated, see remote-fileio.c. */
11287
11288 /* If *LEFT is at least the length of STRING, copy STRING to
11289 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11290 decrease *LEFT. Otherwise raise an error. */
11291
11292 static void
11293 remote_buffer_add_string (char **buffer, int *left, const char *string)
11294 {
11295 int len = strlen (string);
11296
11297 if (len > *left)
11298 error (_("Packet too long for target."));
11299
11300 memcpy (*buffer, string, len);
11301 *buffer += len;
11302 *left -= len;
11303
11304 /* NUL-terminate the buffer as a convenience, if there is
11305 room. */
11306 if (*left)
11307 **buffer = '\0';
11308 }
11309
11310 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11311 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11312 decrease *LEFT. Otherwise raise an error. */
11313
11314 static void
11315 remote_buffer_add_bytes (char **buffer, int *left, const gdb_byte *bytes,
11316 int len)
11317 {
11318 if (2 * len > *left)
11319 error (_("Packet too long for target."));
11320
11321 bin2hex (bytes, *buffer, len);
11322 *buffer += 2 * len;
11323 *left -= 2 * len;
11324
11325 /* NUL-terminate the buffer as a convenience, if there is
11326 room. */
11327 if (*left)
11328 **buffer = '\0';
11329 }
11330
11331 /* If *LEFT is large enough, convert VALUE to hex and add it to
11332 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11333 decrease *LEFT. Otherwise raise an error. */
11334
11335 static void
11336 remote_buffer_add_int (char **buffer, int *left, ULONGEST value)
11337 {
11338 int len = hexnumlen (value);
11339
11340 if (len > *left)
11341 error (_("Packet too long for target."));
11342
11343 hexnumstr (*buffer, value);
11344 *buffer += len;
11345 *left -= len;
11346
11347 /* NUL-terminate the buffer as a convenience, if there is
11348 room. */
11349 if (*left)
11350 **buffer = '\0';
11351 }
11352
11353 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11354 value, *REMOTE_ERRNO to the remote error number or zero if none
11355 was included, and *ATTACHMENT to point to the start of the annex
11356 if any. The length of the packet isn't needed here; there may
11357 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11358
11359 Return 0 if the packet could be parsed, -1 if it could not. If
11360 -1 is returned, the other variables may not be initialized. */
11361
11362 static int
11363 remote_hostio_parse_result (char *buffer, int *retcode,
11364 int *remote_errno, char **attachment)
11365 {
11366 char *p, *p2;
11367
11368 *remote_errno = 0;
11369 *attachment = NULL;
11370
11371 if (buffer[0] != 'F')
11372 return -1;
11373
11374 errno = 0;
11375 *retcode = strtol (&buffer[1], &p, 16);
11376 if (errno != 0 || p == &buffer[1])
11377 return -1;
11378
11379 /* Check for ",errno". */
11380 if (*p == ',')
11381 {
11382 errno = 0;
11383 *remote_errno = strtol (p + 1, &p2, 16);
11384 if (errno != 0 || p + 1 == p2)
11385 return -1;
11386 p = p2;
11387 }
11388
11389 /* Check for ";attachment". If there is no attachment, the
11390 packet should end here. */
11391 if (*p == ';')
11392 {
11393 *attachment = p + 1;
11394 return 0;
11395 }
11396 else if (*p == '\0')
11397 return 0;
11398 else
11399 return -1;
11400 }
11401
11402 /* Send a prepared I/O packet to the target and read its response.
11403 The prepared packet is in the global RS->BUF before this function
11404 is called, and the answer is there when we return.
11405
11406 COMMAND_BYTES is the length of the request to send, which may include
11407 binary data. WHICH_PACKET is the packet configuration to check
11408 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11409 is set to the error number and -1 is returned. Otherwise the value
11410 returned by the function is returned.
11411
11412 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11413 attachment is expected; an error will be reported if there's a
11414 mismatch. If one is found, *ATTACHMENT will be set to point into
11415 the packet buffer and *ATTACHMENT_LEN will be set to the
11416 attachment's length. */
11417
11418 static int
11419 remote_hostio_send_command (int command_bytes, int which_packet,
11420 int *remote_errno, char **attachment,
11421 int *attachment_len)
11422 {
11423 struct remote_state *rs = get_remote_state ();
11424 int ret, bytes_read;
11425 char *attachment_tmp;
11426
11427 if (!rs->remote_desc
11428 || packet_support (which_packet) == PACKET_DISABLE)
11429 {
11430 *remote_errno = FILEIO_ENOSYS;
11431 return -1;
11432 }
11433
11434 putpkt_binary (rs->buf, command_bytes);
11435 bytes_read = getpkt_sane (&rs->buf, &rs->buf_size, 0);
11436
11437 /* If it timed out, something is wrong. Don't try to parse the
11438 buffer. */
11439 if (bytes_read < 0)
11440 {
11441 *remote_errno = FILEIO_EINVAL;
11442 return -1;
11443 }
11444
11445 switch (packet_ok (rs->buf, &remote_protocol_packets[which_packet]))
11446 {
11447 case PACKET_ERROR:
11448 *remote_errno = FILEIO_EINVAL;
11449 return -1;
11450 case PACKET_UNKNOWN:
11451 *remote_errno = FILEIO_ENOSYS;
11452 return -1;
11453 case PACKET_OK:
11454 break;
11455 }
11456
11457 if (remote_hostio_parse_result (rs->buf, &ret, remote_errno,
11458 &attachment_tmp))
11459 {
11460 *remote_errno = FILEIO_EINVAL;
11461 return -1;
11462 }
11463
11464 /* Make sure we saw an attachment if and only if we expected one. */
11465 if ((attachment_tmp == NULL && attachment != NULL)
11466 || (attachment_tmp != NULL && attachment == NULL))
11467 {
11468 *remote_errno = FILEIO_EINVAL;
11469 return -1;
11470 }
11471
11472 /* If an attachment was found, it must point into the packet buffer;
11473 work out how many bytes there were. */
11474 if (attachment_tmp != NULL)
11475 {
11476 *attachment = attachment_tmp;
11477 *attachment_len = bytes_read - (*attachment - rs->buf);
11478 }
11479
11480 return ret;
11481 }
11482
11483 /* Invalidate the readahead cache. */
11484
11485 static void
11486 readahead_cache_invalidate (void)
11487 {
11488 struct remote_state *rs = get_remote_state ();
11489
11490 rs->readahead_cache.fd = -1;
11491 }
11492
11493 /* Invalidate the readahead cache if it is holding data for FD. */
11494
11495 static void
11496 readahead_cache_invalidate_fd (int fd)
11497 {
11498 struct remote_state *rs = get_remote_state ();
11499
11500 if (rs->readahead_cache.fd == fd)
11501 rs->readahead_cache.fd = -1;
11502 }
11503
11504 /* Set the filesystem remote_hostio functions that take FILENAME
11505 arguments will use. Return 0 on success, or -1 if an error
11506 occurs (and set *REMOTE_ERRNO). */
11507
11508 static int
11509 remote_hostio_set_filesystem (struct inferior *inf, int *remote_errno)
11510 {
11511 struct remote_state *rs = get_remote_state ();
11512 int required_pid = (inf == NULL || inf->fake_pid_p) ? 0 : inf->pid;
11513 char *p = rs->buf;
11514 int left = get_remote_packet_size () - 1;
11515 char arg[9];
11516 int ret;
11517
11518 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11519 return 0;
11520
11521 if (rs->fs_pid != -1 && required_pid == rs->fs_pid)
11522 return 0;
11523
11524 remote_buffer_add_string (&p, &left, "vFile:setfs:");
11525
11526 xsnprintf (arg, sizeof (arg), "%x", required_pid);
11527 remote_buffer_add_string (&p, &left, arg);
11528
11529 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_setfs,
11530 remote_errno, NULL, NULL);
11531
11532 if (packet_support (PACKET_vFile_setfs) == PACKET_DISABLE)
11533 return 0;
11534
11535 if (ret == 0)
11536 rs->fs_pid = required_pid;
11537
11538 return ret;
11539 }
11540
11541 /* Implementation of to_fileio_open. */
11542
11543 static int
11544 remote_hostio_open (struct target_ops *self,
11545 struct inferior *inf, const char *filename,
11546 int flags, int mode, int warn_if_slow,
11547 int *remote_errno)
11548 {
11549 struct remote_state *rs = get_remote_state ();
11550 char *p = rs->buf;
11551 int left = get_remote_packet_size () - 1;
11552
11553 if (warn_if_slow)
11554 {
11555 static int warning_issued = 0;
11556
11557 printf_unfiltered (_("Reading %s from remote target...\n"),
11558 filename);
11559
11560 if (!warning_issued)
11561 {
11562 warning (_("File transfers from remote targets can be slow."
11563 " Use \"set sysroot\" to access files locally"
11564 " instead."));
11565 warning_issued = 1;
11566 }
11567 }
11568
11569 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11570 return -1;
11571
11572 remote_buffer_add_string (&p, &left, "vFile:open:");
11573
11574 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11575 strlen (filename));
11576 remote_buffer_add_string (&p, &left, ",");
11577
11578 remote_buffer_add_int (&p, &left, flags);
11579 remote_buffer_add_string (&p, &left, ",");
11580
11581 remote_buffer_add_int (&p, &left, mode);
11582
11583 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_open,
11584 remote_errno, NULL, NULL);
11585 }
11586
11587 /* Implementation of to_fileio_pwrite. */
11588
11589 static int
11590 remote_hostio_pwrite (struct target_ops *self,
11591 int fd, const gdb_byte *write_buf, int len,
11592 ULONGEST offset, int *remote_errno)
11593 {
11594 struct remote_state *rs = get_remote_state ();
11595 char *p = rs->buf;
11596 int left = get_remote_packet_size ();
11597 int out_len;
11598
11599 readahead_cache_invalidate_fd (fd);
11600
11601 remote_buffer_add_string (&p, &left, "vFile:pwrite:");
11602
11603 remote_buffer_add_int (&p, &left, fd);
11604 remote_buffer_add_string (&p, &left, ",");
11605
11606 remote_buffer_add_int (&p, &left, offset);
11607 remote_buffer_add_string (&p, &left, ",");
11608
11609 p += remote_escape_output (write_buf, len, 1, (gdb_byte *) p, &out_len,
11610 get_remote_packet_size () - (p - rs->buf));
11611
11612 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_pwrite,
11613 remote_errno, NULL, NULL);
11614 }
11615
11616 /* Helper for the implementation of to_fileio_pread. Read the file
11617 from the remote side with vFile:pread. */
11618
11619 static int
11620 remote_hostio_pread_vFile (struct target_ops *self,
11621 int fd, gdb_byte *read_buf, int len,
11622 ULONGEST offset, int *remote_errno)
11623 {
11624 struct remote_state *rs = get_remote_state ();
11625 char *p = rs->buf;
11626 char *attachment;
11627 int left = get_remote_packet_size ();
11628 int ret, attachment_len;
11629 int read_len;
11630
11631 remote_buffer_add_string (&p, &left, "vFile:pread:");
11632
11633 remote_buffer_add_int (&p, &left, fd);
11634 remote_buffer_add_string (&p, &left, ",");
11635
11636 remote_buffer_add_int (&p, &left, len);
11637 remote_buffer_add_string (&p, &left, ",");
11638
11639 remote_buffer_add_int (&p, &left, offset);
11640
11641 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_pread,
11642 remote_errno, &attachment,
11643 &attachment_len);
11644
11645 if (ret < 0)
11646 return ret;
11647
11648 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
11649 read_buf, len);
11650 if (read_len != ret)
11651 error (_("Read returned %d, but %d bytes."), ret, (int) read_len);
11652
11653 return ret;
11654 }
11655
11656 /* Serve pread from the readahead cache. Returns number of bytes
11657 read, or 0 if the request can't be served from the cache. */
11658
11659 static int
11660 remote_hostio_pread_from_cache (struct remote_state *rs,
11661 int fd, gdb_byte *read_buf, size_t len,
11662 ULONGEST offset)
11663 {
11664 struct readahead_cache *cache = &rs->readahead_cache;
11665
11666 if (cache->fd == fd
11667 && cache->offset <= offset
11668 && offset < cache->offset + cache->bufsize)
11669 {
11670 ULONGEST max = cache->offset + cache->bufsize;
11671
11672 if (offset + len > max)
11673 len = max - offset;
11674
11675 memcpy (read_buf, cache->buf + offset - cache->offset, len);
11676 return len;
11677 }
11678
11679 return 0;
11680 }
11681
11682 /* Implementation of to_fileio_pread. */
11683
11684 static int
11685 remote_hostio_pread (struct target_ops *self,
11686 int fd, gdb_byte *read_buf, int len,
11687 ULONGEST offset, int *remote_errno)
11688 {
11689 int ret;
11690 struct remote_state *rs = get_remote_state ();
11691 struct readahead_cache *cache = &rs->readahead_cache;
11692
11693 ret = remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset);
11694 if (ret > 0)
11695 {
11696 cache->hit_count++;
11697
11698 if (remote_debug)
11699 fprintf_unfiltered (gdb_stdlog, "readahead cache hit %s\n",
11700 pulongest (cache->hit_count));
11701 return ret;
11702 }
11703
11704 cache->miss_count++;
11705 if (remote_debug)
11706 fprintf_unfiltered (gdb_stdlog, "readahead cache miss %s\n",
11707 pulongest (cache->miss_count));
11708
11709 cache->fd = fd;
11710 cache->offset = offset;
11711 cache->bufsize = get_remote_packet_size ();
11712 cache->buf = (gdb_byte *) xrealloc (cache->buf, cache->bufsize);
11713
11714 ret = remote_hostio_pread_vFile (self, cache->fd, cache->buf, cache->bufsize,
11715 cache->offset, remote_errno);
11716 if (ret <= 0)
11717 {
11718 readahead_cache_invalidate_fd (fd);
11719 return ret;
11720 }
11721
11722 cache->bufsize = ret;
11723 return remote_hostio_pread_from_cache (rs, fd, read_buf, len, offset);
11724 }
11725
11726 /* Implementation of to_fileio_close. */
11727
11728 static int
11729 remote_hostio_close (struct target_ops *self, int fd, int *remote_errno)
11730 {
11731 struct remote_state *rs = get_remote_state ();
11732 char *p = rs->buf;
11733 int left = get_remote_packet_size () - 1;
11734
11735 readahead_cache_invalidate_fd (fd);
11736
11737 remote_buffer_add_string (&p, &left, "vFile:close:");
11738
11739 remote_buffer_add_int (&p, &left, fd);
11740
11741 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_close,
11742 remote_errno, NULL, NULL);
11743 }
11744
11745 /* Implementation of to_fileio_unlink. */
11746
11747 static int
11748 remote_hostio_unlink (struct target_ops *self,
11749 struct inferior *inf, const char *filename,
11750 int *remote_errno)
11751 {
11752 struct remote_state *rs = get_remote_state ();
11753 char *p = rs->buf;
11754 int left = get_remote_packet_size () - 1;
11755
11756 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11757 return -1;
11758
11759 remote_buffer_add_string (&p, &left, "vFile:unlink:");
11760
11761 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11762 strlen (filename));
11763
11764 return remote_hostio_send_command (p - rs->buf, PACKET_vFile_unlink,
11765 remote_errno, NULL, NULL);
11766 }
11767
11768 /* Implementation of to_fileio_readlink. */
11769
11770 static char *
11771 remote_hostio_readlink (struct target_ops *self,
11772 struct inferior *inf, const char *filename,
11773 int *remote_errno)
11774 {
11775 struct remote_state *rs = get_remote_state ();
11776 char *p = rs->buf;
11777 char *attachment;
11778 int left = get_remote_packet_size ();
11779 int len, attachment_len;
11780 int read_len;
11781 char *ret;
11782
11783 if (remote_hostio_set_filesystem (inf, remote_errno) != 0)
11784 return NULL;
11785
11786 remote_buffer_add_string (&p, &left, "vFile:readlink:");
11787
11788 remote_buffer_add_bytes (&p, &left, (const gdb_byte *) filename,
11789 strlen (filename));
11790
11791 len = remote_hostio_send_command (p - rs->buf, PACKET_vFile_readlink,
11792 remote_errno, &attachment,
11793 &attachment_len);
11794
11795 if (len < 0)
11796 return NULL;
11797
11798 ret = (char *) xmalloc (len + 1);
11799
11800 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
11801 (gdb_byte *) ret, len);
11802 if (read_len != len)
11803 error (_("Readlink returned %d, but %d bytes."), len, read_len);
11804
11805 ret[len] = '\0';
11806 return ret;
11807 }
11808
11809 /* Implementation of to_fileio_fstat. */
11810
11811 static int
11812 remote_hostio_fstat (struct target_ops *self,
11813 int fd, struct stat *st,
11814 int *remote_errno)
11815 {
11816 struct remote_state *rs = get_remote_state ();
11817 char *p = rs->buf;
11818 int left = get_remote_packet_size ();
11819 int attachment_len, ret;
11820 char *attachment;
11821 struct fio_stat fst;
11822 int read_len;
11823
11824 remote_buffer_add_string (&p, &left, "vFile:fstat:");
11825
11826 remote_buffer_add_int (&p, &left, fd);
11827
11828 ret = remote_hostio_send_command (p - rs->buf, PACKET_vFile_fstat,
11829 remote_errno, &attachment,
11830 &attachment_len);
11831 if (ret < 0)
11832 {
11833 if (*remote_errno != FILEIO_ENOSYS)
11834 return ret;
11835
11836 /* Strictly we should return -1, ENOSYS here, but when
11837 "set sysroot remote:" was implemented in August 2008
11838 BFD's need for a stat function was sidestepped with
11839 this hack. This was not remedied until March 2015
11840 so we retain the previous behavior to avoid breaking
11841 compatibility.
11842
11843 Note that the memset is a March 2015 addition; older
11844 GDBs set st_size *and nothing else* so the structure
11845 would have garbage in all other fields. This might
11846 break something but retaining the previous behavior
11847 here would be just too wrong. */
11848
11849 memset (st, 0, sizeof (struct stat));
11850 st->st_size = INT_MAX;
11851 return 0;
11852 }
11853
11854 read_len = remote_unescape_input ((gdb_byte *) attachment, attachment_len,
11855 (gdb_byte *) &fst, sizeof (fst));
11856
11857 if (read_len != ret)
11858 error (_("vFile:fstat returned %d, but %d bytes."), ret, read_len);
11859
11860 if (read_len != sizeof (fst))
11861 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11862 read_len, (int) sizeof (fst));
11863
11864 remote_fileio_to_host_stat (&fst, st);
11865
11866 return 0;
11867 }
11868
11869 /* Implementation of to_filesystem_is_local. */
11870
11871 static int
11872 remote_filesystem_is_local (struct target_ops *self)
11873 {
11874 /* Valgrind GDB presents itself as a remote target but works
11875 on the local filesystem: it does not implement remote get
11876 and users are not expected to set a sysroot. To handle
11877 this case we treat the remote filesystem as local if the
11878 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11879 does not support vFile:open. */
11880 if (strcmp (gdb_sysroot, TARGET_SYSROOT_PREFIX) == 0)
11881 {
11882 enum packet_support ps = packet_support (PACKET_vFile_open);
11883
11884 if (ps == PACKET_SUPPORT_UNKNOWN)
11885 {
11886 int fd, remote_errno;
11887
11888 /* Try opening a file to probe support. The supplied
11889 filename is irrelevant, we only care about whether
11890 the stub recognizes the packet or not. */
11891 fd = remote_hostio_open (self, NULL, "just probing",
11892 FILEIO_O_RDONLY, 0700, 0,
11893 &remote_errno);
11894
11895 if (fd >= 0)
11896 remote_hostio_close (self, fd, &remote_errno);
11897
11898 ps = packet_support (PACKET_vFile_open);
11899 }
11900
11901 if (ps == PACKET_DISABLE)
11902 {
11903 static int warning_issued = 0;
11904
11905 if (!warning_issued)
11906 {
11907 warning (_("remote target does not support file"
11908 " transfer, attempting to access files"
11909 " from local filesystem."));
11910 warning_issued = 1;
11911 }
11912
11913 return 1;
11914 }
11915 }
11916
11917 return 0;
11918 }
11919
11920 static int
11921 remote_fileio_errno_to_host (int errnum)
11922 {
11923 switch (errnum)
11924 {
11925 case FILEIO_EPERM:
11926 return EPERM;
11927 case FILEIO_ENOENT:
11928 return ENOENT;
11929 case FILEIO_EINTR:
11930 return EINTR;
11931 case FILEIO_EIO:
11932 return EIO;
11933 case FILEIO_EBADF:
11934 return EBADF;
11935 case FILEIO_EACCES:
11936 return EACCES;
11937 case FILEIO_EFAULT:
11938 return EFAULT;
11939 case FILEIO_EBUSY:
11940 return EBUSY;
11941 case FILEIO_EEXIST:
11942 return EEXIST;
11943 case FILEIO_ENODEV:
11944 return ENODEV;
11945 case FILEIO_ENOTDIR:
11946 return ENOTDIR;
11947 case FILEIO_EISDIR:
11948 return EISDIR;
11949 case FILEIO_EINVAL:
11950 return EINVAL;
11951 case FILEIO_ENFILE:
11952 return ENFILE;
11953 case FILEIO_EMFILE:
11954 return EMFILE;
11955 case FILEIO_EFBIG:
11956 return EFBIG;
11957 case FILEIO_ENOSPC:
11958 return ENOSPC;
11959 case FILEIO_ESPIPE:
11960 return ESPIPE;
11961 case FILEIO_EROFS:
11962 return EROFS;
11963 case FILEIO_ENOSYS:
11964 return ENOSYS;
11965 case FILEIO_ENAMETOOLONG:
11966 return ENAMETOOLONG;
11967 }
11968 return -1;
11969 }
11970
11971 static char *
11972 remote_hostio_error (int errnum)
11973 {
11974 int host_error = remote_fileio_errno_to_host (errnum);
11975
11976 if (host_error == -1)
11977 error (_("Unknown remote I/O error %d"), errnum);
11978 else
11979 error (_("Remote I/O error: %s"), safe_strerror (host_error));
11980 }
11981
11982 static void
11983 remote_hostio_close_cleanup (void *opaque)
11984 {
11985 int fd = *(int *) opaque;
11986 int remote_errno;
11987
11988 remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno);
11989 }
11990
11991 void
11992 remote_file_put (const char *local_file, const char *remote_file, int from_tty)
11993 {
11994 struct cleanup *back_to, *close_cleanup;
11995 int retcode, fd, remote_errno, bytes, io_size;
11996 gdb_byte *buffer;
11997 int bytes_in_buffer;
11998 int saw_eof;
11999 ULONGEST offset;
12000 struct remote_state *rs = get_remote_state ();
12001
12002 if (!rs->remote_desc)
12003 error (_("command can only be used with remote target"));
12004
12005 gdb_file_up file = gdb_fopen_cloexec (local_file, "rb");
12006 if (file == NULL)
12007 perror_with_name (local_file);
12008
12009 fd = remote_hostio_open (find_target_at (process_stratum), NULL,
12010 remote_file, (FILEIO_O_WRONLY | FILEIO_O_CREAT
12011 | FILEIO_O_TRUNC),
12012 0700, 0, &remote_errno);
12013 if (fd == -1)
12014 remote_hostio_error (remote_errno);
12015
12016 /* Send up to this many bytes at once. They won't all fit in the
12017 remote packet limit, so we'll transfer slightly fewer. */
12018 io_size = get_remote_packet_size ();
12019 buffer = (gdb_byte *) xmalloc (io_size);
12020 back_to = make_cleanup (xfree, buffer);
12021
12022 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
12023
12024 bytes_in_buffer = 0;
12025 saw_eof = 0;
12026 offset = 0;
12027 while (bytes_in_buffer || !saw_eof)
12028 {
12029 if (!saw_eof)
12030 {
12031 bytes = fread (buffer + bytes_in_buffer, 1,
12032 io_size - bytes_in_buffer,
12033 file.get ());
12034 if (bytes == 0)
12035 {
12036 if (ferror (file.get ()))
12037 error (_("Error reading %s."), local_file);
12038 else
12039 {
12040 /* EOF. Unless there is something still in the
12041 buffer from the last iteration, we are done. */
12042 saw_eof = 1;
12043 if (bytes_in_buffer == 0)
12044 break;
12045 }
12046 }
12047 }
12048 else
12049 bytes = 0;
12050
12051 bytes += bytes_in_buffer;
12052 bytes_in_buffer = 0;
12053
12054 retcode = remote_hostio_pwrite (find_target_at (process_stratum),
12055 fd, buffer, bytes,
12056 offset, &remote_errno);
12057
12058 if (retcode < 0)
12059 remote_hostio_error (remote_errno);
12060 else if (retcode == 0)
12061 error (_("Remote write of %d bytes returned 0!"), bytes);
12062 else if (retcode < bytes)
12063 {
12064 /* Short write. Save the rest of the read data for the next
12065 write. */
12066 bytes_in_buffer = bytes - retcode;
12067 memmove (buffer, buffer + retcode, bytes_in_buffer);
12068 }
12069
12070 offset += retcode;
12071 }
12072
12073 discard_cleanups (close_cleanup);
12074 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
12075 remote_hostio_error (remote_errno);
12076
12077 if (from_tty)
12078 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file);
12079 do_cleanups (back_to);
12080 }
12081
12082 void
12083 remote_file_get (const char *remote_file, const char *local_file, int from_tty)
12084 {
12085 struct cleanup *back_to, *close_cleanup;
12086 int fd, remote_errno, bytes, io_size;
12087 gdb_byte *buffer;
12088 ULONGEST offset;
12089 struct remote_state *rs = get_remote_state ();
12090
12091 if (!rs->remote_desc)
12092 error (_("command can only be used with remote target"));
12093
12094 fd = remote_hostio_open (find_target_at (process_stratum), NULL,
12095 remote_file, FILEIO_O_RDONLY, 0, 0,
12096 &remote_errno);
12097 if (fd == -1)
12098 remote_hostio_error (remote_errno);
12099
12100 gdb_file_up file = gdb_fopen_cloexec (local_file, "wb");
12101 if (file == NULL)
12102 perror_with_name (local_file);
12103
12104 /* Send up to this many bytes at once. They won't all fit in the
12105 remote packet limit, so we'll transfer slightly fewer. */
12106 io_size = get_remote_packet_size ();
12107 buffer = (gdb_byte *) xmalloc (io_size);
12108 back_to = make_cleanup (xfree, buffer);
12109
12110 close_cleanup = make_cleanup (remote_hostio_close_cleanup, &fd);
12111
12112 offset = 0;
12113 while (1)
12114 {
12115 bytes = remote_hostio_pread (find_target_at (process_stratum),
12116 fd, buffer, io_size, offset, &remote_errno);
12117 if (bytes == 0)
12118 /* Success, but no bytes, means end-of-file. */
12119 break;
12120 if (bytes == -1)
12121 remote_hostio_error (remote_errno);
12122
12123 offset += bytes;
12124
12125 bytes = fwrite (buffer, 1, bytes, file.get ());
12126 if (bytes == 0)
12127 perror_with_name (local_file);
12128 }
12129
12130 discard_cleanups (close_cleanup);
12131 if (remote_hostio_close (find_target_at (process_stratum), fd, &remote_errno))
12132 remote_hostio_error (remote_errno);
12133
12134 if (from_tty)
12135 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file);
12136 do_cleanups (back_to);
12137 }
12138
12139 void
12140 remote_file_delete (const char *remote_file, int from_tty)
12141 {
12142 int retcode, remote_errno;
12143 struct remote_state *rs = get_remote_state ();
12144
12145 if (!rs->remote_desc)
12146 error (_("command can only be used with remote target"));
12147
12148 retcode = remote_hostio_unlink (find_target_at (process_stratum),
12149 NULL, remote_file, &remote_errno);
12150 if (retcode == -1)
12151 remote_hostio_error (remote_errno);
12152
12153 if (from_tty)
12154 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file);
12155 }
12156
12157 static void
12158 remote_put_command (const char *args, int from_tty)
12159 {
12160 if (args == NULL)
12161 error_no_arg (_("file to put"));
12162
12163 gdb_argv argv (args);
12164 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12165 error (_("Invalid parameters to remote put"));
12166
12167 remote_file_put (argv[0], argv[1], from_tty);
12168 }
12169
12170 static void
12171 remote_get_command (const char *args, int from_tty)
12172 {
12173 if (args == NULL)
12174 error_no_arg (_("file to get"));
12175
12176 gdb_argv argv (args);
12177 if (argv[0] == NULL || argv[1] == NULL || argv[2] != NULL)
12178 error (_("Invalid parameters to remote get"));
12179
12180 remote_file_get (argv[0], argv[1], from_tty);
12181 }
12182
12183 static void
12184 remote_delete_command (const char *args, int from_tty)
12185 {
12186 if (args == NULL)
12187 error_no_arg (_("file to delete"));
12188
12189 gdb_argv argv (args);
12190 if (argv[0] == NULL || argv[1] != NULL)
12191 error (_("Invalid parameters to remote delete"));
12192
12193 remote_file_delete (argv[0], from_tty);
12194 }
12195
12196 static void
12197 remote_command (const char *args, int from_tty)
12198 {
12199 help_list (remote_cmdlist, "remote ", all_commands, gdb_stdout);
12200 }
12201
12202 static int
12203 remote_can_execute_reverse (struct target_ops *self)
12204 {
12205 if (packet_support (PACKET_bs) == PACKET_ENABLE
12206 || packet_support (PACKET_bc) == PACKET_ENABLE)
12207 return 1;
12208 else
12209 return 0;
12210 }
12211
12212 static int
12213 remote_supports_non_stop (struct target_ops *self)
12214 {
12215 return 1;
12216 }
12217
12218 static int
12219 remote_supports_disable_randomization (struct target_ops *self)
12220 {
12221 /* Only supported in extended mode. */
12222 return 0;
12223 }
12224
12225 static int
12226 remote_supports_multi_process (struct target_ops *self)
12227 {
12228 struct remote_state *rs = get_remote_state ();
12229
12230 return remote_multi_process_p (rs);
12231 }
12232
12233 static int
12234 remote_supports_cond_tracepoints (void)
12235 {
12236 return packet_support (PACKET_ConditionalTracepoints) == PACKET_ENABLE;
12237 }
12238
12239 static int
12240 remote_supports_cond_breakpoints (struct target_ops *self)
12241 {
12242 return packet_support (PACKET_ConditionalBreakpoints) == PACKET_ENABLE;
12243 }
12244
12245 static int
12246 remote_supports_fast_tracepoints (void)
12247 {
12248 return packet_support (PACKET_FastTracepoints) == PACKET_ENABLE;
12249 }
12250
12251 static int
12252 remote_supports_static_tracepoints (void)
12253 {
12254 return packet_support (PACKET_StaticTracepoints) == PACKET_ENABLE;
12255 }
12256
12257 static int
12258 remote_supports_install_in_trace (void)
12259 {
12260 return packet_support (PACKET_InstallInTrace) == PACKET_ENABLE;
12261 }
12262
12263 static int
12264 remote_supports_enable_disable_tracepoint (struct target_ops *self)
12265 {
12266 return (packet_support (PACKET_EnableDisableTracepoints_feature)
12267 == PACKET_ENABLE);
12268 }
12269
12270 static int
12271 remote_supports_string_tracing (struct target_ops *self)
12272 {
12273 return packet_support (PACKET_tracenz_feature) == PACKET_ENABLE;
12274 }
12275
12276 static int
12277 remote_can_run_breakpoint_commands (struct target_ops *self)
12278 {
12279 return packet_support (PACKET_BreakpointCommands) == PACKET_ENABLE;
12280 }
12281
12282 static void
12283 remote_trace_init (struct target_ops *self)
12284 {
12285 struct remote_state *rs = get_remote_state ();
12286
12287 putpkt ("QTinit");
12288 remote_get_noisy_reply ();
12289 if (strcmp (rs->buf, "OK") != 0)
12290 error (_("Target does not support this command."));
12291 }
12292
12293 /* Recursive routine to walk through command list including loops, and
12294 download packets for each command. */
12295
12296 static void
12297 remote_download_command_source (int num, ULONGEST addr,
12298 struct command_line *cmds)
12299 {
12300 struct remote_state *rs = get_remote_state ();
12301 struct command_line *cmd;
12302
12303 for (cmd = cmds; cmd; cmd = cmd->next)
12304 {
12305 QUIT; /* Allow user to bail out with ^C. */
12306 strcpy (rs->buf, "QTDPsrc:");
12307 encode_source_string (num, addr, "cmd", cmd->line,
12308 rs->buf + strlen (rs->buf),
12309 rs->buf_size - strlen (rs->buf));
12310 putpkt (rs->buf);
12311 remote_get_noisy_reply ();
12312 if (strcmp (rs->buf, "OK"))
12313 warning (_("Target does not support source download."));
12314
12315 if (cmd->control_type == while_control
12316 || cmd->control_type == while_stepping_control)
12317 {
12318 remote_download_command_source (num, addr, *cmd->body_list);
12319
12320 QUIT; /* Allow user to bail out with ^C. */
12321 strcpy (rs->buf, "QTDPsrc:");
12322 encode_source_string (num, addr, "cmd", "end",
12323 rs->buf + strlen (rs->buf),
12324 rs->buf_size - strlen (rs->buf));
12325 putpkt (rs->buf);
12326 remote_get_noisy_reply ();
12327 if (strcmp (rs->buf, "OK"))
12328 warning (_("Target does not support source download."));
12329 }
12330 }
12331 }
12332
12333 static void
12334 remote_download_tracepoint (struct target_ops *self, struct bp_location *loc)
12335 {
12336 #define BUF_SIZE 2048
12337
12338 CORE_ADDR tpaddr;
12339 char addrbuf[40];
12340 char buf[BUF_SIZE];
12341 std::vector<std::string> tdp_actions;
12342 std::vector<std::string> stepping_actions;
12343 char *pkt;
12344 struct breakpoint *b = loc->owner;
12345 struct tracepoint *t = (struct tracepoint *) b;
12346 struct remote_state *rs = get_remote_state ();
12347
12348 encode_actions_rsp (loc, &tdp_actions, &stepping_actions);
12349
12350 tpaddr = loc->address;
12351 sprintf_vma (addrbuf, tpaddr);
12352 xsnprintf (buf, BUF_SIZE, "QTDP:%x:%s:%c:%lx:%x", b->number,
12353 addrbuf, /* address */
12354 (b->enable_state == bp_enabled ? 'E' : 'D'),
12355 t->step_count, t->pass_count);
12356 /* Fast tracepoints are mostly handled by the target, but we can
12357 tell the target how big of an instruction block should be moved
12358 around. */
12359 if (b->type == bp_fast_tracepoint)
12360 {
12361 /* Only test for support at download time; we may not know
12362 target capabilities at definition time. */
12363 if (remote_supports_fast_tracepoints ())
12364 {
12365 if (gdbarch_fast_tracepoint_valid_at (loc->gdbarch, tpaddr,
12366 NULL))
12367 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":F%x",
12368 gdb_insn_length (loc->gdbarch, tpaddr));
12369 else
12370 /* If it passed validation at definition but fails now,
12371 something is very wrong. */
12372 internal_error (__FILE__, __LINE__,
12373 _("Fast tracepoint not "
12374 "valid during download"));
12375 }
12376 else
12377 /* Fast tracepoints are functionally identical to regular
12378 tracepoints, so don't take lack of support as a reason to
12379 give up on the trace run. */
12380 warning (_("Target does not support fast tracepoints, "
12381 "downloading %d as regular tracepoint"), b->number);
12382 }
12383 else if (b->type == bp_static_tracepoint)
12384 {
12385 /* Only test for support at download time; we may not know
12386 target capabilities at definition time. */
12387 if (remote_supports_static_tracepoints ())
12388 {
12389 struct static_tracepoint_marker marker;
12390
12391 if (target_static_tracepoint_marker_at (tpaddr, &marker))
12392 strcat (buf, ":S");
12393 else
12394 error (_("Static tracepoint not valid during download"));
12395 }
12396 else
12397 /* Fast tracepoints are functionally identical to regular
12398 tracepoints, so don't take lack of support as a reason
12399 to give up on the trace run. */
12400 error (_("Target does not support static tracepoints"));
12401 }
12402 /* If the tracepoint has a conditional, make it into an agent
12403 expression and append to the definition. */
12404 if (loc->cond)
12405 {
12406 /* Only test support at download time, we may not know target
12407 capabilities at definition time. */
12408 if (remote_supports_cond_tracepoints ())
12409 {
12410 agent_expr_up aexpr = gen_eval_for_expr (tpaddr, loc->cond.get ());
12411 xsnprintf (buf + strlen (buf), BUF_SIZE - strlen (buf), ":X%x,",
12412 aexpr->len);
12413 pkt = buf + strlen (buf);
12414 for (int ndx = 0; ndx < aexpr->len; ++ndx)
12415 pkt = pack_hex_byte (pkt, aexpr->buf[ndx]);
12416 *pkt = '\0';
12417 }
12418 else
12419 warning (_("Target does not support conditional tracepoints, "
12420 "ignoring tp %d cond"), b->number);
12421 }
12422
12423 if (b->commands || *default_collect)
12424 strcat (buf, "-");
12425 putpkt (buf);
12426 remote_get_noisy_reply ();
12427 if (strcmp (rs->buf, "OK"))
12428 error (_("Target does not support tracepoints."));
12429
12430 /* do_single_steps (t); */
12431 for (auto action_it = tdp_actions.begin ();
12432 action_it != tdp_actions.end (); action_it++)
12433 {
12434 QUIT; /* Allow user to bail out with ^C. */
12435
12436 bool has_more = (action_it != tdp_actions.end ()
12437 || !stepping_actions.empty ());
12438
12439 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%c",
12440 b->number, addrbuf, /* address */
12441 action_it->c_str (),
12442 has_more ? '-' : 0);
12443 putpkt (buf);
12444 remote_get_noisy_reply ();
12445 if (strcmp (rs->buf, "OK"))
12446 error (_("Error on target while setting tracepoints."));
12447 }
12448
12449 for (auto action_it = stepping_actions.begin ();
12450 action_it != stepping_actions.end (); action_it++)
12451 {
12452 QUIT; /* Allow user to bail out with ^C. */
12453
12454 bool is_first = action_it == stepping_actions.begin ();
12455 bool has_more = action_it != stepping_actions.end ();
12456
12457 xsnprintf (buf, BUF_SIZE, "QTDP:-%x:%s:%s%s%s",
12458 b->number, addrbuf, /* address */
12459 is_first ? "S" : "",
12460 action_it->c_str (),
12461 has_more ? "-" : "");
12462 putpkt (buf);
12463 remote_get_noisy_reply ();
12464 if (strcmp (rs->buf, "OK"))
12465 error (_("Error on target while setting tracepoints."));
12466 }
12467
12468 if (packet_support (PACKET_TracepointSource) == PACKET_ENABLE)
12469 {
12470 if (b->location != NULL)
12471 {
12472 strcpy (buf, "QTDPsrc:");
12473 encode_source_string (b->number, loc->address, "at",
12474 event_location_to_string (b->location.get ()),
12475 buf + strlen (buf), 2048 - strlen (buf));
12476 putpkt (buf);
12477 remote_get_noisy_reply ();
12478 if (strcmp (rs->buf, "OK"))
12479 warning (_("Target does not support source download."));
12480 }
12481 if (b->cond_string)
12482 {
12483 strcpy (buf, "QTDPsrc:");
12484 encode_source_string (b->number, loc->address,
12485 "cond", b->cond_string, buf + strlen (buf),
12486 2048 - strlen (buf));
12487 putpkt (buf);
12488 remote_get_noisy_reply ();
12489 if (strcmp (rs->buf, "OK"))
12490 warning (_("Target does not support source download."));
12491 }
12492 remote_download_command_source (b->number, loc->address,
12493 breakpoint_commands (b));
12494 }
12495 }
12496
12497 static int
12498 remote_can_download_tracepoint (struct target_ops *self)
12499 {
12500 struct remote_state *rs = get_remote_state ();
12501 struct trace_status *ts;
12502 int status;
12503
12504 /* Don't try to install tracepoints until we've relocated our
12505 symbols, and fetched and merged the target's tracepoint list with
12506 ours. */
12507 if (rs->starting_up)
12508 return 0;
12509
12510 ts = current_trace_status ();
12511 status = remote_get_trace_status (self, ts);
12512
12513 if (status == -1 || !ts->running_known || !ts->running)
12514 return 0;
12515
12516 /* If we are in a tracing experiment, but remote stub doesn't support
12517 installing tracepoint in trace, we have to return. */
12518 if (!remote_supports_install_in_trace ())
12519 return 0;
12520
12521 return 1;
12522 }
12523
12524
12525 static void
12526 remote_download_trace_state_variable (struct target_ops *self,
12527 struct trace_state_variable *tsv)
12528 {
12529 struct remote_state *rs = get_remote_state ();
12530 char *p;
12531
12532 xsnprintf (rs->buf, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12533 tsv->number, phex ((ULONGEST) tsv->initial_value, 8),
12534 tsv->builtin);
12535 p = rs->buf + strlen (rs->buf);
12536 if ((p - rs->buf) + strlen (tsv->name) * 2 >= get_remote_packet_size ())
12537 error (_("Trace state variable name too long for tsv definition packet"));
12538 p += 2 * bin2hex ((gdb_byte *) (tsv->name), p, strlen (tsv->name));
12539 *p++ = '\0';
12540 putpkt (rs->buf);
12541 remote_get_noisy_reply ();
12542 if (*rs->buf == '\0')
12543 error (_("Target does not support this command."));
12544 if (strcmp (rs->buf, "OK") != 0)
12545 error (_("Error on target while downloading trace state variable."));
12546 }
12547
12548 static void
12549 remote_enable_tracepoint (struct target_ops *self,
12550 struct bp_location *location)
12551 {
12552 struct remote_state *rs = get_remote_state ();
12553 char addr_buf[40];
12554
12555 sprintf_vma (addr_buf, location->address);
12556 xsnprintf (rs->buf, get_remote_packet_size (), "QTEnable:%x:%s",
12557 location->owner->number, addr_buf);
12558 putpkt (rs->buf);
12559 remote_get_noisy_reply ();
12560 if (*rs->buf == '\0')
12561 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12562 if (strcmp (rs->buf, "OK") != 0)
12563 error (_("Error on target while enabling tracepoint."));
12564 }
12565
12566 static void
12567 remote_disable_tracepoint (struct target_ops *self,
12568 struct bp_location *location)
12569 {
12570 struct remote_state *rs = get_remote_state ();
12571 char addr_buf[40];
12572
12573 sprintf_vma (addr_buf, location->address);
12574 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisable:%x:%s",
12575 location->owner->number, addr_buf);
12576 putpkt (rs->buf);
12577 remote_get_noisy_reply ();
12578 if (*rs->buf == '\0')
12579 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12580 if (strcmp (rs->buf, "OK") != 0)
12581 error (_("Error on target while disabling tracepoint."));
12582 }
12583
12584 static void
12585 remote_trace_set_readonly_regions (struct target_ops *self)
12586 {
12587 asection *s;
12588 bfd *abfd = NULL;
12589 bfd_size_type size;
12590 bfd_vma vma;
12591 int anysecs = 0;
12592 int offset = 0;
12593
12594 if (!exec_bfd)
12595 return; /* No information to give. */
12596
12597 struct remote_state *rs = get_remote_state ();
12598
12599 strcpy (rs->buf, "QTro");
12600 offset = strlen (rs->buf);
12601 for (s = exec_bfd->sections; s; s = s->next)
12602 {
12603 char tmp1[40], tmp2[40];
12604 int sec_length;
12605
12606 if ((s->flags & SEC_LOAD) == 0 ||
12607 /* (s->flags & SEC_CODE) == 0 || */
12608 (s->flags & SEC_READONLY) == 0)
12609 continue;
12610
12611 anysecs = 1;
12612 vma = bfd_get_section_vma (abfd, s);
12613 size = bfd_get_section_size (s);
12614 sprintf_vma (tmp1, vma);
12615 sprintf_vma (tmp2, vma + size);
12616 sec_length = 1 + strlen (tmp1) + 1 + strlen (tmp2);
12617 if (offset + sec_length + 1 > rs->buf_size)
12618 {
12619 if (packet_support (PACKET_qXfer_traceframe_info) != PACKET_ENABLE)
12620 warning (_("\
12621 Too many sections for read-only sections definition packet."));
12622 break;
12623 }
12624 xsnprintf (rs->buf + offset, rs->buf_size - offset, ":%s,%s",
12625 tmp1, tmp2);
12626 offset += sec_length;
12627 }
12628 if (anysecs)
12629 {
12630 putpkt (rs->buf);
12631 getpkt (&rs->buf, &rs->buf_size, 0);
12632 }
12633 }
12634
12635 static void
12636 remote_trace_start (struct target_ops *self)
12637 {
12638 struct remote_state *rs = get_remote_state ();
12639
12640 putpkt ("QTStart");
12641 remote_get_noisy_reply ();
12642 if (*rs->buf == '\0')
12643 error (_("Target does not support this command."));
12644 if (strcmp (rs->buf, "OK") != 0)
12645 error (_("Bogus reply from target: %s"), rs->buf);
12646 }
12647
12648 static int
12649 remote_get_trace_status (struct target_ops *self, struct trace_status *ts)
12650 {
12651 /* Initialize it just to avoid a GCC false warning. */
12652 char *p = NULL;
12653 /* FIXME we need to get register block size some other way. */
12654 extern int trace_regblock_size;
12655 enum packet_result result;
12656 struct remote_state *rs = get_remote_state ();
12657
12658 if (packet_support (PACKET_qTStatus) == PACKET_DISABLE)
12659 return -1;
12660
12661 trace_regblock_size
12662 = get_remote_arch_state (target_gdbarch ())->sizeof_g_packet;
12663
12664 putpkt ("qTStatus");
12665
12666 TRY
12667 {
12668 p = remote_get_noisy_reply ();
12669 }
12670 CATCH (ex, RETURN_MASK_ERROR)
12671 {
12672 if (ex.error != TARGET_CLOSE_ERROR)
12673 {
12674 exception_fprintf (gdb_stderr, ex, "qTStatus: ");
12675 return -1;
12676 }
12677 throw_exception (ex);
12678 }
12679 END_CATCH
12680
12681 result = packet_ok (p, &remote_protocol_packets[PACKET_qTStatus]);
12682
12683 /* If the remote target doesn't do tracing, flag it. */
12684 if (result == PACKET_UNKNOWN)
12685 return -1;
12686
12687 /* We're working with a live target. */
12688 ts->filename = NULL;
12689
12690 if (*p++ != 'T')
12691 error (_("Bogus trace status reply from target: %s"), rs->buf);
12692
12693 /* Function 'parse_trace_status' sets default value of each field of
12694 'ts' at first, so we don't have to do it here. */
12695 parse_trace_status (p, ts);
12696
12697 return ts->running;
12698 }
12699
12700 static void
12701 remote_get_tracepoint_status (struct target_ops *self, struct breakpoint *bp,
12702 struct uploaded_tp *utp)
12703 {
12704 struct remote_state *rs = get_remote_state ();
12705 char *reply;
12706 struct bp_location *loc;
12707 struct tracepoint *tp = (struct tracepoint *) bp;
12708 size_t size = get_remote_packet_size ();
12709
12710 if (tp)
12711 {
12712 tp->hit_count = 0;
12713 tp->traceframe_usage = 0;
12714 for (loc = tp->loc; loc; loc = loc->next)
12715 {
12716 /* If the tracepoint was never downloaded, don't go asking for
12717 any status. */
12718 if (tp->number_on_target == 0)
12719 continue;
12720 xsnprintf (rs->buf, size, "qTP:%x:%s", tp->number_on_target,
12721 phex_nz (loc->address, 0));
12722 putpkt (rs->buf);
12723 reply = remote_get_noisy_reply ();
12724 if (reply && *reply)
12725 {
12726 if (*reply == 'V')
12727 parse_tracepoint_status (reply + 1, bp, utp);
12728 }
12729 }
12730 }
12731 else if (utp)
12732 {
12733 utp->hit_count = 0;
12734 utp->traceframe_usage = 0;
12735 xsnprintf (rs->buf, size, "qTP:%x:%s", utp->number,
12736 phex_nz (utp->addr, 0));
12737 putpkt (rs->buf);
12738 reply = remote_get_noisy_reply ();
12739 if (reply && *reply)
12740 {
12741 if (*reply == 'V')
12742 parse_tracepoint_status (reply + 1, bp, utp);
12743 }
12744 }
12745 }
12746
12747 static void
12748 remote_trace_stop (struct target_ops *self)
12749 {
12750 struct remote_state *rs = get_remote_state ();
12751
12752 putpkt ("QTStop");
12753 remote_get_noisy_reply ();
12754 if (*rs->buf == '\0')
12755 error (_("Target does not support this command."));
12756 if (strcmp (rs->buf, "OK") != 0)
12757 error (_("Bogus reply from target: %s"), rs->buf);
12758 }
12759
12760 static int
12761 remote_trace_find (struct target_ops *self,
12762 enum trace_find_type type, int num,
12763 CORE_ADDR addr1, CORE_ADDR addr2,
12764 int *tpp)
12765 {
12766 struct remote_state *rs = get_remote_state ();
12767 char *endbuf = rs->buf + get_remote_packet_size ();
12768 char *p, *reply;
12769 int target_frameno = -1, target_tracept = -1;
12770
12771 /* Lookups other than by absolute frame number depend on the current
12772 trace selected, so make sure it is correct on the remote end
12773 first. */
12774 if (type != tfind_number)
12775 set_remote_traceframe ();
12776
12777 p = rs->buf;
12778 strcpy (p, "QTFrame:");
12779 p = strchr (p, '\0');
12780 switch (type)
12781 {
12782 case tfind_number:
12783 xsnprintf (p, endbuf - p, "%x", num);
12784 break;
12785 case tfind_pc:
12786 xsnprintf (p, endbuf - p, "pc:%s", phex_nz (addr1, 0));
12787 break;
12788 case tfind_tp:
12789 xsnprintf (p, endbuf - p, "tdp:%x", num);
12790 break;
12791 case tfind_range:
12792 xsnprintf (p, endbuf - p, "range:%s:%s", phex_nz (addr1, 0),
12793 phex_nz (addr2, 0));
12794 break;
12795 case tfind_outside:
12796 xsnprintf (p, endbuf - p, "outside:%s:%s", phex_nz (addr1, 0),
12797 phex_nz (addr2, 0));
12798 break;
12799 default:
12800 error (_("Unknown trace find type %d"), type);
12801 }
12802
12803 putpkt (rs->buf);
12804 reply = remote_get_noisy_reply ();
12805 if (*reply == '\0')
12806 error (_("Target does not support this command."));
12807
12808 while (reply && *reply)
12809 switch (*reply)
12810 {
12811 case 'F':
12812 p = ++reply;
12813 target_frameno = (int) strtol (p, &reply, 16);
12814 if (reply == p)
12815 error (_("Unable to parse trace frame number"));
12816 /* Don't update our remote traceframe number cache on failure
12817 to select a remote traceframe. */
12818 if (target_frameno == -1)
12819 return -1;
12820 break;
12821 case 'T':
12822 p = ++reply;
12823 target_tracept = (int) strtol (p, &reply, 16);
12824 if (reply == p)
12825 error (_("Unable to parse tracepoint number"));
12826 break;
12827 case 'O': /* "OK"? */
12828 if (reply[1] == 'K' && reply[2] == '\0')
12829 reply += 2;
12830 else
12831 error (_("Bogus reply from target: %s"), reply);
12832 break;
12833 default:
12834 error (_("Bogus reply from target: %s"), reply);
12835 }
12836 if (tpp)
12837 *tpp = target_tracept;
12838
12839 rs->remote_traceframe_number = target_frameno;
12840 return target_frameno;
12841 }
12842
12843 static int
12844 remote_get_trace_state_variable_value (struct target_ops *self,
12845 int tsvnum, LONGEST *val)
12846 {
12847 struct remote_state *rs = get_remote_state ();
12848 char *reply;
12849 ULONGEST uval;
12850
12851 set_remote_traceframe ();
12852
12853 xsnprintf (rs->buf, get_remote_packet_size (), "qTV:%x", tsvnum);
12854 putpkt (rs->buf);
12855 reply = remote_get_noisy_reply ();
12856 if (reply && *reply)
12857 {
12858 if (*reply == 'V')
12859 {
12860 unpack_varlen_hex (reply + 1, &uval);
12861 *val = (LONGEST) uval;
12862 return 1;
12863 }
12864 }
12865 return 0;
12866 }
12867
12868 static int
12869 remote_save_trace_data (struct target_ops *self, const char *filename)
12870 {
12871 struct remote_state *rs = get_remote_state ();
12872 char *p, *reply;
12873
12874 p = rs->buf;
12875 strcpy (p, "QTSave:");
12876 p += strlen (p);
12877 if ((p - rs->buf) + strlen (filename) * 2 >= get_remote_packet_size ())
12878 error (_("Remote file name too long for trace save packet"));
12879 p += 2 * bin2hex ((gdb_byte *) filename, p, strlen (filename));
12880 *p++ = '\0';
12881 putpkt (rs->buf);
12882 reply = remote_get_noisy_reply ();
12883 if (*reply == '\0')
12884 error (_("Target does not support this command."));
12885 if (strcmp (reply, "OK") != 0)
12886 error (_("Bogus reply from target: %s"), reply);
12887 return 0;
12888 }
12889
12890 /* This is basically a memory transfer, but needs to be its own packet
12891 because we don't know how the target actually organizes its trace
12892 memory, plus we want to be able to ask for as much as possible, but
12893 not be unhappy if we don't get as much as we ask for. */
12894
12895 static LONGEST
12896 remote_get_raw_trace_data (struct target_ops *self,
12897 gdb_byte *buf, ULONGEST offset, LONGEST len)
12898 {
12899 struct remote_state *rs = get_remote_state ();
12900 char *reply;
12901 char *p;
12902 int rslt;
12903
12904 p = rs->buf;
12905 strcpy (p, "qTBuffer:");
12906 p += strlen (p);
12907 p += hexnumstr (p, offset);
12908 *p++ = ',';
12909 p += hexnumstr (p, len);
12910 *p++ = '\0';
12911
12912 putpkt (rs->buf);
12913 reply = remote_get_noisy_reply ();
12914 if (reply && *reply)
12915 {
12916 /* 'l' by itself means we're at the end of the buffer and
12917 there is nothing more to get. */
12918 if (*reply == 'l')
12919 return 0;
12920
12921 /* Convert the reply into binary. Limit the number of bytes to
12922 convert according to our passed-in buffer size, rather than
12923 what was returned in the packet; if the target is
12924 unexpectedly generous and gives us a bigger reply than we
12925 asked for, we don't want to crash. */
12926 rslt = hex2bin (reply, buf, len);
12927 return rslt;
12928 }
12929
12930 /* Something went wrong, flag as an error. */
12931 return -1;
12932 }
12933
12934 static void
12935 remote_set_disconnected_tracing (struct target_ops *self, int val)
12936 {
12937 struct remote_state *rs = get_remote_state ();
12938
12939 if (packet_support (PACKET_DisconnectedTracing_feature) == PACKET_ENABLE)
12940 {
12941 char *reply;
12942
12943 xsnprintf (rs->buf, get_remote_packet_size (), "QTDisconnected:%x", val);
12944 putpkt (rs->buf);
12945 reply = remote_get_noisy_reply ();
12946 if (*reply == '\0')
12947 error (_("Target does not support this command."));
12948 if (strcmp (reply, "OK") != 0)
12949 error (_("Bogus reply from target: %s"), reply);
12950 }
12951 else if (val)
12952 warning (_("Target does not support disconnected tracing."));
12953 }
12954
12955 static int
12956 remote_core_of_thread (struct target_ops *ops, ptid_t ptid)
12957 {
12958 struct thread_info *info = find_thread_ptid (ptid);
12959
12960 if (info && info->priv)
12961 return info->priv->core;
12962 return -1;
12963 }
12964
12965 static void
12966 remote_set_circular_trace_buffer (struct target_ops *self, int val)
12967 {
12968 struct remote_state *rs = get_remote_state ();
12969 char *reply;
12970
12971 xsnprintf (rs->buf, get_remote_packet_size (), "QTBuffer:circular:%x", val);
12972 putpkt (rs->buf);
12973 reply = remote_get_noisy_reply ();
12974 if (*reply == '\0')
12975 error (_("Target does not support this command."));
12976 if (strcmp (reply, "OK") != 0)
12977 error (_("Bogus reply from target: %s"), reply);
12978 }
12979
12980 static traceframe_info_up
12981 remote_traceframe_info (struct target_ops *self)
12982 {
12983 gdb::unique_xmalloc_ptr<char> text
12984 = target_read_stralloc (&current_target, TARGET_OBJECT_TRACEFRAME_INFO,
12985 NULL);
12986 if (text != NULL)
12987 return parse_traceframe_info (text.get ());
12988
12989 return NULL;
12990 }
12991
12992 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12993 instruction on which a fast tracepoint may be placed. Returns -1
12994 if the packet is not supported, and 0 if the minimum instruction
12995 length is unknown. */
12996
12997 static int
12998 remote_get_min_fast_tracepoint_insn_len (struct target_ops *self)
12999 {
13000 struct remote_state *rs = get_remote_state ();
13001 char *reply;
13002
13003 /* If we're not debugging a process yet, the IPA can't be
13004 loaded. */
13005 if (!target_has_execution)
13006 return 0;
13007
13008 /* Make sure the remote is pointing at the right process. */
13009 set_general_process ();
13010
13011 xsnprintf (rs->buf, get_remote_packet_size (), "qTMinFTPILen");
13012 putpkt (rs->buf);
13013 reply = remote_get_noisy_reply ();
13014 if (*reply == '\0')
13015 return -1;
13016 else
13017 {
13018 ULONGEST min_insn_len;
13019
13020 unpack_varlen_hex (reply, &min_insn_len);
13021
13022 return (int) min_insn_len;
13023 }
13024 }
13025
13026 static void
13027 remote_set_trace_buffer_size (struct target_ops *self, LONGEST val)
13028 {
13029 if (packet_support (PACKET_QTBuffer_size) != PACKET_DISABLE)
13030 {
13031 struct remote_state *rs = get_remote_state ();
13032 char *buf = rs->buf;
13033 char *endbuf = rs->buf + get_remote_packet_size ();
13034 enum packet_result result;
13035
13036 gdb_assert (val >= 0 || val == -1);
13037 buf += xsnprintf (buf, endbuf - buf, "QTBuffer:size:");
13038 /* Send -1 as literal "-1" to avoid host size dependency. */
13039 if (val < 0)
13040 {
13041 *buf++ = '-';
13042 buf += hexnumstr (buf, (ULONGEST) -val);
13043 }
13044 else
13045 buf += hexnumstr (buf, (ULONGEST) val);
13046
13047 putpkt (rs->buf);
13048 remote_get_noisy_reply ();
13049 result = packet_ok (rs->buf,
13050 &remote_protocol_packets[PACKET_QTBuffer_size]);
13051
13052 if (result != PACKET_OK)
13053 warning (_("Bogus reply from target: %s"), rs->buf);
13054 }
13055 }
13056
13057 static int
13058 remote_set_trace_notes (struct target_ops *self,
13059 const char *user, const char *notes,
13060 const char *stop_notes)
13061 {
13062 struct remote_state *rs = get_remote_state ();
13063 char *reply;
13064 char *buf = rs->buf;
13065 char *endbuf = rs->buf + get_remote_packet_size ();
13066 int nbytes;
13067
13068 buf += xsnprintf (buf, endbuf - buf, "QTNotes:");
13069 if (user)
13070 {
13071 buf += xsnprintf (buf, endbuf - buf, "user:");
13072 nbytes = bin2hex ((gdb_byte *) user, buf, strlen (user));
13073 buf += 2 * nbytes;
13074 *buf++ = ';';
13075 }
13076 if (notes)
13077 {
13078 buf += xsnprintf (buf, endbuf - buf, "notes:");
13079 nbytes = bin2hex ((gdb_byte *) notes, buf, strlen (notes));
13080 buf += 2 * nbytes;
13081 *buf++ = ';';
13082 }
13083 if (stop_notes)
13084 {
13085 buf += xsnprintf (buf, endbuf - buf, "tstop:");
13086 nbytes = bin2hex ((gdb_byte *) stop_notes, buf, strlen (stop_notes));
13087 buf += 2 * nbytes;
13088 *buf++ = ';';
13089 }
13090 /* Ensure the buffer is terminated. */
13091 *buf = '\0';
13092
13093 putpkt (rs->buf);
13094 reply = remote_get_noisy_reply ();
13095 if (*reply == '\0')
13096 return 0;
13097
13098 if (strcmp (reply, "OK") != 0)
13099 error (_("Bogus reply from target: %s"), reply);
13100
13101 return 1;
13102 }
13103
13104 static int
13105 remote_use_agent (struct target_ops *self, int use)
13106 {
13107 if (packet_support (PACKET_QAgent) != PACKET_DISABLE)
13108 {
13109 struct remote_state *rs = get_remote_state ();
13110
13111 /* If the stub supports QAgent. */
13112 xsnprintf (rs->buf, get_remote_packet_size (), "QAgent:%d", use);
13113 putpkt (rs->buf);
13114 getpkt (&rs->buf, &rs->buf_size, 0);
13115
13116 if (strcmp (rs->buf, "OK") == 0)
13117 {
13118 use_agent = use;
13119 return 1;
13120 }
13121 }
13122
13123 return 0;
13124 }
13125
13126 static int
13127 remote_can_use_agent (struct target_ops *self)
13128 {
13129 return (packet_support (PACKET_QAgent) != PACKET_DISABLE);
13130 }
13131
13132 struct btrace_target_info
13133 {
13134 /* The ptid of the traced thread. */
13135 ptid_t ptid;
13136
13137 /* The obtained branch trace configuration. */
13138 struct btrace_config conf;
13139 };
13140
13141 /* Reset our idea of our target's btrace configuration. */
13142
13143 static void
13144 remote_btrace_reset (void)
13145 {
13146 struct remote_state *rs = get_remote_state ();
13147
13148 memset (&rs->btrace_config, 0, sizeof (rs->btrace_config));
13149 }
13150
13151 /* Check whether the target supports branch tracing. */
13152
13153 static int
13154 remote_supports_btrace (struct target_ops *self, enum btrace_format format)
13155 {
13156 if (packet_support (PACKET_Qbtrace_off) != PACKET_ENABLE)
13157 return 0;
13158 if (packet_support (PACKET_qXfer_btrace) != PACKET_ENABLE)
13159 return 0;
13160
13161 switch (format)
13162 {
13163 case BTRACE_FORMAT_NONE:
13164 return 0;
13165
13166 case BTRACE_FORMAT_BTS:
13167 return (packet_support (PACKET_Qbtrace_bts) == PACKET_ENABLE);
13168
13169 case BTRACE_FORMAT_PT:
13170 /* The trace is decoded on the host. Even if our target supports it,
13171 we still need to have libipt to decode the trace. */
13172 #if defined (HAVE_LIBIPT)
13173 return (packet_support (PACKET_Qbtrace_pt) == PACKET_ENABLE);
13174 #else /* !defined (HAVE_LIBIPT) */
13175 return 0;
13176 #endif /* !defined (HAVE_LIBIPT) */
13177 }
13178
13179 internal_error (__FILE__, __LINE__, _("Unknown branch trace format"));
13180 }
13181
13182 /* Synchronize the configuration with the target. */
13183
13184 static void
13185 btrace_sync_conf (const struct btrace_config *conf)
13186 {
13187 struct packet_config *packet;
13188 struct remote_state *rs;
13189 char *buf, *pos, *endbuf;
13190
13191 rs = get_remote_state ();
13192 buf = rs->buf;
13193 endbuf = buf + get_remote_packet_size ();
13194
13195 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_bts_size];
13196 if (packet_config_support (packet) == PACKET_ENABLE
13197 && conf->bts.size != rs->btrace_config.bts.size)
13198 {
13199 pos = buf;
13200 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13201 conf->bts.size);
13202
13203 putpkt (buf);
13204 getpkt (&buf, &rs->buf_size, 0);
13205
13206 if (packet_ok (buf, packet) == PACKET_ERROR)
13207 {
13208 if (buf[0] == 'E' && buf[1] == '.')
13209 error (_("Failed to configure the BTS buffer size: %s"), buf + 2);
13210 else
13211 error (_("Failed to configure the BTS buffer size."));
13212 }
13213
13214 rs->btrace_config.bts.size = conf->bts.size;
13215 }
13216
13217 packet = &remote_protocol_packets[PACKET_Qbtrace_conf_pt_size];
13218 if (packet_config_support (packet) == PACKET_ENABLE
13219 && conf->pt.size != rs->btrace_config.pt.size)
13220 {
13221 pos = buf;
13222 pos += xsnprintf (pos, endbuf - pos, "%s=0x%x", packet->name,
13223 conf->pt.size);
13224
13225 putpkt (buf);
13226 getpkt (&buf, &rs->buf_size, 0);
13227
13228 if (packet_ok (buf, packet) == PACKET_ERROR)
13229 {
13230 if (buf[0] == 'E' && buf[1] == '.')
13231 error (_("Failed to configure the trace buffer size: %s"), buf + 2);
13232 else
13233 error (_("Failed to configure the trace buffer size."));
13234 }
13235
13236 rs->btrace_config.pt.size = conf->pt.size;
13237 }
13238 }
13239
13240 /* Read the current thread's btrace configuration from the target and
13241 store it into CONF. */
13242
13243 static void
13244 btrace_read_config (struct btrace_config *conf)
13245 {
13246 gdb::unique_xmalloc_ptr<char> xml
13247 = target_read_stralloc (&current_target, TARGET_OBJECT_BTRACE_CONF, "");
13248 if (xml != NULL)
13249 parse_xml_btrace_conf (conf, xml.get ());
13250 }
13251
13252 /* Maybe reopen target btrace. */
13253
13254 static void
13255 remote_btrace_maybe_reopen (void)
13256 {
13257 struct remote_state *rs = get_remote_state ();
13258 struct thread_info *tp;
13259 int btrace_target_pushed = 0;
13260 int warned = 0;
13261
13262 scoped_restore_current_thread restore_thread;
13263
13264 ALL_NON_EXITED_THREADS (tp)
13265 {
13266 set_general_thread (tp->ptid);
13267
13268 memset (&rs->btrace_config, 0x00, sizeof (struct btrace_config));
13269 btrace_read_config (&rs->btrace_config);
13270
13271 if (rs->btrace_config.format == BTRACE_FORMAT_NONE)
13272 continue;
13273
13274 #if !defined (HAVE_LIBIPT)
13275 if (rs->btrace_config.format == BTRACE_FORMAT_PT)
13276 {
13277 if (!warned)
13278 {
13279 warned = 1;
13280 warning (_("GDB does not support Intel Processor Trace. "
13281 "\"record\" will not work in this session."));
13282 }
13283
13284 continue;
13285 }
13286 #endif /* !defined (HAVE_LIBIPT) */
13287
13288 /* Push target, once, but before anything else happens. This way our
13289 changes to the threads will be cleaned up by unpushing the target
13290 in case btrace_read_config () throws. */
13291 if (!btrace_target_pushed)
13292 {
13293 btrace_target_pushed = 1;
13294 record_btrace_push_target ();
13295 printf_filtered (_("Target is recording using %s.\n"),
13296 btrace_format_string (rs->btrace_config.format));
13297 }
13298
13299 tp->btrace.target = XCNEW (struct btrace_target_info);
13300 tp->btrace.target->ptid = tp->ptid;
13301 tp->btrace.target->conf = rs->btrace_config;
13302 }
13303 }
13304
13305 /* Enable branch tracing. */
13306
13307 static struct btrace_target_info *
13308 remote_enable_btrace (struct target_ops *self, ptid_t ptid,
13309 const struct btrace_config *conf)
13310 {
13311 struct btrace_target_info *tinfo = NULL;
13312 struct packet_config *packet = NULL;
13313 struct remote_state *rs = get_remote_state ();
13314 char *buf = rs->buf;
13315 char *endbuf = rs->buf + get_remote_packet_size ();
13316
13317 switch (conf->format)
13318 {
13319 case BTRACE_FORMAT_BTS:
13320 packet = &remote_protocol_packets[PACKET_Qbtrace_bts];
13321 break;
13322
13323 case BTRACE_FORMAT_PT:
13324 packet = &remote_protocol_packets[PACKET_Qbtrace_pt];
13325 break;
13326 }
13327
13328 if (packet == NULL || packet_config_support (packet) != PACKET_ENABLE)
13329 error (_("Target does not support branch tracing."));
13330
13331 btrace_sync_conf (conf);
13332
13333 set_general_thread (ptid);
13334
13335 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13336 putpkt (rs->buf);
13337 getpkt (&rs->buf, &rs->buf_size, 0);
13338
13339 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13340 {
13341 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13342 error (_("Could not enable branch tracing for %s: %s"),
13343 target_pid_to_str (ptid), rs->buf + 2);
13344 else
13345 error (_("Could not enable branch tracing for %s."),
13346 target_pid_to_str (ptid));
13347 }
13348
13349 tinfo = XCNEW (struct btrace_target_info);
13350 tinfo->ptid = ptid;
13351
13352 /* If we fail to read the configuration, we lose some information, but the
13353 tracing itself is not impacted. */
13354 TRY
13355 {
13356 btrace_read_config (&tinfo->conf);
13357 }
13358 CATCH (err, RETURN_MASK_ERROR)
13359 {
13360 if (err.message != NULL)
13361 warning ("%s", err.message);
13362 }
13363 END_CATCH
13364
13365 return tinfo;
13366 }
13367
13368 /* Disable branch tracing. */
13369
13370 static void
13371 remote_disable_btrace (struct target_ops *self,
13372 struct btrace_target_info *tinfo)
13373 {
13374 struct packet_config *packet = &remote_protocol_packets[PACKET_Qbtrace_off];
13375 struct remote_state *rs = get_remote_state ();
13376 char *buf = rs->buf;
13377 char *endbuf = rs->buf + get_remote_packet_size ();
13378
13379 if (packet_config_support (packet) != PACKET_ENABLE)
13380 error (_("Target does not support branch tracing."));
13381
13382 set_general_thread (tinfo->ptid);
13383
13384 buf += xsnprintf (buf, endbuf - buf, "%s", packet->name);
13385 putpkt (rs->buf);
13386 getpkt (&rs->buf, &rs->buf_size, 0);
13387
13388 if (packet_ok (rs->buf, packet) == PACKET_ERROR)
13389 {
13390 if (rs->buf[0] == 'E' && rs->buf[1] == '.')
13391 error (_("Could not disable branch tracing for %s: %s"),
13392 target_pid_to_str (tinfo->ptid), rs->buf + 2);
13393 else
13394 error (_("Could not disable branch tracing for %s."),
13395 target_pid_to_str (tinfo->ptid));
13396 }
13397
13398 xfree (tinfo);
13399 }
13400
13401 /* Teardown branch tracing. */
13402
13403 static void
13404 remote_teardown_btrace (struct target_ops *self,
13405 struct btrace_target_info *tinfo)
13406 {
13407 /* We must not talk to the target during teardown. */
13408 xfree (tinfo);
13409 }
13410
13411 /* Read the branch trace. */
13412
13413 static enum btrace_error
13414 remote_read_btrace (struct target_ops *self,
13415 struct btrace_data *btrace,
13416 struct btrace_target_info *tinfo,
13417 enum btrace_read_type type)
13418 {
13419 struct packet_config *packet = &remote_protocol_packets[PACKET_qXfer_btrace];
13420 const char *annex;
13421
13422 if (packet_config_support (packet) != PACKET_ENABLE)
13423 error (_("Target does not support branch tracing."));
13424
13425 #if !defined(HAVE_LIBEXPAT)
13426 error (_("Cannot process branch tracing result. XML parsing not supported."));
13427 #endif
13428
13429 switch (type)
13430 {
13431 case BTRACE_READ_ALL:
13432 annex = "all";
13433 break;
13434 case BTRACE_READ_NEW:
13435 annex = "new";
13436 break;
13437 case BTRACE_READ_DELTA:
13438 annex = "delta";
13439 break;
13440 default:
13441 internal_error (__FILE__, __LINE__,
13442 _("Bad branch tracing read type: %u."),
13443 (unsigned int) type);
13444 }
13445
13446 gdb::unique_xmalloc_ptr<char> xml
13447 = target_read_stralloc (&current_target, TARGET_OBJECT_BTRACE, annex);
13448 if (xml == NULL)
13449 return BTRACE_ERR_UNKNOWN;
13450
13451 parse_xml_btrace (btrace, xml.get ());
13452
13453 return BTRACE_ERR_NONE;
13454 }
13455
13456 static const struct btrace_config *
13457 remote_btrace_conf (struct target_ops *self,
13458 const struct btrace_target_info *tinfo)
13459 {
13460 return &tinfo->conf;
13461 }
13462
13463 static int
13464 remote_augmented_libraries_svr4_read (struct target_ops *self)
13465 {
13466 return (packet_support (PACKET_augmented_libraries_svr4_read_feature)
13467 == PACKET_ENABLE);
13468 }
13469
13470 /* Implementation of to_load. */
13471
13472 static void
13473 remote_load (struct target_ops *self, const char *name, int from_tty)
13474 {
13475 generic_load (name, from_tty);
13476 }
13477
13478 /* Accepts an integer PID; returns a string representing a file that
13479 can be opened on the remote side to get the symbols for the child
13480 process. Returns NULL if the operation is not supported. */
13481
13482 static char *
13483 remote_pid_to_exec_file (struct target_ops *self, int pid)
13484 {
13485 static gdb::unique_xmalloc_ptr<char> filename;
13486 struct inferior *inf;
13487 char *annex = NULL;
13488
13489 if (packet_support (PACKET_qXfer_exec_file) != PACKET_ENABLE)
13490 return NULL;
13491
13492 inf = find_inferior_pid (pid);
13493 if (inf == NULL)
13494 internal_error (__FILE__, __LINE__,
13495 _("not currently attached to process %d"), pid);
13496
13497 if (!inf->fake_pid_p)
13498 {
13499 const int annex_size = 9;
13500
13501 annex = (char *) alloca (annex_size);
13502 xsnprintf (annex, annex_size, "%x", pid);
13503 }
13504
13505 filename = target_read_stralloc (&current_target,
13506 TARGET_OBJECT_EXEC_FILE, annex);
13507
13508 return filename.get ();
13509 }
13510
13511 /* Implement the to_can_do_single_step target_ops method. */
13512
13513 static int
13514 remote_can_do_single_step (struct target_ops *ops)
13515 {
13516 /* We can only tell whether target supports single step or not by
13517 supported s and S vCont actions if the stub supports vContSupported
13518 feature. If the stub doesn't support vContSupported feature,
13519 we have conservatively to think target doesn't supports single
13520 step. */
13521 if (packet_support (PACKET_vContSupported) == PACKET_ENABLE)
13522 {
13523 struct remote_state *rs = get_remote_state ();
13524
13525 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
13526 remote_vcont_probe (rs);
13527
13528 return rs->supports_vCont.s && rs->supports_vCont.S;
13529 }
13530 else
13531 return 0;
13532 }
13533
13534 /* Implementation of the to_execution_direction method for the remote
13535 target. */
13536
13537 static enum exec_direction_kind
13538 remote_execution_direction (struct target_ops *self)
13539 {
13540 struct remote_state *rs = get_remote_state ();
13541
13542 return rs->last_resume_exec_dir;
13543 }
13544
13545 /* Return pointer to the thread_info struct which corresponds to
13546 THREAD_HANDLE (having length HANDLE_LEN). */
13547
13548 static struct thread_info *
13549 remote_thread_handle_to_thread_info (struct target_ops *ops,
13550 const gdb_byte *thread_handle,
13551 int handle_len,
13552 struct inferior *inf)
13553 {
13554 struct thread_info *tp;
13555
13556 ALL_NON_EXITED_THREADS (tp)
13557 {
13558 struct private_thread_info *priv = get_private_info_thread (tp);
13559
13560 if (tp->inf == inf && priv != NULL)
13561 {
13562 if (handle_len != priv->thread_handle->size ())
13563 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13564 handle_len, priv->thread_handle->size ());
13565 if (memcmp (thread_handle, priv->thread_handle->data (),
13566 handle_len) == 0)
13567 return tp;
13568 }
13569 }
13570
13571 return NULL;
13572 }
13573
13574 static void
13575 init_remote_ops (void)
13576 {
13577 remote_ops.to_shortname = "remote";
13578 remote_ops.to_longname = "Remote serial target in gdb-specific protocol";
13579 remote_ops.to_doc =
13580 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13581 Specify the serial device it is connected to\n\
13582 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13583 remote_ops.to_open = remote_open;
13584 remote_ops.to_close = remote_close;
13585 remote_ops.to_detach = remote_detach;
13586 remote_ops.to_disconnect = remote_disconnect;
13587 remote_ops.to_resume = remote_resume;
13588 remote_ops.to_commit_resume = remote_commit_resume;
13589 remote_ops.to_wait = remote_wait;
13590 remote_ops.to_fetch_registers = remote_fetch_registers;
13591 remote_ops.to_store_registers = remote_store_registers;
13592 remote_ops.to_prepare_to_store = remote_prepare_to_store;
13593 remote_ops.to_files_info = remote_files_info;
13594 remote_ops.to_insert_breakpoint = remote_insert_breakpoint;
13595 remote_ops.to_remove_breakpoint = remote_remove_breakpoint;
13596 remote_ops.to_stopped_by_sw_breakpoint = remote_stopped_by_sw_breakpoint;
13597 remote_ops.to_supports_stopped_by_sw_breakpoint = remote_supports_stopped_by_sw_breakpoint;
13598 remote_ops.to_stopped_by_hw_breakpoint = remote_stopped_by_hw_breakpoint;
13599 remote_ops.to_supports_stopped_by_hw_breakpoint = remote_supports_stopped_by_hw_breakpoint;
13600 remote_ops.to_stopped_by_watchpoint = remote_stopped_by_watchpoint;
13601 remote_ops.to_stopped_data_address = remote_stopped_data_address;
13602 remote_ops.to_watchpoint_addr_within_range =
13603 remote_watchpoint_addr_within_range;
13604 remote_ops.to_can_use_hw_breakpoint = remote_check_watch_resources;
13605 remote_ops.to_insert_hw_breakpoint = remote_insert_hw_breakpoint;
13606 remote_ops.to_remove_hw_breakpoint = remote_remove_hw_breakpoint;
13607 remote_ops.to_region_ok_for_hw_watchpoint
13608 = remote_region_ok_for_hw_watchpoint;
13609 remote_ops.to_insert_watchpoint = remote_insert_watchpoint;
13610 remote_ops.to_remove_watchpoint = remote_remove_watchpoint;
13611 remote_ops.to_kill = remote_kill;
13612 remote_ops.to_load = remote_load;
13613 remote_ops.to_mourn_inferior = remote_mourn;
13614 remote_ops.to_pass_signals = remote_pass_signals;
13615 remote_ops.to_set_syscall_catchpoint = remote_set_syscall_catchpoint;
13616 remote_ops.to_program_signals = remote_program_signals;
13617 remote_ops.to_thread_alive = remote_thread_alive;
13618 remote_ops.to_thread_name = remote_thread_name;
13619 remote_ops.to_update_thread_list = remote_update_thread_list;
13620 remote_ops.to_pid_to_str = remote_pid_to_str;
13621 remote_ops.to_extra_thread_info = remote_threads_extra_info;
13622 remote_ops.to_get_ada_task_ptid = remote_get_ada_task_ptid;
13623 remote_ops.to_stop = remote_stop;
13624 remote_ops.to_interrupt = remote_interrupt;
13625 remote_ops.to_pass_ctrlc = remote_pass_ctrlc;
13626 remote_ops.to_xfer_partial = remote_xfer_partial;
13627 remote_ops.to_get_memory_xfer_limit = remote_get_memory_xfer_limit;
13628 remote_ops.to_rcmd = remote_rcmd;
13629 remote_ops.to_pid_to_exec_file = remote_pid_to_exec_file;
13630 remote_ops.to_log_command = serial_log_command;
13631 remote_ops.to_get_thread_local_address = remote_get_thread_local_address;
13632 remote_ops.to_stratum = process_stratum;
13633 remote_ops.to_has_all_memory = default_child_has_all_memory;
13634 remote_ops.to_has_memory = default_child_has_memory;
13635 remote_ops.to_has_stack = default_child_has_stack;
13636 remote_ops.to_has_registers = default_child_has_registers;
13637 remote_ops.to_has_execution = default_child_has_execution;
13638 remote_ops.to_has_thread_control = tc_schedlock; /* can lock scheduler */
13639 remote_ops.to_can_execute_reverse = remote_can_execute_reverse;
13640 remote_ops.to_magic = OPS_MAGIC;
13641 remote_ops.to_memory_map = remote_memory_map;
13642 remote_ops.to_flash_erase = remote_flash_erase;
13643 remote_ops.to_flash_done = remote_flash_done;
13644 remote_ops.to_read_description = remote_read_description;
13645 remote_ops.to_search_memory = remote_search_memory;
13646 remote_ops.to_can_async_p = remote_can_async_p;
13647 remote_ops.to_is_async_p = remote_is_async_p;
13648 remote_ops.to_async = remote_async;
13649 remote_ops.to_thread_events = remote_thread_events;
13650 remote_ops.to_can_do_single_step = remote_can_do_single_step;
13651 remote_ops.to_terminal_inferior = remote_terminal_inferior;
13652 remote_ops.to_terminal_ours = remote_terminal_ours;
13653 remote_ops.to_supports_non_stop = remote_supports_non_stop;
13654 remote_ops.to_supports_multi_process = remote_supports_multi_process;
13655 remote_ops.to_supports_disable_randomization
13656 = remote_supports_disable_randomization;
13657 remote_ops.to_filesystem_is_local = remote_filesystem_is_local;
13658 remote_ops.to_fileio_open = remote_hostio_open;
13659 remote_ops.to_fileio_pwrite = remote_hostio_pwrite;
13660 remote_ops.to_fileio_pread = remote_hostio_pread;
13661 remote_ops.to_fileio_fstat = remote_hostio_fstat;
13662 remote_ops.to_fileio_close = remote_hostio_close;
13663 remote_ops.to_fileio_unlink = remote_hostio_unlink;
13664 remote_ops.to_fileio_readlink = remote_hostio_readlink;
13665 remote_ops.to_supports_enable_disable_tracepoint = remote_supports_enable_disable_tracepoint;
13666 remote_ops.to_supports_string_tracing = remote_supports_string_tracing;
13667 remote_ops.to_supports_evaluation_of_breakpoint_conditions = remote_supports_cond_breakpoints;
13668 remote_ops.to_can_run_breakpoint_commands = remote_can_run_breakpoint_commands;
13669 remote_ops.to_trace_init = remote_trace_init;
13670 remote_ops.to_download_tracepoint = remote_download_tracepoint;
13671 remote_ops.to_can_download_tracepoint = remote_can_download_tracepoint;
13672 remote_ops.to_download_trace_state_variable
13673 = remote_download_trace_state_variable;
13674 remote_ops.to_enable_tracepoint = remote_enable_tracepoint;
13675 remote_ops.to_disable_tracepoint = remote_disable_tracepoint;
13676 remote_ops.to_trace_set_readonly_regions = remote_trace_set_readonly_regions;
13677 remote_ops.to_trace_start = remote_trace_start;
13678 remote_ops.to_get_trace_status = remote_get_trace_status;
13679 remote_ops.to_get_tracepoint_status = remote_get_tracepoint_status;
13680 remote_ops.to_trace_stop = remote_trace_stop;
13681 remote_ops.to_trace_find = remote_trace_find;
13682 remote_ops.to_get_trace_state_variable_value
13683 = remote_get_trace_state_variable_value;
13684 remote_ops.to_save_trace_data = remote_save_trace_data;
13685 remote_ops.to_upload_tracepoints = remote_upload_tracepoints;
13686 remote_ops.to_upload_trace_state_variables
13687 = remote_upload_trace_state_variables;
13688 remote_ops.to_get_raw_trace_data = remote_get_raw_trace_data;
13689 remote_ops.to_get_min_fast_tracepoint_insn_len = remote_get_min_fast_tracepoint_insn_len;
13690 remote_ops.to_set_disconnected_tracing = remote_set_disconnected_tracing;
13691 remote_ops.to_set_circular_trace_buffer = remote_set_circular_trace_buffer;
13692 remote_ops.to_set_trace_buffer_size = remote_set_trace_buffer_size;
13693 remote_ops.to_set_trace_notes = remote_set_trace_notes;
13694 remote_ops.to_core_of_thread = remote_core_of_thread;
13695 remote_ops.to_verify_memory = remote_verify_memory;
13696 remote_ops.to_get_tib_address = remote_get_tib_address;
13697 remote_ops.to_set_permissions = remote_set_permissions;
13698 remote_ops.to_static_tracepoint_marker_at
13699 = remote_static_tracepoint_marker_at;
13700 remote_ops.to_static_tracepoint_markers_by_strid
13701 = remote_static_tracepoint_markers_by_strid;
13702 remote_ops.to_traceframe_info = remote_traceframe_info;
13703 remote_ops.to_use_agent = remote_use_agent;
13704 remote_ops.to_can_use_agent = remote_can_use_agent;
13705 remote_ops.to_supports_btrace = remote_supports_btrace;
13706 remote_ops.to_enable_btrace = remote_enable_btrace;
13707 remote_ops.to_disable_btrace = remote_disable_btrace;
13708 remote_ops.to_teardown_btrace = remote_teardown_btrace;
13709 remote_ops.to_read_btrace = remote_read_btrace;
13710 remote_ops.to_btrace_conf = remote_btrace_conf;
13711 remote_ops.to_augmented_libraries_svr4_read =
13712 remote_augmented_libraries_svr4_read;
13713 remote_ops.to_follow_fork = remote_follow_fork;
13714 remote_ops.to_follow_exec = remote_follow_exec;
13715 remote_ops.to_insert_fork_catchpoint = remote_insert_fork_catchpoint;
13716 remote_ops.to_remove_fork_catchpoint = remote_remove_fork_catchpoint;
13717 remote_ops.to_insert_vfork_catchpoint = remote_insert_vfork_catchpoint;
13718 remote_ops.to_remove_vfork_catchpoint = remote_remove_vfork_catchpoint;
13719 remote_ops.to_insert_exec_catchpoint = remote_insert_exec_catchpoint;
13720 remote_ops.to_remove_exec_catchpoint = remote_remove_exec_catchpoint;
13721 remote_ops.to_execution_direction = remote_execution_direction;
13722 remote_ops.to_thread_handle_to_thread_info =
13723 remote_thread_handle_to_thread_info;
13724 }
13725
13726 /* Set up the extended remote vector by making a copy of the standard
13727 remote vector and adding to it. */
13728
13729 static void
13730 init_extended_remote_ops (void)
13731 {
13732 extended_remote_ops = remote_ops;
13733
13734 extended_remote_ops.to_shortname = "extended-remote";
13735 extended_remote_ops.to_longname =
13736 "Extended remote serial target in gdb-specific protocol";
13737 extended_remote_ops.to_doc =
13738 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13739 Specify the serial device it is connected to (e.g. /dev/ttya).";
13740 extended_remote_ops.to_open = extended_remote_open;
13741 extended_remote_ops.to_create_inferior = extended_remote_create_inferior;
13742 extended_remote_ops.to_detach = extended_remote_detach;
13743 extended_remote_ops.to_attach = extended_remote_attach;
13744 extended_remote_ops.to_post_attach = extended_remote_post_attach;
13745 extended_remote_ops.to_supports_disable_randomization
13746 = extended_remote_supports_disable_randomization;
13747 }
13748
13749 static int
13750 remote_can_async_p (struct target_ops *ops)
13751 {
13752 struct remote_state *rs = get_remote_state ();
13753
13754 /* We don't go async if the user has explicitly prevented it with the
13755 "maint set target-async" command. */
13756 if (!target_async_permitted)
13757 return 0;
13758
13759 /* We're async whenever the serial device is. */
13760 return serial_can_async_p (rs->remote_desc);
13761 }
13762
13763 static int
13764 remote_is_async_p (struct target_ops *ops)
13765 {
13766 struct remote_state *rs = get_remote_state ();
13767
13768 if (!target_async_permitted)
13769 /* We only enable async when the user specifically asks for it. */
13770 return 0;
13771
13772 /* We're async whenever the serial device is. */
13773 return serial_is_async_p (rs->remote_desc);
13774 }
13775
13776 /* Pass the SERIAL event on and up to the client. One day this code
13777 will be able to delay notifying the client of an event until the
13778 point where an entire packet has been received. */
13779
13780 static serial_event_ftype remote_async_serial_handler;
13781
13782 static void
13783 remote_async_serial_handler (struct serial *scb, void *context)
13784 {
13785 /* Don't propogate error information up to the client. Instead let
13786 the client find out about the error by querying the target. */
13787 inferior_event_handler (INF_REG_EVENT, NULL);
13788 }
13789
13790 static void
13791 remote_async_inferior_event_handler (gdb_client_data data)
13792 {
13793 inferior_event_handler (INF_REG_EVENT, NULL);
13794 }
13795
13796 static void
13797 remote_async (struct target_ops *ops, int enable)
13798 {
13799 struct remote_state *rs = get_remote_state ();
13800
13801 if (enable)
13802 {
13803 serial_async (rs->remote_desc, remote_async_serial_handler, rs);
13804
13805 /* If there are pending events in the stop reply queue tell the
13806 event loop to process them. */
13807 if (!QUEUE_is_empty (stop_reply_p, stop_reply_queue))
13808 mark_async_event_handler (remote_async_inferior_event_token);
13809 /* For simplicity, below we clear the pending events token
13810 without remembering whether it is marked, so here we always
13811 mark it. If there's actually no pending notification to
13812 process, this ends up being a no-op (other than a spurious
13813 event-loop wakeup). */
13814 if (target_is_non_stop_p ())
13815 mark_async_event_handler (rs->notif_state->get_pending_events_token);
13816 }
13817 else
13818 {
13819 serial_async (rs->remote_desc, NULL, NULL);
13820 /* If the core is disabling async, it doesn't want to be
13821 disturbed with target events. Clear all async event sources
13822 too. */
13823 clear_async_event_handler (remote_async_inferior_event_token);
13824 if (target_is_non_stop_p ())
13825 clear_async_event_handler (rs->notif_state->get_pending_events_token);
13826 }
13827 }
13828
13829 /* Implementation of the to_thread_events method. */
13830
13831 static void
13832 remote_thread_events (struct target_ops *ops, int enable)
13833 {
13834 struct remote_state *rs = get_remote_state ();
13835 size_t size = get_remote_packet_size ();
13836
13837 if (packet_support (PACKET_QThreadEvents) == PACKET_DISABLE)
13838 return;
13839
13840 xsnprintf (rs->buf, size, "QThreadEvents:%x", enable ? 1 : 0);
13841 putpkt (rs->buf);
13842 getpkt (&rs->buf, &rs->buf_size, 0);
13843
13844 switch (packet_ok (rs->buf,
13845 &remote_protocol_packets[PACKET_QThreadEvents]))
13846 {
13847 case PACKET_OK:
13848 if (strcmp (rs->buf, "OK") != 0)
13849 error (_("Remote refused setting thread events: %s"), rs->buf);
13850 break;
13851 case PACKET_ERROR:
13852 warning (_("Remote failure reply: %s"), rs->buf);
13853 break;
13854 case PACKET_UNKNOWN:
13855 break;
13856 }
13857 }
13858
13859 static void
13860 set_remote_cmd (const char *args, int from_tty)
13861 {
13862 help_list (remote_set_cmdlist, "set remote ", all_commands, gdb_stdout);
13863 }
13864
13865 static void
13866 show_remote_cmd (const char *args, int from_tty)
13867 {
13868 /* We can't just use cmd_show_list here, because we want to skip
13869 the redundant "show remote Z-packet" and the legacy aliases. */
13870 struct cmd_list_element *list = remote_show_cmdlist;
13871 struct ui_out *uiout = current_uiout;
13872
13873 ui_out_emit_tuple tuple_emitter (uiout, "showlist");
13874 for (; list != NULL; list = list->next)
13875 if (strcmp (list->name, "Z-packet") == 0)
13876 continue;
13877 else if (list->type == not_set_cmd)
13878 /* Alias commands are exactly like the original, except they
13879 don't have the normal type. */
13880 continue;
13881 else
13882 {
13883 ui_out_emit_tuple option_emitter (uiout, "option");
13884
13885 uiout->field_string ("name", list->name);
13886 uiout->text (": ");
13887 if (list->type == show_cmd)
13888 do_show_command (NULL, from_tty, list);
13889 else
13890 cmd_func (list, NULL, from_tty);
13891 }
13892 }
13893
13894
13895 /* Function to be called whenever a new objfile (shlib) is detected. */
13896 static void
13897 remote_new_objfile (struct objfile *objfile)
13898 {
13899 struct remote_state *rs = get_remote_state ();
13900
13901 if (rs->remote_desc != 0) /* Have a remote connection. */
13902 remote_check_symbols ();
13903 }
13904
13905 /* Pull all the tracepoints defined on the target and create local
13906 data structures representing them. We don't want to create real
13907 tracepoints yet, we don't want to mess up the user's existing
13908 collection. */
13909
13910 static int
13911 remote_upload_tracepoints (struct target_ops *self, struct uploaded_tp **utpp)
13912 {
13913 struct remote_state *rs = get_remote_state ();
13914 char *p;
13915
13916 /* Ask for a first packet of tracepoint definition. */
13917 putpkt ("qTfP");
13918 getpkt (&rs->buf, &rs->buf_size, 0);
13919 p = rs->buf;
13920 while (*p && *p != 'l')
13921 {
13922 parse_tracepoint_definition (p, utpp);
13923 /* Ask for another packet of tracepoint definition. */
13924 putpkt ("qTsP");
13925 getpkt (&rs->buf, &rs->buf_size, 0);
13926 p = rs->buf;
13927 }
13928 return 0;
13929 }
13930
13931 static int
13932 remote_upload_trace_state_variables (struct target_ops *self,
13933 struct uploaded_tsv **utsvp)
13934 {
13935 struct remote_state *rs = get_remote_state ();
13936 char *p;
13937
13938 /* Ask for a first packet of variable definition. */
13939 putpkt ("qTfV");
13940 getpkt (&rs->buf, &rs->buf_size, 0);
13941 p = rs->buf;
13942 while (*p && *p != 'l')
13943 {
13944 parse_tsv_definition (p, utsvp);
13945 /* Ask for another packet of variable definition. */
13946 putpkt ("qTsV");
13947 getpkt (&rs->buf, &rs->buf_size, 0);
13948 p = rs->buf;
13949 }
13950 return 0;
13951 }
13952
13953 /* The "set/show range-stepping" show hook. */
13954
13955 static void
13956 show_range_stepping (struct ui_file *file, int from_tty,
13957 struct cmd_list_element *c,
13958 const char *value)
13959 {
13960 fprintf_filtered (file,
13961 _("Debugger's willingness to use range stepping "
13962 "is %s.\n"), value);
13963 }
13964
13965 /* The "set/show range-stepping" set hook. */
13966
13967 static void
13968 set_range_stepping (const char *ignore_args, int from_tty,
13969 struct cmd_list_element *c)
13970 {
13971 struct remote_state *rs = get_remote_state ();
13972
13973 /* Whene enabling, check whether range stepping is actually
13974 supported by the target, and warn if not. */
13975 if (use_range_stepping)
13976 {
13977 if (rs->remote_desc != NULL)
13978 {
13979 if (packet_support (PACKET_vCont) == PACKET_SUPPORT_UNKNOWN)
13980 remote_vcont_probe (rs);
13981
13982 if (packet_support (PACKET_vCont) == PACKET_ENABLE
13983 && rs->supports_vCont.r)
13984 return;
13985 }
13986
13987 warning (_("Range stepping is not supported by the current target"));
13988 }
13989 }
13990
13991 void
13992 _initialize_remote (void)
13993 {
13994 struct cmd_list_element *cmd;
13995 const char *cmd_name;
13996
13997 /* architecture specific data */
13998 remote_gdbarch_data_handle =
13999 gdbarch_data_register_post_init (init_remote_state);
14000 remote_g_packet_data_handle =
14001 gdbarch_data_register_pre_init (remote_g_packet_data_init);
14002
14003 remote_pspace_data
14004 = register_program_space_data_with_cleanup (NULL,
14005 remote_pspace_data_cleanup);
14006
14007 /* Initialize the per-target state. At the moment there is only one
14008 of these, not one per target. Only one target is active at a
14009 time. */
14010 remote_state = new_remote_state ();
14011
14012 init_remote_ops ();
14013 add_target (&remote_ops);
14014
14015 init_extended_remote_ops ();
14016 add_target (&extended_remote_ops);
14017
14018 /* Hook into new objfile notification. */
14019 observer_attach_new_objfile (remote_new_objfile);
14020 /* We're no longer interested in notification events of an inferior
14021 when it exits. */
14022 observer_attach_inferior_exit (discard_pending_stop_replies);
14023
14024 #if 0
14025 init_remote_threadtests ();
14026 #endif
14027
14028 stop_reply_queue = QUEUE_alloc (stop_reply_p, stop_reply_xfree);
14029 /* set/show remote ... */
14030
14031 add_prefix_cmd ("remote", class_maintenance, set_remote_cmd, _("\
14032 Remote protocol specific variables\n\
14033 Configure various remote-protocol specific variables such as\n\
14034 the packets being used"),
14035 &remote_set_cmdlist, "set remote ",
14036 0 /* allow-unknown */, &setlist);
14037 add_prefix_cmd ("remote", class_maintenance, show_remote_cmd, _("\
14038 Remote protocol specific variables\n\
14039 Configure various remote-protocol specific variables such as\n\
14040 the packets being used"),
14041 &remote_show_cmdlist, "show remote ",
14042 0 /* allow-unknown */, &showlist);
14043
14044 add_cmd ("compare-sections", class_obscure, compare_sections_command, _("\
14045 Compare section data on target to the exec file.\n\
14046 Argument is a single section name (default: all loaded sections).\n\
14047 To compare only read-only loaded sections, specify the -r option."),
14048 &cmdlist);
14049
14050 add_cmd ("packet", class_maintenance, packet_command, _("\
14051 Send an arbitrary packet to a remote target.\n\
14052 maintenance packet TEXT\n\
14053 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14054 this command sends the string TEXT to the inferior, and displays the\n\
14055 response packet. GDB supplies the initial `$' character, and the\n\
14056 terminating `#' character and checksum."),
14057 &maintenancelist);
14058
14059 add_setshow_boolean_cmd ("remotebreak", no_class, &remote_break, _("\
14060 Set whether to send break if interrupted."), _("\
14061 Show whether to send break if interrupted."), _("\
14062 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14063 set_remotebreak, show_remotebreak,
14064 &setlist, &showlist);
14065 cmd_name = "remotebreak";
14066 cmd = lookup_cmd (&cmd_name, setlist, "", -1, 1);
14067 deprecate_cmd (cmd, "set remote interrupt-sequence");
14068 cmd_name = "remotebreak"; /* needed because lookup_cmd updates the pointer */
14069 cmd = lookup_cmd (&cmd_name, showlist, "", -1, 1);
14070 deprecate_cmd (cmd, "show remote interrupt-sequence");
14071
14072 add_setshow_enum_cmd ("interrupt-sequence", class_support,
14073 interrupt_sequence_modes, &interrupt_sequence_mode,
14074 _("\
14075 Set interrupt sequence to remote target."), _("\
14076 Show interrupt sequence to remote target."), _("\
14077 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14078 NULL, show_interrupt_sequence,
14079 &remote_set_cmdlist,
14080 &remote_show_cmdlist);
14081
14082 add_setshow_boolean_cmd ("interrupt-on-connect", class_support,
14083 &interrupt_on_connect, _("\
14084 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14085 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14086 If set, interrupt sequence is sent to remote target."),
14087 NULL, NULL,
14088 &remote_set_cmdlist, &remote_show_cmdlist);
14089
14090 /* Install commands for configuring memory read/write packets. */
14091
14092 add_cmd ("remotewritesize", no_class, set_memory_write_packet_size, _("\
14093 Set the maximum number of bytes per memory write packet (deprecated)."),
14094 &setlist);
14095 add_cmd ("remotewritesize", no_class, show_memory_write_packet_size, _("\
14096 Show the maximum number of bytes per memory write packet (deprecated)."),
14097 &showlist);
14098 add_cmd ("memory-write-packet-size", no_class,
14099 set_memory_write_packet_size, _("\
14100 Set the maximum number of bytes per memory-write packet.\n\
14101 Specify the number of bytes in a packet or 0 (zero) for the\n\
14102 default packet size. The actual limit is further reduced\n\
14103 dependent on the target. Specify ``fixed'' to disable the\n\
14104 further restriction and ``limit'' to enable that restriction."),
14105 &remote_set_cmdlist);
14106 add_cmd ("memory-read-packet-size", no_class,
14107 set_memory_read_packet_size, _("\
14108 Set the maximum number of bytes per memory-read packet.\n\
14109 Specify the number of bytes in a packet or 0 (zero) for the\n\
14110 default packet size. The actual limit is further reduced\n\
14111 dependent on the target. Specify ``fixed'' to disable the\n\
14112 further restriction and ``limit'' to enable that restriction."),
14113 &remote_set_cmdlist);
14114 add_cmd ("memory-write-packet-size", no_class,
14115 show_memory_write_packet_size,
14116 _("Show the maximum number of bytes per memory-write packet."),
14117 &remote_show_cmdlist);
14118 add_cmd ("memory-read-packet-size", no_class,
14119 show_memory_read_packet_size,
14120 _("Show the maximum number of bytes per memory-read packet."),
14121 &remote_show_cmdlist);
14122
14123 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class,
14124 &remote_hw_watchpoint_limit, _("\
14125 Set the maximum number of target hardware watchpoints."), _("\
14126 Show the maximum number of target hardware watchpoints."), _("\
14127 Specify a negative limit for unlimited."),
14128 NULL, NULL, /* FIXME: i18n: The maximum
14129 number of target hardware
14130 watchpoints is %s. */
14131 &remote_set_cmdlist, &remote_show_cmdlist);
14132 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class,
14133 &remote_hw_watchpoint_length_limit, _("\
14134 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14135 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14136 Specify a negative limit for unlimited."),
14137 NULL, NULL, /* FIXME: i18n: The maximum
14138 length (in bytes) of a target
14139 hardware watchpoint is %s. */
14140 &remote_set_cmdlist, &remote_show_cmdlist);
14141 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class,
14142 &remote_hw_breakpoint_limit, _("\
14143 Set the maximum number of target hardware breakpoints."), _("\
14144 Show the maximum number of target hardware breakpoints."), _("\
14145 Specify a negative limit for unlimited."),
14146 NULL, NULL, /* FIXME: i18n: The maximum
14147 number of target hardware
14148 breakpoints is %s. */
14149 &remote_set_cmdlist, &remote_show_cmdlist);
14150
14151 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure,
14152 &remote_address_size, _("\
14153 Set the maximum size of the address (in bits) in a memory packet."), _("\
14154 Show the maximum size of the address (in bits) in a memory packet."), NULL,
14155 NULL,
14156 NULL, /* FIXME: i18n: */
14157 &setlist, &showlist);
14158
14159 init_all_packet_configs ();
14160
14161 add_packet_config_cmd (&remote_protocol_packets[PACKET_X],
14162 "X", "binary-download", 1);
14163
14164 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCont],
14165 "vCont", "verbose-resume", 0);
14166
14167 add_packet_config_cmd (&remote_protocol_packets[PACKET_QPassSignals],
14168 "QPassSignals", "pass-signals", 0);
14169
14170 add_packet_config_cmd (&remote_protocol_packets[PACKET_QCatchSyscalls],
14171 "QCatchSyscalls", "catch-syscalls", 0);
14172
14173 add_packet_config_cmd (&remote_protocol_packets[PACKET_QProgramSignals],
14174 "QProgramSignals", "program-signals", 0);
14175
14176 add_packet_config_cmd (&remote_protocol_packets[PACKET_QSetWorkingDir],
14177 "QSetWorkingDir", "set-working-dir", 0);
14178
14179 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartupWithShell],
14180 "QStartupWithShell", "startup-with-shell", 0);
14181
14182 add_packet_config_cmd (&remote_protocol_packets
14183 [PACKET_QEnvironmentHexEncoded],
14184 "QEnvironmentHexEncoded", "environment-hex-encoded",
14185 0);
14186
14187 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentReset],
14188 "QEnvironmentReset", "environment-reset",
14189 0);
14190
14191 add_packet_config_cmd (&remote_protocol_packets[PACKET_QEnvironmentUnset],
14192 "QEnvironmentUnset", "environment-unset",
14193 0);
14194
14195 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSymbol],
14196 "qSymbol", "symbol-lookup", 0);
14197
14198 add_packet_config_cmd (&remote_protocol_packets[PACKET_P],
14199 "P", "set-register", 1);
14200
14201 add_packet_config_cmd (&remote_protocol_packets[PACKET_p],
14202 "p", "fetch-register", 1);
14203
14204 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z0],
14205 "Z0", "software-breakpoint", 0);
14206
14207 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z1],
14208 "Z1", "hardware-breakpoint", 0);
14209
14210 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z2],
14211 "Z2", "write-watchpoint", 0);
14212
14213 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z3],
14214 "Z3", "read-watchpoint", 0);
14215
14216 add_packet_config_cmd (&remote_protocol_packets[PACKET_Z4],
14217 "Z4", "access-watchpoint", 0);
14218
14219 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_auxv],
14220 "qXfer:auxv:read", "read-aux-vector", 0);
14221
14222 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_exec_file],
14223 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14224
14225 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_features],
14226 "qXfer:features:read", "target-features", 0);
14227
14228 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries],
14229 "qXfer:libraries:read", "library-info", 0);
14230
14231 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_libraries_svr4],
14232 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14233
14234 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_memory_map],
14235 "qXfer:memory-map:read", "memory-map", 0);
14236
14237 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_read],
14238 "qXfer:spu:read", "read-spu-object", 0);
14239
14240 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_spu_write],
14241 "qXfer:spu:write", "write-spu-object", 0);
14242
14243 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_osdata],
14244 "qXfer:osdata:read", "osdata", 0);
14245
14246 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_threads],
14247 "qXfer:threads:read", "threads", 0);
14248
14249 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_read],
14250 "qXfer:siginfo:read", "read-siginfo-object", 0);
14251
14252 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_siginfo_write],
14253 "qXfer:siginfo:write", "write-siginfo-object", 0);
14254
14255 add_packet_config_cmd
14256 (&remote_protocol_packets[PACKET_qXfer_traceframe_info],
14257 "qXfer:traceframe-info:read", "traceframe-info", 0);
14258
14259 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_uib],
14260 "qXfer:uib:read", "unwind-info-block", 0);
14261
14262 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTLSAddr],
14263 "qGetTLSAddr", "get-thread-local-storage-address",
14264 0);
14265
14266 add_packet_config_cmd (&remote_protocol_packets[PACKET_qGetTIBAddr],
14267 "qGetTIBAddr", "get-thread-information-block-address",
14268 0);
14269
14270 add_packet_config_cmd (&remote_protocol_packets[PACKET_bc],
14271 "bc", "reverse-continue", 0);
14272
14273 add_packet_config_cmd (&remote_protocol_packets[PACKET_bs],
14274 "bs", "reverse-step", 0);
14275
14276 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSupported],
14277 "qSupported", "supported-packets", 0);
14278
14279 add_packet_config_cmd (&remote_protocol_packets[PACKET_qSearch_memory],
14280 "qSearch:memory", "search-memory", 0);
14281
14282 add_packet_config_cmd (&remote_protocol_packets[PACKET_qTStatus],
14283 "qTStatus", "trace-status", 0);
14284
14285 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_setfs],
14286 "vFile:setfs", "hostio-setfs", 0);
14287
14288 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_open],
14289 "vFile:open", "hostio-open", 0);
14290
14291 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pread],
14292 "vFile:pread", "hostio-pread", 0);
14293
14294 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_pwrite],
14295 "vFile:pwrite", "hostio-pwrite", 0);
14296
14297 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_close],
14298 "vFile:close", "hostio-close", 0);
14299
14300 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_unlink],
14301 "vFile:unlink", "hostio-unlink", 0);
14302
14303 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_readlink],
14304 "vFile:readlink", "hostio-readlink", 0);
14305
14306 add_packet_config_cmd (&remote_protocol_packets[PACKET_vFile_fstat],
14307 "vFile:fstat", "hostio-fstat", 0);
14308
14309 add_packet_config_cmd (&remote_protocol_packets[PACKET_vAttach],
14310 "vAttach", "attach", 0);
14311
14312 add_packet_config_cmd (&remote_protocol_packets[PACKET_vRun],
14313 "vRun", "run", 0);
14314
14315 add_packet_config_cmd (&remote_protocol_packets[PACKET_QStartNoAckMode],
14316 "QStartNoAckMode", "noack", 0);
14317
14318 add_packet_config_cmd (&remote_protocol_packets[PACKET_vKill],
14319 "vKill", "kill", 0);
14320
14321 add_packet_config_cmd (&remote_protocol_packets[PACKET_qAttached],
14322 "qAttached", "query-attached", 0);
14323
14324 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalTracepoints],
14325 "ConditionalTracepoints",
14326 "conditional-tracepoints", 0);
14327
14328 add_packet_config_cmd (&remote_protocol_packets[PACKET_ConditionalBreakpoints],
14329 "ConditionalBreakpoints",
14330 "conditional-breakpoints", 0);
14331
14332 add_packet_config_cmd (&remote_protocol_packets[PACKET_BreakpointCommands],
14333 "BreakpointCommands",
14334 "breakpoint-commands", 0);
14335
14336 add_packet_config_cmd (&remote_protocol_packets[PACKET_FastTracepoints],
14337 "FastTracepoints", "fast-tracepoints", 0);
14338
14339 add_packet_config_cmd (&remote_protocol_packets[PACKET_TracepointSource],
14340 "TracepointSource", "TracepointSource", 0);
14341
14342 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAllow],
14343 "QAllow", "allow", 0);
14344
14345 add_packet_config_cmd (&remote_protocol_packets[PACKET_StaticTracepoints],
14346 "StaticTracepoints", "static-tracepoints", 0);
14347
14348 add_packet_config_cmd (&remote_protocol_packets[PACKET_InstallInTrace],
14349 "InstallInTrace", "install-in-trace", 0);
14350
14351 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_statictrace_read],
14352 "qXfer:statictrace:read", "read-sdata-object", 0);
14353
14354 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_fdpic],
14355 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14356
14357 add_packet_config_cmd (&remote_protocol_packets[PACKET_QDisableRandomization],
14358 "QDisableRandomization", "disable-randomization", 0);
14359
14360 add_packet_config_cmd (&remote_protocol_packets[PACKET_QAgent],
14361 "QAgent", "agent", 0);
14362
14363 add_packet_config_cmd (&remote_protocol_packets[PACKET_QTBuffer_size],
14364 "QTBuffer:size", "trace-buffer-size", 0);
14365
14366 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_off],
14367 "Qbtrace:off", "disable-btrace", 0);
14368
14369 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_bts],
14370 "Qbtrace:bts", "enable-btrace-bts", 0);
14371
14372 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_pt],
14373 "Qbtrace:pt", "enable-btrace-pt", 0);
14374
14375 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace],
14376 "qXfer:btrace", "read-btrace", 0);
14377
14378 add_packet_config_cmd (&remote_protocol_packets[PACKET_qXfer_btrace_conf],
14379 "qXfer:btrace-conf", "read-btrace-conf", 0);
14380
14381 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_bts_size],
14382 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14383
14384 add_packet_config_cmd (&remote_protocol_packets[PACKET_multiprocess_feature],
14385 "multiprocess-feature", "multiprocess-feature", 0);
14386
14387 add_packet_config_cmd (&remote_protocol_packets[PACKET_swbreak_feature],
14388 "swbreak-feature", "swbreak-feature", 0);
14389
14390 add_packet_config_cmd (&remote_protocol_packets[PACKET_hwbreak_feature],
14391 "hwbreak-feature", "hwbreak-feature", 0);
14392
14393 add_packet_config_cmd (&remote_protocol_packets[PACKET_fork_event_feature],
14394 "fork-event-feature", "fork-event-feature", 0);
14395
14396 add_packet_config_cmd (&remote_protocol_packets[PACKET_vfork_event_feature],
14397 "vfork-event-feature", "vfork-event-feature", 0);
14398
14399 add_packet_config_cmd (&remote_protocol_packets[PACKET_Qbtrace_conf_pt_size],
14400 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14401
14402 add_packet_config_cmd (&remote_protocol_packets[PACKET_vContSupported],
14403 "vContSupported", "verbose-resume-supported", 0);
14404
14405 add_packet_config_cmd (&remote_protocol_packets[PACKET_exec_event_feature],
14406 "exec-event-feature", "exec-event-feature", 0);
14407
14408 add_packet_config_cmd (&remote_protocol_packets[PACKET_vCtrlC],
14409 "vCtrlC", "ctrl-c", 0);
14410
14411 add_packet_config_cmd (&remote_protocol_packets[PACKET_QThreadEvents],
14412 "QThreadEvents", "thread-events", 0);
14413
14414 add_packet_config_cmd (&remote_protocol_packets[PACKET_no_resumed],
14415 "N stop reply", "no-resumed-stop-reply", 0);
14416
14417 /* Assert that we've registered "set remote foo-packet" commands
14418 for all packet configs. */
14419 {
14420 int i;
14421
14422 for (i = 0; i < PACKET_MAX; i++)
14423 {
14424 /* Ideally all configs would have a command associated. Some
14425 still don't though. */
14426 int excepted;
14427
14428 switch (i)
14429 {
14430 case PACKET_QNonStop:
14431 case PACKET_EnableDisableTracepoints_feature:
14432 case PACKET_tracenz_feature:
14433 case PACKET_DisconnectedTracing_feature:
14434 case PACKET_augmented_libraries_svr4_read_feature:
14435 case PACKET_qCRC:
14436 /* Additions to this list need to be well justified:
14437 pre-existing packets are OK; new packets are not. */
14438 excepted = 1;
14439 break;
14440 default:
14441 excepted = 0;
14442 break;
14443 }
14444
14445 /* This catches both forgetting to add a config command, and
14446 forgetting to remove a packet from the exception list. */
14447 gdb_assert (excepted == (remote_protocol_packets[i].name == NULL));
14448 }
14449 }
14450
14451 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14452 Z sub-packet has its own set and show commands, but users may
14453 have sets to this variable in their .gdbinit files (or in their
14454 documentation). */
14455 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure,
14456 &remote_Z_packet_detect, _("\
14457 Set use of remote protocol `Z' packets"), _("\
14458 Show use of remote protocol `Z' packets "), _("\
14459 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14460 packets."),
14461 set_remote_protocol_Z_packet_cmd,
14462 show_remote_protocol_Z_packet_cmd,
14463 /* FIXME: i18n: Use of remote protocol
14464 `Z' packets is %s. */
14465 &remote_set_cmdlist, &remote_show_cmdlist);
14466
14467 add_prefix_cmd ("remote", class_files, remote_command, _("\
14468 Manipulate files on the remote system\n\
14469 Transfer files to and from the remote target system."),
14470 &remote_cmdlist, "remote ",
14471 0 /* allow-unknown */, &cmdlist);
14472
14473 add_cmd ("put", class_files, remote_put_command,
14474 _("Copy a local file to the remote system."),
14475 &remote_cmdlist);
14476
14477 add_cmd ("get", class_files, remote_get_command,
14478 _("Copy a remote file to the local system."),
14479 &remote_cmdlist);
14480
14481 add_cmd ("delete", class_files, remote_delete_command,
14482 _("Delete a remote file."),
14483 &remote_cmdlist);
14484
14485 add_setshow_string_noescape_cmd ("exec-file", class_files,
14486 &remote_exec_file_var, _("\
14487 Set the remote pathname for \"run\""), _("\
14488 Show the remote pathname for \"run\""), NULL,
14489 set_remote_exec_file,
14490 show_remote_exec_file,
14491 &remote_set_cmdlist,
14492 &remote_show_cmdlist);
14493
14494 add_setshow_boolean_cmd ("range-stepping", class_run,
14495 &use_range_stepping, _("\
14496 Enable or disable range stepping."), _("\
14497 Show whether target-assisted range stepping is enabled."), _("\
14498 If on, and the target supports it, when stepping a source line, GDB\n\
14499 tells the target to step the corresponding range of addresses itself instead\n\
14500 of issuing multiple single-steps. This speeds up source level\n\
14501 stepping. If off, GDB always issues single-steps, even if range\n\
14502 stepping is supported by the target. The default is on."),
14503 set_range_stepping,
14504 show_range_stepping,
14505 &setlist,
14506 &showlist);
14507
14508 /* Eventually initialize fileio. See fileio.c */
14509 initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist);
14510
14511 /* Take advantage of the fact that the TID field is not used, to tag
14512 special ptids with it set to != 0. */
14513 magic_null_ptid = ptid_build (42000, -1, 1);
14514 not_sent_ptid = ptid_build (42000, -2, 1);
14515 any_thread_ptid = ptid_build (42000, 0, 1);
14516 }
This page took 0.542692 seconds and 5 git commands to generate.