1 /* Remote target communications for serial-line targets in custom GDB protocol
3 Copyright (C) 1988-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 /* See the GDB User Guide for details of the GDB remote protocol. */
30 /*#include "terminal.h" */
33 #include "gdb-stabs.h"
34 #include "gdbthread.h"
36 #include "remote-notif.h"
41 #include "cli/cli-decode.h"
42 #include "cli/cli-setshow.h"
43 #include "target-descriptions.h"
45 #include "filestuff.h"
50 #include "gdb_sys_time.h"
52 #include "event-loop.h"
53 #include "event-top.h"
59 #include "gdbcore.h" /* for exec_bfd */
61 #include "remote-fileio.h"
62 #include "gdb/fileio.h"
64 #include "xml-support.h"
66 #include "memory-map.h"
68 #include "tracepoint.h"
73 #include "record-btrace.h"
75 #include "common/scoped_restore.h"
77 #include "common/byte-vector.h"
79 /* Per-program-space data key. */
80 static const struct program_space_data
*remote_pspace_data
;
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
;
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.
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 };
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
);
105 static void remote_files_info (struct target_ops
*ignore
);
107 static void remote_prepare_to_store (struct target_ops
*self
,
108 struct regcache
*regcache
);
110 static void remote_open_1 (const char *, int, struct target_ops
*,
113 static void remote_close (struct target_ops
*self
);
117 static int remote_vkill (int pid
, struct remote_state
*rs
);
119 static void remote_kill_k (void);
121 static void remote_mourn (struct target_ops
*ops
);
123 static void extended_remote_restart (void);
125 static void remote_send (char **buf
, long *sizeof_buf_p
);
127 static int readchar (int timeout
);
129 static void remote_serial_write (const char *str
, int len
);
131 static void remote_kill (struct target_ops
*ops
);
133 static int remote_can_async_p (struct target_ops
*);
135 static int remote_is_async_p (struct target_ops
*);
137 static void remote_async (struct target_ops
*ops
, int enable
);
139 static void remote_thread_events (struct target_ops
*ops
, int enable
);
141 static void interrupt_query (void);
143 static void set_general_thread (ptid_t ptid
);
144 static void set_continue_thread (ptid_t ptid
);
146 static void get_offsets (void);
148 static void skip_frame (void);
150 static long read_frame (char **buf_p
, long *sizeof_buf
);
152 static int hexnumlen (ULONGEST num
);
154 static void init_remote_ops (void);
156 static void init_extended_remote_ops (void);
158 static void remote_stop (struct target_ops
*self
, ptid_t
);
160 static int stubhex (int ch
);
162 static int hexnumstr (char *, ULONGEST
);
164 static int hexnumnstr (char *, ULONGEST
, int);
166 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
168 static void print_packet (const char *);
170 static int stub_unpack_int (char *buff
, int fieldlength
);
172 static ptid_t
remote_current_thread (ptid_t oldptid
);
174 static int putpkt_binary (const char *buf
, int cnt
);
176 static void check_binary_download (CORE_ADDR addr
);
178 struct packet_config
;
180 static void show_packet_config_cmd (struct packet_config
*config
);
182 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
184 struct cmd_list_element
*c
,
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
);
190 static void remote_set_permissions (struct target_ops
*self
);
192 static int remote_get_trace_status (struct target_ops
*self
,
193 struct trace_status
*ts
);
195 static int remote_upload_tracepoints (struct target_ops
*self
,
196 struct uploaded_tp
**utpp
);
198 static int remote_upload_trace_state_variables (struct target_ops
*self
,
199 struct uploaded_tsv
**utsvp
);
201 static void remote_query_supported (void);
203 static void remote_check_symbols (void);
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
);
212 struct threads_listing_context
;
213 static void remove_new_fork_children (struct threads_listing_context
*);
215 static void remote_async_inferior_event_handler (gdb_client_data
);
217 static void remote_terminal_ours (struct target_ops
*self
);
219 static int remote_read_description_p (struct target_ops
*target
);
221 static void remote_console_output (char *msg
);
223 static int remote_supports_cond_breakpoints (struct target_ops
*self
);
225 static int remote_can_run_breakpoint_commands (struct target_ops
*self
);
227 static void remote_btrace_reset (void);
229 static void remote_btrace_maybe_reopen (void);
231 static int stop_reply_queue_length (void);
233 static void readahead_cache_invalidate (void);
235 static void remote_unpush_and_throw (void);
237 static struct remote_state
*get_remote_state (void);
241 static struct cmd_list_element
*remote_cmdlist
;
243 /* For "set remote" and "show remote". */
245 static struct cmd_list_element
*remote_set_cmdlist
;
246 static struct cmd_list_element
*remote_show_cmdlist
;
248 /* Stub vCont actions support.
250 Each field is a boolean flag indicating whether the stub reports
251 support for the corresponding action. */
253 struct vCont_action_support
268 /* Controls whether GDB is willing to use range stepping. */
270 static int use_range_stepping
= 1;
272 #define OPAQUETHREADBYTES 8
274 /* a 64 bit opaque identifier */
275 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
277 /* About this many threadisds fit in a packet. */
279 #define MAXTHREADLISTRESULTS 32
281 /* The max number of chars in debug output. The rest of chars are
284 #define REMOTE_DEBUG_MAX_CHAR 512
286 /* Data for the vFile:pread readahead cache. */
288 struct readahead_cache
290 /* The file descriptor for the file that is being cached. -1 if the
294 /* The offset into the file that the cache buffer corresponds
298 /* The buffer holding the cache contents. */
300 /* The buffer's size. We try to read as much as fits into a packet
304 /* Cache hit and miss counters. */
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. */
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
324 /* True if we're going through initial connection setup (finding out
325 about the remote side's threads, relocating symbols, etc.). */
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
;
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
;
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
348 /* True if we're connected in extended remote mode. */
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
;
359 /* The status of the stub support for the various vCont actions. */
360 struct vCont_action_support supports_vCont
;
362 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
363 responded to that. */
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
;
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
377 struct serial
*remote_desc
;
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
;
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
;
388 char *last_pass_packet
;
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
;
396 enum gdb_signal last_sent_signal
;
400 /* The execution direction of the last resume we got. */
401 enum exec_direction_kind last_resume_exec_dir
;
403 char *finished_object
;
404 char *finished_annex
;
405 ULONGEST finished_offset
;
407 /* Should we try the 'ThreadInfo' query packet?
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
;
417 threadref echo_nextthread
;
418 threadref nextthread
;
419 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
421 /* The state of remote notification. */
422 struct remote_notif_state
*notif_state
;
424 /* The branch trace configuration. */
425 struct btrace_config btrace_config
;
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. */
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
;
442 /* Private data that we'll store in (struct thread_info)->private. */
443 struct private_thread_info
449 /* Thread handle, perhaps a pthread_t or thread_t value, stored as a
450 sequence of bytes. */
451 gdb::byte_vector
*thread_handle
;
453 /* Whether the target stopped for a breakpoint/watchpoint. */
454 enum target_stop_reason stop_reason
;
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
;
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. */
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
;
470 /* The signal specified in the last target_resume call for this
472 enum gdb_signal last_resume_sig
;
474 /* Whether this thread was already vCont-resumed on the remote
480 free_private_thread_info (struct private_thread_info
*info
)
484 delete info
->thread_handle
;
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
492 static struct remote_state
*remote_state
;
494 static struct remote_state
*
495 get_remote_state_raw (void)
500 /* Allocate a new struct remote_state with xmalloc, initialize it, and
503 static struct remote_state
*
504 new_remote_state (void)
506 struct remote_state
*result
= XCNEW (struct remote_state
);
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
;
520 /* Description of the remote protocol for a given architecture. */
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);
530 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
534 struct remote_arch_state
536 /* Description of the remote protocol registers. */
537 long sizeof_g_packet
;
539 /* Description of the remote protocol registers indexed by REGNUM
540 (making an array gdbarch_num_regs in size). */
541 struct packet_reg
*regs
;
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
549 long actual_register_packet_size
;
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
;
556 /* Utility: generate error from an incoming stub packet. */
558 trace_error (char *buf
)
561 return; /* not an error msg */
564 case '1': /* malformed packet error */
565 if (*++buf
== '0') /* general case: */
566 error (_("remote.c: error in outgoing packet."));
568 error (_("remote.c: error in outgoing packet at field #%ld."),
569 strtol (buf
, NULL
, 16));
571 error (_("Target returns error code '%s'."), buf
);
575 /* Utility: wait for reply from stub, while accepting "O" packets. */
578 remote_get_noisy_reply ()
580 struct remote_state
*rs
= get_remote_state ();
582 do /* Loop on reply from remote stub. */
586 QUIT
; /* Allow user to bail out with ^C. */
587 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
591 else if (startswith (buf
, "qRelocInsn:"))
594 CORE_ADDR from
, to
, org_to
;
596 int adjusted_size
= 0;
599 p
= buf
+ strlen ("qRelocInsn:");
600 pp
= unpack_varlen_hex (p
, &ul
);
602 error (_("invalid qRelocInsn packet: %s"), buf
);
606 unpack_varlen_hex (p
, &ul
);
613 gdbarch_relocate_instruction (target_gdbarch (), &to
, from
);
616 CATCH (ex
, RETURN_MASK_ALL
)
618 if (ex
.error
== MEMORY_ERROR
)
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. */
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
630 exception_fprintf (gdb_stderr
, ex
,
631 _("warning: relocating instruction: "));
639 adjusted_size
= to
- org_to
;
641 xsnprintf (buf
, rs
->buf_size
, "qRelocInsn:%x", adjusted_size
);
645 else if (buf
[0] == 'O' && buf
[1] != 'K')
646 remote_console_output (buf
+ 1); /* 'O' message from stub */
648 return buf
; /* Here's the actual reply. */
653 /* Handle for retreving the remote protocol data from gdbarch. */
654 static struct gdbarch_data
*remote_gdbarch_data_handle
;
656 static struct remote_arch_state
*
657 get_remote_arch_state (void)
659 gdb_assert (target_gdbarch () != NULL
);
660 return ((struct remote_arch_state
*)
661 gdbarch_data (target_gdbarch (), remote_gdbarch_data_handle
));
664 /* Fetch the global remote target state. */
666 static struct remote_state
*
667 get_remote_state (void)
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
674 get_remote_arch_state ();
676 return get_remote_state_raw ();
679 /* Cleanup routine for the remote module's pspace data. */
682 remote_pspace_data_cleanup (struct program_space
*pspace
, void *arg
)
684 char *remote_exec_file
= (char *) arg
;
686 xfree (remote_exec_file
);
689 /* Fetch the remote exec-file from the current program space. */
692 get_remote_exec_file (void)
694 char *remote_exec_file
;
697 = (char *) program_space_data (current_program_space
,
699 if (remote_exec_file
== NULL
)
702 return remote_exec_file
;
705 /* Set the remote exec file for PSPACE. */
708 set_pspace_remote_exec_file (struct program_space
*pspace
,
709 char *remote_exec_file
)
711 char *old_file
= (char *) program_space_data (pspace
, remote_pspace_data
);
714 set_program_space_data (pspace
, remote_pspace_data
,
715 xstrdup (remote_exec_file
));
718 /* The "set/show remote exec-file" set command hook. */
721 set_remote_exec_file (char *ignored
, int from_tty
,
722 struct cmd_list_element
*c
)
724 gdb_assert (remote_exec_file_var
!= NULL
);
725 set_pspace_remote_exec_file (current_program_space
, remote_exec_file_var
);
728 /* The "set/show remote exec-file" show command hook. */
731 show_remote_exec_file (struct ui_file
*file
, int from_tty
,
732 struct cmd_list_element
*cmd
, const char *value
)
734 fprintf_filtered (file
, "%s\n", remote_exec_file_var
);
738 compare_pnums (const void *lhs_
, const void *rhs_
)
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_
;
745 if ((*lhs
)->pnum
< (*rhs
)->pnum
)
747 else if ((*lhs
)->pnum
== (*rhs
)->pnum
)
754 map_regcache_remote_table (struct gdbarch
*gdbarch
, struct packet_reg
*regs
)
756 int regnum
, num_remote_regs
, offset
;
757 struct packet_reg
**remote_regs
;
759 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
761 struct packet_reg
*r
= ®s
[regnum
];
763 if (register_size (gdbarch
, regnum
) == 0)
764 /* Do not try to fetch zero-sized (placeholder) registers. */
767 r
->pnum
= gdbarch_remote_register_number (gdbarch
, regnum
);
772 /* Define the g/G packet format as the contents of each register
773 with a remote protocol number, in order of ascending protocol
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
);
780 if (regs
[regnum
].pnum
!= -1)
781 remote_regs
[num_remote_regs
++] = ®s
[regnum
];
783 qsort (remote_regs
, num_remote_regs
, sizeof (struct packet_reg
*),
786 for (regnum
= 0, offset
= 0; regnum
< num_remote_regs
; regnum
++)
788 remote_regs
[regnum
]->in_g_packet
= 1;
789 remote_regs
[regnum
]->offset
= offset
;
790 offset
+= register_size (gdbarch
, remote_regs
[regnum
]->regnum
);
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. */
803 remote_register_number_and_offset (struct gdbarch
*gdbarch
, int regnum
,
804 int *pnum
, int *poffset
)
806 struct packet_reg
*regs
;
807 struct cleanup
*old_chain
;
809 gdb_assert (regnum
< gdbarch_num_regs (gdbarch
));
811 regs
= XCNEWVEC (struct packet_reg
, gdbarch_num_regs (gdbarch
));
812 old_chain
= make_cleanup (xfree
, regs
);
814 map_regcache_remote_table (gdbarch
, regs
);
816 *pnum
= regs
[regnum
].pnum
;
817 *poffset
= regs
[regnum
].offset
;
819 do_cleanups (old_chain
);
825 init_remote_state (struct gdbarch
*gdbarch
)
827 struct remote_state
*rs
= get_remote_state_raw ();
828 struct remote_arch_state
*rsa
;
830 rsa
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct remote_arch_state
);
832 /* Use the architecture to build a regnum<->pnum table, which will be
833 1:1 unless a feature set specifies otherwise. */
834 rsa
->regs
= GDBARCH_OBSTACK_CALLOC (gdbarch
,
835 gdbarch_num_regs (gdbarch
),
838 /* Record the maximum possible size of the g packet - it may turn out
840 rsa
->sizeof_g_packet
= map_regcache_remote_table (gdbarch
, rsa
->regs
);
842 /* Default maximum number of characters in a packet body. Many
843 remote stubs have a hardwired buffer size of 400 bytes
844 (c.f. BUFMAX in m68k-stub.c and i386-stub.c). BUFMAX-1 is used
845 as the maximum packet-size to ensure that the packet and an extra
846 NUL character can always fit in the buffer. This stops GDB
847 trashing stubs that try to squeeze an extra NUL into what is
848 already a full buffer (As of 1999-12-04 that was most stubs). */
849 rsa
->remote_packet_size
= 400 - 1;
851 /* This one is filled in when a ``g'' packet is received. */
852 rsa
->actual_register_packet_size
= 0;
854 /* Should rsa->sizeof_g_packet needs more space than the
855 default, adjust the size accordingly. Remember that each byte is
856 encoded as two characters. 32 is the overhead for the packet
857 header / footer. NOTE: cagney/1999-10-26: I suspect that 8
858 (``$NN:G...#NN'') is a better guess, the below has been padded a
860 if (rsa
->sizeof_g_packet
> ((rsa
->remote_packet_size
- 32) / 2))
861 rsa
->remote_packet_size
= (rsa
->sizeof_g_packet
* 2 + 32);
863 /* Make sure that the packet buffer is plenty big enough for
864 this architecture. */
865 if (rs
->buf_size
< rsa
->remote_packet_size
)
867 rs
->buf_size
= 2 * rsa
->remote_packet_size
;
868 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
874 /* Return the current allowed size of a remote packet. This is
875 inferred from the current architecture, and should be used to
876 limit the length of outgoing packets. */
878 get_remote_packet_size (void)
880 struct remote_state
*rs
= get_remote_state ();
881 struct remote_arch_state
*rsa
= get_remote_arch_state ();
883 if (rs
->explicit_packet_size
)
884 return rs
->explicit_packet_size
;
886 return rsa
->remote_packet_size
;
889 static struct packet_reg
*
890 packet_reg_from_regnum (struct remote_arch_state
*rsa
, long regnum
)
892 if (regnum
< 0 && regnum
>= gdbarch_num_regs (target_gdbarch ()))
896 struct packet_reg
*r
= &rsa
->regs
[regnum
];
898 gdb_assert (r
->regnum
== regnum
);
903 static struct packet_reg
*
904 packet_reg_from_pnum (struct remote_arch_state
*rsa
, LONGEST pnum
)
908 for (i
= 0; i
< gdbarch_num_regs (target_gdbarch ()); i
++)
910 struct packet_reg
*r
= &rsa
->regs
[i
];
918 static struct target_ops remote_ops
;
920 static struct target_ops extended_remote_ops
;
922 /* FIXME: cagney/1999-09-23: Even though getpkt was called with
923 ``forever'' still use the normal timeout mechanism. This is
924 currently used by the ASYNC code to guarentee that target reads
925 during the initial connect always time-out. Once getpkt has been
926 modified to return a timeout indication and, in turn
927 remote_wait()/wait_for_inferior() have gained a timeout parameter
929 static int wait_forever_enabled_p
= 1;
931 /* Allow the user to specify what sequence to send to the remote
932 when he requests a program interruption: Although ^C is usually
933 what remote systems expect (this is the default, here), it is
934 sometimes preferable to send a break. On other systems such
935 as the Linux kernel, a break followed by g, which is Magic SysRq g
936 is required in order to interrupt the execution. */
937 const char interrupt_sequence_control_c
[] = "Ctrl-C";
938 const char interrupt_sequence_break
[] = "BREAK";
939 const char interrupt_sequence_break_g
[] = "BREAK-g";
940 static const char *const interrupt_sequence_modes
[] =
942 interrupt_sequence_control_c
,
943 interrupt_sequence_break
,
944 interrupt_sequence_break_g
,
947 static const char *interrupt_sequence_mode
= interrupt_sequence_control_c
;
950 show_interrupt_sequence (struct ui_file
*file
, int from_tty
,
951 struct cmd_list_element
*c
,
954 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
955 fprintf_filtered (file
,
956 _("Send the ASCII ETX character (Ctrl-c) "
957 "to the remote target to interrupt the "
958 "execution of the program.\n"));
959 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
960 fprintf_filtered (file
,
961 _("send a break signal to the remote target "
962 "to interrupt the execution of the program.\n"));
963 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
964 fprintf_filtered (file
,
965 _("Send a break signal and 'g' a.k.a. Magic SysRq g to "
966 "the remote target to interrupt the execution "
967 "of Linux kernel.\n"));
969 internal_error (__FILE__
, __LINE__
,
970 _("Invalid value for interrupt_sequence_mode: %s."),
971 interrupt_sequence_mode
);
974 /* This boolean variable specifies whether interrupt_sequence is sent
975 to the remote target when gdb connects to it.
976 This is mostly needed when you debug the Linux kernel: The Linux kernel
977 expects BREAK g which is Magic SysRq g for connecting gdb. */
978 static int interrupt_on_connect
= 0;
980 /* This variable is used to implement the "set/show remotebreak" commands.
981 Since these commands are now deprecated in favor of "set/show remote
982 interrupt-sequence", it no longer has any effect on the code. */
983 static int remote_break
;
986 set_remotebreak (char *args
, int from_tty
, struct cmd_list_element
*c
)
989 interrupt_sequence_mode
= interrupt_sequence_break
;
991 interrupt_sequence_mode
= interrupt_sequence_control_c
;
995 show_remotebreak (struct ui_file
*file
, int from_tty
,
996 struct cmd_list_element
*c
,
1001 /* This variable sets the number of bits in an address that are to be
1002 sent in a memory ("M" or "m") packet. Normally, after stripping
1003 leading zeros, the entire address would be sent. This variable
1004 restricts the address to REMOTE_ADDRESS_SIZE bits. HISTORY: The
1005 initial implementation of remote.c restricted the address sent in
1006 memory packets to ``host::sizeof long'' bytes - (typically 32
1007 bits). Consequently, for 64 bit targets, the upper 32 bits of an
1008 address was never sent. Since fixing this bug may cause a break in
1009 some remote targets this variable is principly provided to
1010 facilitate backward compatibility. */
1012 static unsigned int remote_address_size
;
1014 /* Temporary to track who currently owns the terminal. See
1015 remote_terminal_* for more details. */
1017 static int remote_async_terminal_ours_p
;
1020 /* User configurable variables for the number of characters in a
1021 memory read/write packet. MIN (rsa->remote_packet_size,
1022 rsa->sizeof_g_packet) is the default. Some targets need smaller
1023 values (fifo overruns, et.al.) and some users need larger values
1024 (speed up transfers). The variables ``preferred_*'' (the user
1025 request), ``current_*'' (what was actually set) and ``forced_*''
1026 (Positive - a soft limit, negative - a hard limit). */
1028 struct memory_packet_config
1035 /* The default max memory-write-packet-size. The 16k is historical.
1036 (It came from older GDB's using alloca for buffers and the
1037 knowledge (folklore?) that some hosts don't cope very well with
1038 large alloca calls.) */
1039 #define DEFAULT_MAX_MEMORY_PACKET_SIZE 16384
1041 /* The minimum remote packet size for memory transfers. Ensures we
1042 can write at least one byte. */
1043 #define MIN_MEMORY_PACKET_SIZE 20
1045 /* Compute the current size of a read/write packet. Since this makes
1046 use of ``actual_register_packet_size'' the computation is dynamic. */
1049 get_memory_packet_size (struct memory_packet_config
*config
)
1051 struct remote_state
*rs
= get_remote_state ();
1052 struct remote_arch_state
*rsa
= get_remote_arch_state ();
1055 if (config
->fixed_p
)
1057 if (config
->size
<= 0)
1058 what_they_get
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1060 what_they_get
= config
->size
;
1064 what_they_get
= get_remote_packet_size ();
1065 /* Limit the packet to the size specified by the user. */
1066 if (config
->size
> 0
1067 && what_they_get
> config
->size
)
1068 what_they_get
= config
->size
;
1070 /* Limit it to the size of the targets ``g'' response unless we have
1071 permission from the stub to use a larger packet size. */
1072 if (rs
->explicit_packet_size
== 0
1073 && rsa
->actual_register_packet_size
> 0
1074 && what_they_get
> rsa
->actual_register_packet_size
)
1075 what_they_get
= rsa
->actual_register_packet_size
;
1077 if (what_they_get
< MIN_MEMORY_PACKET_SIZE
)
1078 what_they_get
= MIN_MEMORY_PACKET_SIZE
;
1080 /* Make sure there is room in the global buffer for this packet
1081 (including its trailing NUL byte). */
1082 if (rs
->buf_size
< what_they_get
+ 1)
1084 rs
->buf_size
= 2 * what_they_get
;
1085 rs
->buf
= (char *) xrealloc (rs
->buf
, 2 * what_they_get
);
1088 return what_they_get
;
1091 /* Update the size of a read/write packet. If they user wants
1092 something really big then do a sanity check. */
1095 set_memory_packet_size (const char *args
, struct memory_packet_config
*config
)
1097 int fixed_p
= config
->fixed_p
;
1098 long size
= config
->size
;
1101 error (_("Argument required (integer, `fixed' or `limited')."));
1102 else if (strcmp (args
, "hard") == 0
1103 || strcmp (args
, "fixed") == 0)
1105 else if (strcmp (args
, "soft") == 0
1106 || strcmp (args
, "limit") == 0)
1112 size
= strtoul (args
, &end
, 0);
1114 error (_("Invalid %s (bad syntax)."), config
->name
);
1116 /* Instead of explicitly capping the size of a packet to or
1117 disallowing it, the user is allowed to set the size to
1118 something arbitrarily large. */
1121 /* So that the query shows the correct value. */
1123 size
= DEFAULT_MAX_MEMORY_PACKET_SIZE
;
1126 if (fixed_p
&& !config
->fixed_p
)
1128 if (! query (_("The target may not be able to correctly handle a %s\n"
1129 "of %ld bytes. Change the packet size? "),
1130 config
->name
, size
))
1131 error (_("Packet size not changed."));
1133 /* Update the config. */
1134 config
->fixed_p
= fixed_p
;
1135 config
->size
= size
;
1139 show_memory_packet_size (struct memory_packet_config
*config
)
1141 printf_filtered (_("The %s is %ld. "), config
->name
, config
->size
);
1142 if (config
->fixed_p
)
1143 printf_filtered (_("Packets are fixed at %ld bytes.\n"),
1144 get_memory_packet_size (config
));
1146 printf_filtered (_("Packets are limited to %ld bytes.\n"),
1147 get_memory_packet_size (config
));
1150 static struct memory_packet_config memory_write_packet_config
=
1152 "memory-write-packet-size",
1156 set_memory_write_packet_size (const char *args
, int from_tty
)
1158 set_memory_packet_size (args
, &memory_write_packet_config
);
1162 show_memory_write_packet_size (const char *args
, int from_tty
)
1164 show_memory_packet_size (&memory_write_packet_config
);
1168 get_memory_write_packet_size (void)
1170 return get_memory_packet_size (&memory_write_packet_config
);
1173 static struct memory_packet_config memory_read_packet_config
=
1175 "memory-read-packet-size",
1179 set_memory_read_packet_size (const char *args
, int from_tty
)
1181 set_memory_packet_size (args
, &memory_read_packet_config
);
1185 show_memory_read_packet_size (const char *args
, int from_tty
)
1187 show_memory_packet_size (&memory_read_packet_config
);
1191 get_memory_read_packet_size (void)
1193 long size
= get_memory_packet_size (&memory_read_packet_config
);
1195 /* FIXME: cagney/1999-11-07: Functions like getpkt() need to get an
1196 extra buffer size argument before the memory read size can be
1197 increased beyond this. */
1198 if (size
> get_remote_packet_size ())
1199 size
= get_remote_packet_size ();
1204 /* Generic configuration support for packets the stub optionally
1205 supports. Allows the user to specify the use of the packet as well
1206 as allowing GDB to auto-detect support in the remote stub. */
1210 PACKET_SUPPORT_UNKNOWN
= 0,
1215 struct packet_config
1220 /* If auto, GDB auto-detects support for this packet or feature,
1221 either through qSupported, or by trying the packet and looking
1222 at the response. If true, GDB assumes the target supports this
1223 packet. If false, the packet is disabled. Configs that don't
1224 have an associated command always have this set to auto. */
1225 enum auto_boolean detect
;
1227 /* Does the target support this packet? */
1228 enum packet_support support
;
1231 /* Analyze a packet's return value and update the packet config
1241 static enum packet_support
packet_config_support (struct packet_config
*config
);
1242 static enum packet_support
packet_support (int packet
);
1245 show_packet_config_cmd (struct packet_config
*config
)
1247 const char *support
= "internal-error";
1249 switch (packet_config_support (config
))
1252 support
= "enabled";
1254 case PACKET_DISABLE
:
1255 support
= "disabled";
1257 case PACKET_SUPPORT_UNKNOWN
:
1258 support
= "unknown";
1261 switch (config
->detect
)
1263 case AUTO_BOOLEAN_AUTO
:
1264 printf_filtered (_("Support for the `%s' packet "
1265 "is auto-detected, currently %s.\n"),
1266 config
->name
, support
);
1268 case AUTO_BOOLEAN_TRUE
:
1269 case AUTO_BOOLEAN_FALSE
:
1270 printf_filtered (_("Support for the `%s' packet is currently %s.\n"),
1271 config
->name
, support
);
1277 add_packet_config_cmd (struct packet_config
*config
, const char *name
,
1278 const char *title
, int legacy
)
1284 config
->name
= name
;
1285 config
->title
= title
;
1286 set_doc
= xstrprintf ("Set use of remote protocol `%s' (%s) packet",
1288 show_doc
= xstrprintf ("Show current use of remote "
1289 "protocol `%s' (%s) packet",
1291 /* set/show TITLE-packet {auto,on,off} */
1292 cmd_name
= xstrprintf ("%s-packet", title
);
1293 add_setshow_auto_boolean_cmd (cmd_name
, class_obscure
,
1294 &config
->detect
, set_doc
,
1295 show_doc
, NULL
, /* help_doc */
1297 show_remote_protocol_packet_cmd
,
1298 &remote_set_cmdlist
, &remote_show_cmdlist
);
1299 /* The command code copies the documentation strings. */
1302 /* set/show remote NAME-packet {auto,on,off} -- legacy. */
1307 legacy_name
= xstrprintf ("%s-packet", name
);
1308 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1309 &remote_set_cmdlist
);
1310 add_alias_cmd (legacy_name
, cmd_name
, class_obscure
, 0,
1311 &remote_show_cmdlist
);
1315 static enum packet_result
1316 packet_check_result (const char *buf
)
1320 /* The stub recognized the packet request. Check that the
1321 operation succeeded. */
1323 && isxdigit (buf
[1]) && isxdigit (buf
[2])
1325 /* "Enn" - definitly an error. */
1326 return PACKET_ERROR
;
1328 /* Always treat "E." as an error. This will be used for
1329 more verbose error messages, such as E.memtypes. */
1330 if (buf
[0] == 'E' && buf
[1] == '.')
1331 return PACKET_ERROR
;
1333 /* The packet may or may not be OK. Just assume it is. */
1337 /* The stub does not support the packet. */
1338 return PACKET_UNKNOWN
;
1341 static enum packet_result
1342 packet_ok (const char *buf
, struct packet_config
*config
)
1344 enum packet_result result
;
1346 if (config
->detect
!= AUTO_BOOLEAN_TRUE
1347 && config
->support
== PACKET_DISABLE
)
1348 internal_error (__FILE__
, __LINE__
,
1349 _("packet_ok: attempt to use a disabled packet"));
1351 result
= packet_check_result (buf
);
1356 /* The stub recognized the packet request. */
1357 if (config
->support
== PACKET_SUPPORT_UNKNOWN
)
1360 fprintf_unfiltered (gdb_stdlog
,
1361 "Packet %s (%s) is supported\n",
1362 config
->name
, config
->title
);
1363 config
->support
= PACKET_ENABLE
;
1366 case PACKET_UNKNOWN
:
1367 /* The stub does not support the packet. */
1368 if (config
->detect
== AUTO_BOOLEAN_AUTO
1369 && config
->support
== PACKET_ENABLE
)
1371 /* If the stub previously indicated that the packet was
1372 supported then there is a protocol error. */
1373 error (_("Protocol error: %s (%s) conflicting enabled responses."),
1374 config
->name
, config
->title
);
1376 else if (config
->detect
== AUTO_BOOLEAN_TRUE
)
1378 /* The user set it wrong. */
1379 error (_("Enabled packet %s (%s) not recognized by stub"),
1380 config
->name
, config
->title
);
1384 fprintf_unfiltered (gdb_stdlog
,
1385 "Packet %s (%s) is NOT supported\n",
1386 config
->name
, config
->title
);
1387 config
->support
= PACKET_DISABLE
;
1408 PACKET_vFile_pwrite
,
1410 PACKET_vFile_unlink
,
1411 PACKET_vFile_readlink
,
1414 PACKET_qXfer_features
,
1415 PACKET_qXfer_exec_file
,
1416 PACKET_qXfer_libraries
,
1417 PACKET_qXfer_libraries_svr4
,
1418 PACKET_qXfer_memory_map
,
1419 PACKET_qXfer_spu_read
,
1420 PACKET_qXfer_spu_write
,
1421 PACKET_qXfer_osdata
,
1422 PACKET_qXfer_threads
,
1423 PACKET_qXfer_statictrace_read
,
1424 PACKET_qXfer_traceframe_info
,
1430 PACKET_QPassSignals
,
1431 PACKET_QCatchSyscalls
,
1432 PACKET_QProgramSignals
,
1433 PACKET_QStartupWithShell
,
1434 PACKET_QEnvironmentHexEncoded
,
1435 PACKET_QEnvironmentReset
,
1436 PACKET_QEnvironmentUnset
,
1438 PACKET_qSearch_memory
,
1441 PACKET_QStartNoAckMode
,
1443 PACKET_qXfer_siginfo_read
,
1444 PACKET_qXfer_siginfo_write
,
1447 /* Support for conditional tracepoints. */
1448 PACKET_ConditionalTracepoints
,
1450 /* Support for target-side breakpoint conditions. */
1451 PACKET_ConditionalBreakpoints
,
1453 /* Support for target-side breakpoint commands. */
1454 PACKET_BreakpointCommands
,
1456 /* Support for fast tracepoints. */
1457 PACKET_FastTracepoints
,
1459 /* Support for static tracepoints. */
1460 PACKET_StaticTracepoints
,
1462 /* Support for installing tracepoints while a trace experiment is
1464 PACKET_InstallInTrace
,
1468 PACKET_TracepointSource
,
1471 PACKET_QDisableRandomization
,
1473 PACKET_QTBuffer_size
,
1477 PACKET_qXfer_btrace
,
1479 /* Support for the QNonStop packet. */
1482 /* Support for the QThreadEvents packet. */
1483 PACKET_QThreadEvents
,
1485 /* Support for multi-process extensions. */
1486 PACKET_multiprocess_feature
,
1488 /* Support for enabling and disabling tracepoints while a trace
1489 experiment is running. */
1490 PACKET_EnableDisableTracepoints_feature
,
1492 /* Support for collecting strings using the tracenz bytecode. */
1493 PACKET_tracenz_feature
,
1495 /* Support for continuing to run a trace experiment while GDB is
1497 PACKET_DisconnectedTracing_feature
,
1499 /* Support for qXfer:libraries-svr4:read with a non-empty annex. */
1500 PACKET_augmented_libraries_svr4_read_feature
,
1502 /* Support for the qXfer:btrace-conf:read packet. */
1503 PACKET_qXfer_btrace_conf
,
1505 /* Support for the Qbtrace-conf:bts:size packet. */
1506 PACKET_Qbtrace_conf_bts_size
,
1508 /* Support for swbreak+ feature. */
1509 PACKET_swbreak_feature
,
1511 /* Support for hwbreak+ feature. */
1512 PACKET_hwbreak_feature
,
1514 /* Support for fork events. */
1515 PACKET_fork_event_feature
,
1517 /* Support for vfork events. */
1518 PACKET_vfork_event_feature
,
1520 /* Support for the Qbtrace-conf:pt:size packet. */
1521 PACKET_Qbtrace_conf_pt_size
,
1523 /* Support for exec events. */
1524 PACKET_exec_event_feature
,
1526 /* Support for query supported vCont actions. */
1527 PACKET_vContSupported
,
1529 /* Support remote CTRL-C. */
1532 /* Support TARGET_WAITKIND_NO_RESUMED. */
1538 static struct packet_config remote_protocol_packets
[PACKET_MAX
];
1540 /* Returns the packet's corresponding "set remote foo-packet" command
1541 state. See struct packet_config for more details. */
1543 static enum auto_boolean
1544 packet_set_cmd_state (int packet
)
1546 return remote_protocol_packets
[packet
].detect
;
1549 /* Returns whether a given packet or feature is supported. This takes
1550 into account the state of the corresponding "set remote foo-packet"
1551 command, which may be used to bypass auto-detection. */
1553 static enum packet_support
1554 packet_config_support (struct packet_config
*config
)
1556 switch (config
->detect
)
1558 case AUTO_BOOLEAN_TRUE
:
1559 return PACKET_ENABLE
;
1560 case AUTO_BOOLEAN_FALSE
:
1561 return PACKET_DISABLE
;
1562 case AUTO_BOOLEAN_AUTO
:
1563 return config
->support
;
1565 gdb_assert_not_reached (_("bad switch"));
1569 /* Same as packet_config_support, but takes the packet's enum value as
1572 static enum packet_support
1573 packet_support (int packet
)
1575 struct packet_config
*config
= &remote_protocol_packets
[packet
];
1577 return packet_config_support (config
);
1581 show_remote_protocol_packet_cmd (struct ui_file
*file
, int from_tty
,
1582 struct cmd_list_element
*c
,
1585 struct packet_config
*packet
;
1587 for (packet
= remote_protocol_packets
;
1588 packet
< &remote_protocol_packets
[PACKET_MAX
];
1591 if (&packet
->detect
== c
->var
)
1593 show_packet_config_cmd (packet
);
1597 internal_error (__FILE__
, __LINE__
, _("Could not find config for %s"),
1601 /* Should we try one of the 'Z' requests? */
1605 Z_PACKET_SOFTWARE_BP
,
1606 Z_PACKET_HARDWARE_BP
,
1613 /* For compatibility with older distributions. Provide a ``set remote
1614 Z-packet ...'' command that updates all the Z packet types. */
1616 static enum auto_boolean remote_Z_packet_detect
;
1619 set_remote_protocol_Z_packet_cmd (char *args
, int from_tty
,
1620 struct cmd_list_element
*c
)
1624 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1625 remote_protocol_packets
[PACKET_Z0
+ i
].detect
= remote_Z_packet_detect
;
1629 show_remote_protocol_Z_packet_cmd (struct ui_file
*file
, int from_tty
,
1630 struct cmd_list_element
*c
,
1635 for (i
= 0; i
< NR_Z_PACKET_TYPES
; i
++)
1637 show_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
+ i
]);
1641 /* Returns true if the multi-process extensions are in effect. */
1644 remote_multi_process_p (struct remote_state
*rs
)
1646 return packet_support (PACKET_multiprocess_feature
) == PACKET_ENABLE
;
1649 /* Returns true if fork events are supported. */
1652 remote_fork_event_p (struct remote_state
*rs
)
1654 return packet_support (PACKET_fork_event_feature
) == PACKET_ENABLE
;
1657 /* Returns true if vfork events are supported. */
1660 remote_vfork_event_p (struct remote_state
*rs
)
1662 return packet_support (PACKET_vfork_event_feature
) == PACKET_ENABLE
;
1665 /* Returns true if exec events are supported. */
1668 remote_exec_event_p (struct remote_state
*rs
)
1670 return packet_support (PACKET_exec_event_feature
) == PACKET_ENABLE
;
1673 /* Insert fork catchpoint target routine. If fork events are enabled
1674 then return success, nothing more to do. */
1677 remote_insert_fork_catchpoint (struct target_ops
*ops
, int pid
)
1679 struct remote_state
*rs
= get_remote_state ();
1681 return !remote_fork_event_p (rs
);
1684 /* Remove fork catchpoint target routine. Nothing to do, just
1688 remote_remove_fork_catchpoint (struct target_ops
*ops
, int pid
)
1693 /* Insert vfork catchpoint target routine. If vfork events are enabled
1694 then return success, nothing more to do. */
1697 remote_insert_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1699 struct remote_state
*rs
= get_remote_state ();
1701 return !remote_vfork_event_p (rs
);
1704 /* Remove vfork catchpoint target routine. Nothing to do, just
1708 remote_remove_vfork_catchpoint (struct target_ops
*ops
, int pid
)
1713 /* Insert exec catchpoint target routine. If exec events are
1714 enabled, just return success. */
1717 remote_insert_exec_catchpoint (struct target_ops
*ops
, int pid
)
1719 struct remote_state
*rs
= get_remote_state ();
1721 return !remote_exec_event_p (rs
);
1724 /* Remove exec catchpoint target routine. Nothing to do, just
1728 remote_remove_exec_catchpoint (struct target_ops
*ops
, int pid
)
1734 /* Asynchronous signal handle registered as event loop source for
1735 when we have pending events ready to be passed to the core. */
1737 static struct async_event_handler
*remote_async_inferior_event_token
;
1741 static ptid_t magic_null_ptid
;
1742 static ptid_t not_sent_ptid
;
1743 static ptid_t any_thread_ptid
;
1745 /* Find out if the stub attached to PID (and hence GDB should offer to
1746 detach instead of killing it when bailing out). */
1749 remote_query_attached (int pid
)
1751 struct remote_state
*rs
= get_remote_state ();
1752 size_t size
= get_remote_packet_size ();
1754 if (packet_support (PACKET_qAttached
) == PACKET_DISABLE
)
1757 if (remote_multi_process_p (rs
))
1758 xsnprintf (rs
->buf
, size
, "qAttached:%x", pid
);
1760 xsnprintf (rs
->buf
, size
, "qAttached");
1763 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
1765 switch (packet_ok (rs
->buf
,
1766 &remote_protocol_packets
[PACKET_qAttached
]))
1769 if (strcmp (rs
->buf
, "1") == 0)
1773 warning (_("Remote failure reply: %s"), rs
->buf
);
1775 case PACKET_UNKNOWN
:
1782 /* Add PID to GDB's inferior table. If FAKE_PID_P is true, then PID
1783 has been invented by GDB, instead of reported by the target. Since
1784 we can be connected to a remote system before before knowing about
1785 any inferior, mark the target with execution when we find the first
1786 inferior. If ATTACHED is 1, then we had just attached to this
1787 inferior. If it is 0, then we just created this inferior. If it
1788 is -1, then try querying the remote stub to find out if it had
1789 attached to the inferior or not. If TRY_OPEN_EXEC is true then
1790 attempt to open this inferior's executable as the main executable
1791 if no main executable is open already. */
1793 static struct inferior
*
1794 remote_add_inferior (int fake_pid_p
, int pid
, int attached
,
1797 struct inferior
*inf
;
1799 /* Check whether this process we're learning about is to be
1800 considered attached, or if is to be considered to have been
1801 spawned by the stub. */
1803 attached
= remote_query_attached (pid
);
1805 if (gdbarch_has_global_solist (target_gdbarch ()))
1807 /* If the target shares code across all inferiors, then every
1808 attach adds a new inferior. */
1809 inf
= add_inferior (pid
);
1811 /* ... and every inferior is bound to the same program space.
1812 However, each inferior may still have its own address
1814 inf
->aspace
= maybe_new_address_space ();
1815 inf
->pspace
= current_program_space
;
1819 /* In the traditional debugging scenario, there's a 1-1 match
1820 between program/address spaces. We simply bind the inferior
1821 to the program space's address space. */
1822 inf
= current_inferior ();
1823 inferior_appeared (inf
, pid
);
1826 inf
->attach_flag
= attached
;
1827 inf
->fake_pid_p
= fake_pid_p
;
1829 /* If no main executable is currently open then attempt to
1830 open the file that was executed to create this inferior. */
1831 if (try_open_exec
&& get_exec_file (0) == NULL
)
1832 exec_file_locate_attach (pid
, 0, 1);
1837 static struct private_thread_info
*
1838 get_private_info_thread (struct thread_info
*info
);
1840 /* Add thread PTID to GDB's thread list. Tag it as executing/running
1841 according to RUNNING. */
1844 remote_add_thread (ptid_t ptid
, int running
, int executing
)
1846 struct remote_state
*rs
= get_remote_state ();
1847 struct thread_info
*thread
;
1849 /* GDB historically didn't pull threads in the initial connection
1850 setup. If the remote target doesn't even have a concept of
1851 threads (e.g., a bare-metal target), even if internally we
1852 consider that a single-threaded target, mentioning a new thread
1853 might be confusing to the user. Be silent then, preserving the
1854 age old behavior. */
1855 if (rs
->starting_up
)
1856 thread
= add_thread_silent (ptid
);
1858 thread
= add_thread (ptid
);
1860 get_private_info_thread (thread
)->vcont_resumed
= executing
;
1861 set_executing (ptid
, executing
);
1862 set_running (ptid
, running
);
1865 /* Come here when we learn about a thread id from the remote target.
1866 It may be the first time we hear about such thread, so take the
1867 opportunity to add it to GDB's thread list. In case this is the
1868 first time we're noticing its corresponding inferior, add it to
1869 GDB's inferior list as well. EXECUTING indicates whether the
1870 thread is (internally) executing or stopped. */
1873 remote_notice_new_inferior (ptid_t currthread
, int executing
)
1875 /* In non-stop mode, we assume new found threads are (externally)
1876 running until proven otherwise with a stop reply. In all-stop,
1877 we can only get here if all threads are stopped. */
1878 int running
= target_is_non_stop_p () ? 1 : 0;
1880 /* If this is a new thread, add it to GDB's thread list.
1881 If we leave it up to WFI to do this, bad things will happen. */
1883 if (in_thread_list (currthread
) && is_exited (currthread
))
1885 /* We're seeing an event on a thread id we knew had exited.
1886 This has to be a new thread reusing the old id. Add it. */
1887 remote_add_thread (currthread
, running
, executing
);
1891 if (!in_thread_list (currthread
))
1893 struct inferior
*inf
= NULL
;
1894 int pid
= ptid_get_pid (currthread
);
1896 if (ptid_is_pid (inferior_ptid
)
1897 && pid
== ptid_get_pid (inferior_ptid
))
1899 /* inferior_ptid has no thread member yet. This can happen
1900 with the vAttach -> remote_wait,"TAAthread:" path if the
1901 stub doesn't support qC. This is the first stop reported
1902 after an attach, so this is the main thread. Update the
1903 ptid in the thread list. */
1904 if (in_thread_list (pid_to_ptid (pid
)))
1905 thread_change_ptid (inferior_ptid
, currthread
);
1908 remote_add_thread (currthread
, running
, executing
);
1909 inferior_ptid
= currthread
;
1914 if (ptid_equal (magic_null_ptid
, inferior_ptid
))
1916 /* inferior_ptid is not set yet. This can happen with the
1917 vRun -> remote_wait,"TAAthread:" path if the stub
1918 doesn't support qC. This is the first stop reported
1919 after an attach, so this is the main thread. Update the
1920 ptid in the thread list. */
1921 thread_change_ptid (inferior_ptid
, currthread
);
1925 /* When connecting to a target remote, or to a target
1926 extended-remote which already was debugging an inferior, we
1927 may not know about it yet. Add it before adding its child
1928 thread, so notifications are emitted in a sensible order. */
1929 if (!in_inferior_list (ptid_get_pid (currthread
)))
1931 struct remote_state
*rs
= get_remote_state ();
1932 int fake_pid_p
= !remote_multi_process_p (rs
);
1934 inf
= remote_add_inferior (fake_pid_p
,
1935 ptid_get_pid (currthread
), -1, 1);
1938 /* This is really a new thread. Add it. */
1939 remote_add_thread (currthread
, running
, executing
);
1941 /* If we found a new inferior, let the common code do whatever
1942 it needs to with it (e.g., read shared libraries, insert
1943 breakpoints), unless we're just setting up an all-stop
1947 struct remote_state
*rs
= get_remote_state ();
1949 if (!rs
->starting_up
)
1950 notice_new_inferior (currthread
, executing
, 0);
1955 /* Return THREAD's private thread data, creating it if necessary. */
1957 static struct private_thread_info
*
1958 get_private_info_thread (struct thread_info
*thread
)
1960 gdb_assert (thread
!= NULL
);
1962 if (thread
->priv
== NULL
)
1964 struct private_thread_info
*priv
= XNEW (struct private_thread_info
);
1966 thread
->private_dtor
= free_private_thread_info
;
1967 thread
->priv
= priv
;
1973 priv
->last_resume_step
= 0;
1974 priv
->last_resume_sig
= GDB_SIGNAL_0
;
1975 priv
->vcont_resumed
= 0;
1976 priv
->thread_handle
= nullptr;
1979 return thread
->priv
;
1982 /* Return PTID's private thread data, creating it if necessary. */
1984 static struct private_thread_info
*
1985 get_private_info_ptid (ptid_t ptid
)
1987 struct thread_info
*info
= find_thread_ptid (ptid
);
1989 return get_private_info_thread (info
);
1992 /* Call this function as a result of
1993 1) A halt indication (T packet) containing a thread id
1994 2) A direct query of currthread
1995 3) Successful execution of set thread */
1998 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
2000 rs
->general_thread
= currthread
;
2003 /* If 'QPassSignals' is supported, tell the remote stub what signals
2004 it can simply pass through to the inferior without reporting. */
2007 remote_pass_signals (struct target_ops
*self
,
2008 int numsigs
, unsigned char *pass_signals
)
2010 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2012 char *pass_packet
, *p
;
2014 struct remote_state
*rs
= get_remote_state ();
2016 gdb_assert (numsigs
< 256);
2017 for (i
= 0; i
< numsigs
; i
++)
2019 if (pass_signals
[i
])
2022 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2023 strcpy (pass_packet
, "QPassSignals:");
2024 p
= pass_packet
+ strlen (pass_packet
);
2025 for (i
= 0; i
< numsigs
; i
++)
2027 if (pass_signals
[i
])
2030 *p
++ = tohex (i
>> 4);
2031 *p
++ = tohex (i
& 15);
2040 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2042 putpkt (pass_packet
);
2043 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2044 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2045 if (rs
->last_pass_packet
)
2046 xfree (rs
->last_pass_packet
);
2047 rs
->last_pass_packet
= pass_packet
;
2050 xfree (pass_packet
);
2054 /* If 'QCatchSyscalls' is supported, tell the remote stub
2055 to report syscalls to GDB. */
2058 remote_set_syscall_catchpoint (struct target_ops
*self
,
2059 int pid
, int needed
, int any_count
,
2060 int table_size
, int *table
)
2063 enum packet_result result
;
2066 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2068 /* Not supported. */
2072 if (needed
&& !any_count
)
2076 /* Count how many syscalls are to be caught (table[sysno] != 0). */
2077 for (i
= 0; i
< table_size
; i
++)
2086 fprintf_unfiltered (gdb_stdlog
,
2087 "remote_set_syscall_catchpoint "
2088 "pid %d needed %d any_count %d n_sysno %d\n",
2089 pid
, needed
, any_count
, n_sysno
);
2094 /* Prepare a packet with the sysno list, assuming max 8+1
2095 characters for a sysno. If the resulting packet size is too
2096 big, fallback on the non-selective packet. */
2097 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2099 catch_packet
= (char *) xmalloc (maxpktsz
);
2100 strcpy (catch_packet
, "QCatchSyscalls:1");
2109 /* Add in catch_packet each syscall to be caught (table[i] != 0). */
2110 for (i
= 0; i
< table_size
; i
++)
2113 p
+= xsnprintf (p
, catch_packet
+ maxpktsz
- p
, ";%x", i
);
2116 if (strlen (catch_packet
) > get_remote_packet_size ())
2118 /* catch_packet too big. Fallback to less efficient
2119 non selective mode, with GDB doing the filtering. */
2120 catch_packet
[sizeof ("QCatchSyscalls:1") - 1] = 0;
2124 catch_packet
= xstrdup ("QCatchSyscalls:0");
2127 struct cleanup
*old_chain
= make_cleanup (xfree
, catch_packet
);
2128 struct remote_state
*rs
= get_remote_state ();
2130 putpkt (catch_packet
);
2131 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2132 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2133 do_cleanups (old_chain
);
2134 if (result
== PACKET_OK
)
2141 /* If 'QProgramSignals' is supported, tell the remote stub what
2142 signals it should pass through to the inferior when detaching. */
2145 remote_program_signals (struct target_ops
*self
,
2146 int numsigs
, unsigned char *signals
)
2148 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2152 struct remote_state
*rs
= get_remote_state ();
2154 gdb_assert (numsigs
< 256);
2155 for (i
= 0; i
< numsigs
; i
++)
2160 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2161 strcpy (packet
, "QProgramSignals:");
2162 p
= packet
+ strlen (packet
);
2163 for (i
= 0; i
< numsigs
; i
++)
2165 if (signal_pass_state (i
))
2168 *p
++ = tohex (i
>> 4);
2169 *p
++ = tohex (i
& 15);
2178 if (!rs
->last_program_signals_packet
2179 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2182 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2183 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2184 xfree (rs
->last_program_signals_packet
);
2185 rs
->last_program_signals_packet
= packet
;
2192 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2193 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2194 thread. If GEN is set, set the general thread, if not, then set
2195 the step/continue thread. */
2197 set_thread (ptid_t ptid
, int gen
)
2199 struct remote_state
*rs
= get_remote_state ();
2200 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2201 char *buf
= rs
->buf
;
2202 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
2204 if (ptid_equal (state
, ptid
))
2208 *buf
++ = gen
? 'g' : 'c';
2209 if (ptid_equal (ptid
, magic_null_ptid
))
2210 xsnprintf (buf
, endbuf
- buf
, "0");
2211 else if (ptid_equal (ptid
, any_thread_ptid
))
2212 xsnprintf (buf
, endbuf
- buf
, "0");
2213 else if (ptid_equal (ptid
, minus_one_ptid
))
2214 xsnprintf (buf
, endbuf
- buf
, "-1");
2216 write_ptid (buf
, endbuf
, ptid
);
2218 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2220 rs
->general_thread
= ptid
;
2222 rs
->continue_thread
= ptid
;
2226 set_general_thread (ptid_t ptid
)
2228 set_thread (ptid
, 1);
2232 set_continue_thread (ptid_t ptid
)
2234 set_thread (ptid
, 0);
2237 /* Change the remote current process. Which thread within the process
2238 ends up selected isn't important, as long as it is the same process
2239 as what INFERIOR_PTID points to.
2241 This comes from that fact that there is no explicit notion of
2242 "selected process" in the protocol. The selected process for
2243 general operations is the process the selected general thread
2247 set_general_process (void)
2249 struct remote_state
*rs
= get_remote_state ();
2251 /* If the remote can't handle multiple processes, don't bother. */
2252 if (!remote_multi_process_p (rs
))
2255 /* We only need to change the remote current thread if it's pointing
2256 at some other process. */
2257 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
2258 set_general_thread (inferior_ptid
);
2262 /* Return nonzero if this is the main thread that we made up ourselves
2263 to model non-threaded targets as single-threaded. */
2266 remote_thread_always_alive (struct target_ops
*ops
, ptid_t ptid
)
2268 if (ptid_equal (ptid
, magic_null_ptid
))
2269 /* The main thread is always alive. */
2272 if (ptid_get_pid (ptid
) != 0 && ptid_get_lwp (ptid
) == 0)
2273 /* The main thread is always alive. This can happen after a
2274 vAttach, if the remote side doesn't support
2281 /* Return nonzero if the thread PTID is still alive on the remote
2285 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2287 struct remote_state
*rs
= get_remote_state ();
2290 /* Check if this is a thread that we made up ourselves to model
2291 non-threaded targets as single-threaded. */
2292 if (remote_thread_always_alive (ops
, ptid
))
2296 endp
= rs
->buf
+ get_remote_packet_size ();
2299 write_ptid (p
, endp
, ptid
);
2302 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2303 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2306 /* Return a pointer to a thread name if we know it and NULL otherwise.
2307 The thread_info object owns the memory for the name. */
2310 remote_thread_name (struct target_ops
*ops
, struct thread_info
*info
)
2312 if (info
->priv
!= NULL
)
2313 return info
->priv
->name
;
2318 /* About these extended threadlist and threadinfo packets. They are
2319 variable length packets but, the fields within them are often fixed
2320 length. They are redundent enough to send over UDP as is the
2321 remote protocol in general. There is a matching unit test module
2324 /* WARNING: This threadref data structure comes from the remote O.S.,
2325 libstub protocol encoding, and remote.c. It is not particularly
2328 /* Right now, the internal structure is int. We want it to be bigger.
2329 Plan to fix this. */
2331 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2333 /* gdb_ext_thread_info is an internal GDB data structure which is
2334 equivalent to the reply of the remote threadinfo packet. */
2336 struct gdb_ext_thread_info
2338 threadref threadid
; /* External form of thread reference. */
2339 int active
; /* Has state interesting to GDB?
2341 char display
[256]; /* Brief state display, name,
2342 blocked/suspended. */
2343 char shortname
[32]; /* To be used to name threads. */
2344 char more_display
[256]; /* Long info, statistics, queue depth,
2348 /* The volume of remote transfers can be limited by submitting
2349 a mask containing bits specifying the desired information.
2350 Use a union of these values as the 'selection' parameter to
2351 get_thread_info. FIXME: Make these TAG names more thread specific. */
2353 #define TAG_THREADID 1
2354 #define TAG_EXISTS 2
2355 #define TAG_DISPLAY 4
2356 #define TAG_THREADNAME 8
2357 #define TAG_MOREDISPLAY 16
2359 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2361 static char *unpack_nibble (char *buf
, int *val
);
2363 static char *unpack_byte (char *buf
, int *value
);
2365 static char *pack_int (char *buf
, int value
);
2367 static char *unpack_int (char *buf
, int *value
);
2369 static char *unpack_string (char *src
, char *dest
, int length
);
2371 static char *pack_threadid (char *pkt
, threadref
*id
);
2373 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2375 void int_to_threadref (threadref
*id
, int value
);
2377 static int threadref_to_int (threadref
*ref
);
2379 static void copy_threadref (threadref
*dest
, threadref
*src
);
2381 static int threadmatch (threadref
*dest
, threadref
*src
);
2383 static char *pack_threadinfo_request (char *pkt
, int mode
,
2386 static int remote_unpack_thread_info_response (char *pkt
,
2387 threadref
*expectedref
,
2388 struct gdb_ext_thread_info
2392 static int remote_get_threadinfo (threadref
*threadid
,
2393 int fieldset
, /*TAG mask */
2394 struct gdb_ext_thread_info
*info
);
2396 static char *pack_threadlist_request (char *pkt
, int startflag
,
2398 threadref
*nextthread
);
2400 static int parse_threadlist_response (char *pkt
,
2402 threadref
*original_echo
,
2403 threadref
*resultlist
,
2406 static int remote_get_threadlist (int startflag
,
2407 threadref
*nextthread
,
2411 threadref
*threadlist
);
2413 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2415 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2416 void *context
, int looplimit
);
2418 static int remote_newthread_step (threadref
*ref
, void *context
);
2421 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2422 buffer we're allowed to write to. Returns
2423 BUF+CHARACTERS_WRITTEN. */
2426 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2429 struct remote_state
*rs
= get_remote_state ();
2431 if (remote_multi_process_p (rs
))
2433 pid
= ptid_get_pid (ptid
);
2435 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2437 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2439 tid
= ptid_get_lwp (ptid
);
2441 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2443 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2448 /* Extract a PTID from BUF. If non-null, OBUF is set to one past the
2449 last parsed char. Returns null_ptid if no thread id is found, and
2450 throws an error if the thread id has an invalid format. */
2453 read_ptid (const char *buf
, const char **obuf
)
2455 const char *p
= buf
;
2457 ULONGEST pid
= 0, tid
= 0;
2461 /* Multi-process ptid. */
2462 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2464 error (_("invalid remote ptid: %s"), p
);
2467 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2470 return ptid_build (pid
, tid
, 0);
2473 /* No multi-process. Just a tid. */
2474 pp
= unpack_varlen_hex (p
, &tid
);
2476 /* Return null_ptid when no thread id is found. */
2484 /* Since the stub is not sending a process id, then default to
2485 what's in inferior_ptid, unless it's null at this point. If so,
2486 then since there's no way to know the pid of the reported
2487 threads, use the magic number. */
2488 if (ptid_equal (inferior_ptid
, null_ptid
))
2489 pid
= ptid_get_pid (magic_null_ptid
);
2491 pid
= ptid_get_pid (inferior_ptid
);
2495 return ptid_build (pid
, tid
, 0);
2501 if (ch
>= 'a' && ch
<= 'f')
2502 return ch
- 'a' + 10;
2503 if (ch
>= '0' && ch
<= '9')
2505 if (ch
>= 'A' && ch
<= 'F')
2506 return ch
- 'A' + 10;
2511 stub_unpack_int (char *buff
, int fieldlength
)
2518 nibble
= stubhex (*buff
++);
2522 retval
= retval
<< 4;
2528 unpack_nibble (char *buf
, int *val
)
2530 *val
= fromhex (*buf
++);
2535 unpack_byte (char *buf
, int *value
)
2537 *value
= stub_unpack_int (buf
, 2);
2542 pack_int (char *buf
, int value
)
2544 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2545 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2546 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2547 buf
= pack_hex_byte (buf
, (value
& 0xff));
2552 unpack_int (char *buf
, int *value
)
2554 *value
= stub_unpack_int (buf
, 8);
2558 #if 0 /* Currently unused, uncomment when needed. */
2559 static char *pack_string (char *pkt
, char *string
);
2562 pack_string (char *pkt
, char *string
)
2567 len
= strlen (string
);
2569 len
= 200; /* Bigger than most GDB packets, junk??? */
2570 pkt
= pack_hex_byte (pkt
, len
);
2574 if ((ch
== '\0') || (ch
== '#'))
2575 ch
= '*'; /* Protect encapsulation. */
2580 #endif /* 0 (unused) */
2583 unpack_string (char *src
, char *dest
, int length
)
2592 pack_threadid (char *pkt
, threadref
*id
)
2595 unsigned char *altid
;
2597 altid
= (unsigned char *) id
;
2598 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2600 pkt
= pack_hex_byte (pkt
, *altid
++);
2606 unpack_threadid (char *inbuf
, threadref
*id
)
2609 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2612 altref
= (char *) id
;
2614 while (inbuf
< limit
)
2616 x
= stubhex (*inbuf
++);
2617 y
= stubhex (*inbuf
++);
2618 *altref
++ = (x
<< 4) | y
;
2623 /* Externally, threadrefs are 64 bits but internally, they are still
2624 ints. This is due to a mismatch of specifications. We would like
2625 to use 64bit thread references internally. This is an adapter
2629 int_to_threadref (threadref
*id
, int value
)
2631 unsigned char *scan
;
2633 scan
= (unsigned char *) id
;
2639 *scan
++ = (value
>> 24) & 0xff;
2640 *scan
++ = (value
>> 16) & 0xff;
2641 *scan
++ = (value
>> 8) & 0xff;
2642 *scan
++ = (value
& 0xff);
2646 threadref_to_int (threadref
*ref
)
2649 unsigned char *scan
;
2655 value
= (value
<< 8) | ((*scan
++) & 0xff);
2660 copy_threadref (threadref
*dest
, threadref
*src
)
2663 unsigned char *csrc
, *cdest
;
2665 csrc
= (unsigned char *) src
;
2666 cdest
= (unsigned char *) dest
;
2673 threadmatch (threadref
*dest
, threadref
*src
)
2675 /* Things are broken right now, so just assume we got a match. */
2677 unsigned char *srcp
, *destp
;
2679 srcp
= (char *) src
;
2680 destp
= (char *) dest
;
2684 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2691 threadid:1, # always request threadid
2698 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2701 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2703 *pkt
++ = 'q'; /* Info Query */
2704 *pkt
++ = 'P'; /* process or thread info */
2705 pkt
= pack_int (pkt
, mode
); /* mode */
2706 pkt
= pack_threadid (pkt
, id
); /* threadid */
2707 *pkt
= '\0'; /* terminate */
2711 /* These values tag the fields in a thread info response packet. */
2712 /* Tagging the fields allows us to request specific fields and to
2713 add more fields as time goes by. */
2715 #define TAG_THREADID 1 /* Echo the thread identifier. */
2716 #define TAG_EXISTS 2 /* Is this process defined enough to
2717 fetch registers and its stack? */
2718 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2719 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2720 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2724 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2725 struct gdb_ext_thread_info
*info
)
2727 struct remote_state
*rs
= get_remote_state ();
2731 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2734 /* info->threadid = 0; FIXME: implement zero_threadref. */
2736 info
->display
[0] = '\0';
2737 info
->shortname
[0] = '\0';
2738 info
->more_display
[0] = '\0';
2740 /* Assume the characters indicating the packet type have been
2742 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2743 pkt
= unpack_threadid (pkt
, &ref
);
2746 warning (_("Incomplete response to threadinfo request."));
2747 if (!threadmatch (&ref
, expectedref
))
2748 { /* This is an answer to a different request. */
2749 warning (_("ERROR RMT Thread info mismatch."));
2752 copy_threadref (&info
->threadid
, &ref
);
2754 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2756 /* Packets are terminated with nulls. */
2757 while ((pkt
< limit
) && mask
&& *pkt
)
2759 pkt
= unpack_int (pkt
, &tag
); /* tag */
2760 pkt
= unpack_byte (pkt
, &length
); /* length */
2761 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2763 warning (_("ERROR RMT: threadinfo tag mismatch."));
2767 if (tag
== TAG_THREADID
)
2771 warning (_("ERROR RMT: length of threadid is not 16."));
2775 pkt
= unpack_threadid (pkt
, &ref
);
2776 mask
= mask
& ~TAG_THREADID
;
2779 if (tag
== TAG_EXISTS
)
2781 info
->active
= stub_unpack_int (pkt
, length
);
2783 mask
= mask
& ~(TAG_EXISTS
);
2786 warning (_("ERROR RMT: 'exists' length too long."));
2792 if (tag
== TAG_THREADNAME
)
2794 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2795 mask
= mask
& ~TAG_THREADNAME
;
2798 if (tag
== TAG_DISPLAY
)
2800 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2801 mask
= mask
& ~TAG_DISPLAY
;
2804 if (tag
== TAG_MOREDISPLAY
)
2806 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2807 mask
= mask
& ~TAG_MOREDISPLAY
;
2810 warning (_("ERROR RMT: unknown thread info tag."));
2811 break; /* Not a tag we know about. */
2817 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2818 struct gdb_ext_thread_info
*info
)
2820 struct remote_state
*rs
= get_remote_state ();
2823 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2825 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2827 if (rs
->buf
[0] == '\0')
2830 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2835 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2838 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2839 threadref
*nextthread
)
2841 *pkt
++ = 'q'; /* info query packet */
2842 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2843 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2844 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2845 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2850 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2853 parse_threadlist_response (char *pkt
, int result_limit
,
2854 threadref
*original_echo
, threadref
*resultlist
,
2857 struct remote_state
*rs
= get_remote_state ();
2859 int count
, resultcount
, done
;
2862 /* Assume the 'q' and 'M chars have been stripped. */
2863 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2864 /* done parse past here */
2865 pkt
= unpack_byte (pkt
, &count
); /* count field */
2866 pkt
= unpack_nibble (pkt
, &done
);
2867 /* The first threadid is the argument threadid. */
2868 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2869 while ((count
-- > 0) && (pkt
< limit
))
2871 pkt
= unpack_threadid (pkt
, resultlist
++);
2872 if (resultcount
++ >= result_limit
)
2880 /* Fetch the next batch of threads from the remote. Returns -1 if the
2881 qL packet is not supported, 0 on error and 1 on success. */
2884 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2885 int *done
, int *result_count
, threadref
*threadlist
)
2887 struct remote_state
*rs
= get_remote_state ();
2890 /* Trancate result limit to be smaller than the packet size. */
2891 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2892 >= get_remote_packet_size ())
2893 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2895 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2897 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2898 if (*rs
->buf
== '\0')
2900 /* Packet not supported. */
2905 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2906 &rs
->echo_nextthread
, threadlist
, done
);
2908 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2910 /* FIXME: This is a good reason to drop the packet. */
2911 /* Possably, there is a duplicate response. */
2913 retransmit immediatly - race conditions
2914 retransmit after timeout - yes
2916 wait for packet, then exit
2918 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2919 return 0; /* I choose simply exiting. */
2921 if (*result_count
<= 0)
2925 warning (_("RMT ERROR : failed to get remote thread list."));
2928 return result
; /* break; */
2930 if (*result_count
> result_limit
)
2933 warning (_("RMT ERROR: threadlist response longer than requested."));
2939 /* Fetch the list of remote threads, with the qL packet, and call
2940 STEPFUNCTION for each thread found. Stops iterating and returns 1
2941 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2942 STEPFUNCTION returns false. If the packet is not supported,
2946 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2949 struct remote_state
*rs
= get_remote_state ();
2950 int done
, i
, result_count
;
2958 if (loopcount
++ > looplimit
)
2961 warning (_("Remote fetch threadlist -infinite loop-."));
2964 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
2965 MAXTHREADLISTRESULTS
,
2966 &done
, &result_count
,
2967 rs
->resultthreadlist
);
2970 /* Clear for later iterations. */
2972 /* Setup to resume next batch of thread references, set nextthread. */
2973 if (result_count
>= 1)
2974 copy_threadref (&rs
->nextthread
,
2975 &rs
->resultthreadlist
[result_count
- 1]);
2977 while (result_count
--)
2979 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
2989 /* A thread found on the remote target. */
2991 typedef struct thread_item
2993 /* The thread's PTID. */
2996 /* The thread's extra info. May be NULL. */
2999 /* The thread's name. May be NULL. */
3002 /* The core the thread was running on. -1 if not known. */
3005 /* The thread handle associated with the thread. */
3006 gdb::byte_vector
*thread_handle
;
3009 DEF_VEC_O(thread_item_t
);
3011 /* Context passed around to the various methods listing remote
3012 threads. As new threads are found, they're added to the ITEMS
3015 struct threads_listing_context
3017 /* The threads found on the remote target. */
3018 VEC (thread_item_t
) *items
;
3021 /* Discard the contents of the constructed thread listing context. */
3024 clear_threads_listing_context (void *p
)
3026 struct threads_listing_context
*context
3027 = (struct threads_listing_context
*) p
;
3029 struct thread_item
*item
;
3031 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3033 xfree (item
->extra
);
3035 delete item
->thread_handle
;
3038 VEC_free (thread_item_t
, context
->items
);
3041 /* Remove the thread specified as the related_pid field of WS
3042 from the CONTEXT list. */
3045 threads_listing_context_remove (struct target_waitstatus
*ws
,
3046 struct threads_listing_context
*context
)
3048 struct thread_item
*item
;
3050 ptid_t child_ptid
= ws
->value
.related_pid
;
3052 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3054 if (ptid_equal (item
->ptid
, child_ptid
))
3056 VEC_ordered_remove (thread_item_t
, context
->items
, i
);
3063 remote_newthread_step (threadref
*ref
, void *data
)
3065 struct threads_listing_context
*context
3066 = (struct threads_listing_context
*) data
;
3067 struct thread_item item
;
3068 int pid
= ptid_get_pid (inferior_ptid
);
3070 item
.ptid
= ptid_build (pid
, threadref_to_int (ref
), 0);
3074 item
.thread_handle
= nullptr;
3076 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3078 return 1; /* continue iterator */
3081 #define CRAZY_MAX_THREADS 1000
3084 remote_current_thread (ptid_t oldpid
)
3086 struct remote_state
*rs
= get_remote_state ();
3089 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3090 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3095 result
= read_ptid (&rs
->buf
[2], &obuf
);
3096 if (*obuf
!= '\0' && remote_debug
)
3097 fprintf_unfiltered (gdb_stdlog
,
3098 "warning: garbage in qC reply\n");
3106 /* List remote threads using the deprecated qL packet. */
3109 remote_get_threads_with_ql (struct target_ops
*ops
,
3110 struct threads_listing_context
*context
)
3112 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3113 CRAZY_MAX_THREADS
) >= 0)
3119 #if defined(HAVE_LIBEXPAT)
3122 start_thread (struct gdb_xml_parser
*parser
,
3123 const struct gdb_xml_element
*element
,
3124 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
3126 struct threads_listing_context
*data
3127 = (struct threads_listing_context
*) user_data
;
3129 struct thread_item item
;
3131 struct gdb_xml_value
*attr
;
3133 id
= (char *) xml_find_attribute (attributes
, "id")->value
;
3134 item
.ptid
= read_ptid (id
, NULL
);
3136 attr
= xml_find_attribute (attributes
, "core");
3138 item
.core
= *(ULONGEST
*) attr
->value
;
3142 attr
= xml_find_attribute (attributes
, "name");
3143 item
.name
= attr
!= NULL
? xstrdup ((const char *) attr
->value
) : NULL
;
3145 attr
= xml_find_attribute (attributes
, "handle");
3148 item
.thread_handle
= new gdb::byte_vector
3149 (strlen ((const char *) attr
->value
) / 2);
3150 hex2bin ((const char *) attr
->value
, item
.thread_handle
->data (),
3151 item
.thread_handle
->size ());
3154 item
.thread_handle
= nullptr;
3158 VEC_safe_push (thread_item_t
, data
->items
, &item
);
3162 end_thread (struct gdb_xml_parser
*parser
,
3163 const struct gdb_xml_element
*element
,
3164 void *user_data
, const char *body_text
)
3166 struct threads_listing_context
*data
3167 = (struct threads_listing_context
*) user_data
;
3169 if (body_text
&& *body_text
)
3170 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
3173 const struct gdb_xml_attribute thread_attributes
[] = {
3174 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3175 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3176 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3177 { "handle", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3178 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3181 const struct gdb_xml_element thread_children
[] = {
3182 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3185 const struct gdb_xml_element threads_children
[] = {
3186 { "thread", thread_attributes
, thread_children
,
3187 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3188 start_thread
, end_thread
},
3189 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3192 const struct gdb_xml_element threads_elements
[] = {
3193 { "threads", NULL
, threads_children
,
3194 GDB_XML_EF_NONE
, NULL
, NULL
},
3195 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3200 /* List remote threads using qXfer:threads:read. */
3203 remote_get_threads_with_qxfer (struct target_ops
*ops
,
3204 struct threads_listing_context
*context
)
3206 #if defined(HAVE_LIBEXPAT)
3207 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3209 char *xml
= target_read_stralloc (ops
, TARGET_OBJECT_THREADS
, NULL
);
3210 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
3212 if (xml
!= NULL
&& *xml
!= '\0')
3214 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3215 threads_elements
, xml
, context
);
3218 do_cleanups (back_to
);
3226 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3229 remote_get_threads_with_qthreadinfo (struct target_ops
*ops
,
3230 struct threads_listing_context
*context
)
3232 struct remote_state
*rs
= get_remote_state ();
3234 if (rs
->use_threadinfo_query
)
3238 putpkt ("qfThreadInfo");
3239 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3241 if (bufp
[0] != '\0') /* q packet recognized */
3243 while (*bufp
++ == 'm') /* reply contains one or more TID */
3247 struct thread_item item
;
3249 item
.ptid
= read_ptid (bufp
, &bufp
);
3253 item
.thread_handle
= nullptr;
3255 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3257 while (*bufp
++ == ','); /* comma-separated list */
3258 putpkt ("qsThreadInfo");
3259 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3266 /* Packet not recognized. */
3267 rs
->use_threadinfo_query
= 0;
3274 /* Implement the to_update_thread_list function for the remote
3278 remote_update_thread_list (struct target_ops
*ops
)
3280 struct threads_listing_context context
;
3281 struct cleanup
*old_chain
;
3284 context
.items
= NULL
;
3285 old_chain
= make_cleanup (clear_threads_listing_context
, &context
);
3287 /* We have a few different mechanisms to fetch the thread list. Try
3288 them all, starting with the most preferred one first, falling
3289 back to older methods. */
3290 if (remote_get_threads_with_qxfer (ops
, &context
)
3291 || remote_get_threads_with_qthreadinfo (ops
, &context
)
3292 || remote_get_threads_with_ql (ops
, &context
))
3295 struct thread_item
*item
;
3296 struct thread_info
*tp
, *tmp
;
3300 if (VEC_empty (thread_item_t
, context
.items
)
3301 && remote_thread_always_alive (ops
, inferior_ptid
))
3303 /* Some targets don't really support threads, but still
3304 reply an (empty) thread list in response to the thread
3305 listing packets, instead of replying "packet not
3306 supported". Exit early so we don't delete the main
3308 do_cleanups (old_chain
);
3312 /* CONTEXT now holds the current thread list on the remote
3313 target end. Delete GDB-side threads no longer found on the
3315 ALL_THREADS_SAFE (tp
, tmp
)
3318 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3321 if (ptid_equal (item
->ptid
, tp
->ptid
))
3325 if (i
== VEC_length (thread_item_t
, context
.items
))
3328 delete_thread (tp
->ptid
);
3332 /* Remove any unreported fork child threads from CONTEXT so
3333 that we don't interfere with follow fork, which is where
3334 creation of such threads is handled. */
3335 remove_new_fork_children (&context
);
3337 /* And now add threads we don't know about yet to our list. */
3339 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3342 if (!ptid_equal (item
->ptid
, null_ptid
))
3344 struct private_thread_info
*info
;
3345 /* In non-stop mode, we assume new found threads are
3346 executing until proven otherwise with a stop reply.
3347 In all-stop, we can only get here if all threads are
3349 int executing
= target_is_non_stop_p () ? 1 : 0;
3351 remote_notice_new_inferior (item
->ptid
, executing
);
3353 info
= get_private_info_ptid (item
->ptid
);
3354 info
->core
= item
->core
;
3355 info
->extra
= item
->extra
;
3357 info
->name
= item
->name
;
3359 info
->thread_handle
= item
->thread_handle
;
3360 item
->thread_handle
= nullptr;
3367 /* If no thread listing method is supported, then query whether
3368 each known thread is alive, one by one, with the T packet.
3369 If the target doesn't support threads at all, then this is a
3370 no-op. See remote_thread_alive. */
3374 do_cleanups (old_chain
);
3378 * Collect a descriptive string about the given thread.
3379 * The target may say anything it wants to about the thread
3380 * (typically info about its blocked / runnable state, name, etc.).
3381 * This string will appear in the info threads display.
3383 * Optional: targets are not required to implement this function.
3387 remote_threads_extra_info (struct target_ops
*self
, struct thread_info
*tp
)
3389 struct remote_state
*rs
= get_remote_state ();
3393 struct gdb_ext_thread_info threadinfo
;
3394 static char display_buf
[100]; /* arbitrary... */
3395 int n
= 0; /* position in display_buf */
3397 if (rs
->remote_desc
== 0) /* paranoia */
3398 internal_error (__FILE__
, __LINE__
,
3399 _("remote_threads_extra_info"));
3401 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
3402 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_lwp (tp
->ptid
) == 0))
3403 /* This is the main thread which was added by GDB. The remote
3404 server doesn't know about it. */
3407 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3409 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
3411 if (info
&& info
->priv
)
3412 return info
->priv
->extra
;
3417 if (rs
->use_threadextra_query
)
3420 char *endb
= rs
->buf
+ get_remote_packet_size ();
3422 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3424 write_ptid (b
, endb
, tp
->ptid
);
3427 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3428 if (rs
->buf
[0] != 0)
3430 n
= std::min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
3431 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
3432 display_buf
[result
] = '\0';
3437 /* If the above query fails, fall back to the old method. */
3438 rs
->use_threadextra_query
= 0;
3439 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3440 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3441 int_to_threadref (&id
, ptid_get_lwp (tp
->ptid
));
3442 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3443 if (threadinfo
.active
)
3445 if (*threadinfo
.shortname
)
3446 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
3447 " Name: %s,", threadinfo
.shortname
);
3448 if (*threadinfo
.display
)
3449 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3450 " State: %s,", threadinfo
.display
);
3451 if (*threadinfo
.more_display
)
3452 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3453 " Priority: %s", threadinfo
.more_display
);
3457 /* For purely cosmetic reasons, clear up trailing commas. */
3458 if (',' == display_buf
[n
-1])
3459 display_buf
[n
-1] = ' ';
3468 remote_static_tracepoint_marker_at (struct target_ops
*self
, CORE_ADDR addr
,
3469 struct static_tracepoint_marker
*marker
)
3471 struct remote_state
*rs
= get_remote_state ();
3474 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3476 p
+= hexnumstr (p
, addr
);
3478 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3482 error (_("Remote failure reply: %s"), p
);
3486 parse_static_tracepoint_marker_definition (p
, NULL
, marker
);
3493 static VEC(static_tracepoint_marker_p
) *
3494 remote_static_tracepoint_markers_by_strid (struct target_ops
*self
,
3497 struct remote_state
*rs
= get_remote_state ();
3498 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
3499 struct static_tracepoint_marker
*marker
= NULL
;
3500 struct cleanup
*old_chain
;
3503 /* Ask for a first packet of static tracepoint marker
3506 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3509 error (_("Remote failure reply: %s"), p
);
3511 old_chain
= make_cleanup (free_current_marker
, &marker
);
3516 marker
= XCNEW (struct static_tracepoint_marker
);
3520 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3522 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3524 VEC_safe_push (static_tracepoint_marker_p
,
3530 release_static_tracepoint_marker (marker
);
3531 memset (marker
, 0, sizeof (*marker
));
3534 while (*p
++ == ','); /* comma-separated list */
3535 /* Ask for another packet of static tracepoint definition. */
3537 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3541 do_cleanups (old_chain
);
3546 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3549 remote_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
3551 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
3555 /* Restart the remote side; this is an extended protocol operation. */
3558 extended_remote_restart (void)
3560 struct remote_state
*rs
= get_remote_state ();
3562 /* Send the restart command; for reasons I don't understand the
3563 remote side really expects a number after the "R". */
3564 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3567 remote_fileio_reset ();
3570 /* Clean up connection to a remote debugger. */
3573 remote_close (struct target_ops
*self
)
3575 struct remote_state
*rs
= get_remote_state ();
3577 if (rs
->remote_desc
== NULL
)
3578 return; /* already closed */
3580 /* Make sure we leave stdin registered in the event loop. */
3581 remote_terminal_ours (self
);
3583 serial_close (rs
->remote_desc
);
3584 rs
->remote_desc
= NULL
;
3586 /* We don't have a connection to the remote stub anymore. Get rid
3587 of all the inferiors and their threads we were controlling.
3588 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3589 will be unable to find the thread corresponding to (pid, 0, 0). */
3590 inferior_ptid
= null_ptid
;
3591 discard_all_inferiors ();
3593 /* We are closing the remote target, so we should discard
3594 everything of this target. */
3595 discard_pending_stop_replies_in_queue (rs
);
3597 if (remote_async_inferior_event_token
)
3598 delete_async_event_handler (&remote_async_inferior_event_token
);
3600 remote_notif_state_xfree (rs
->notif_state
);
3602 trace_reset_local_state ();
3605 /* Query the remote side for the text, data and bss offsets. */
3610 struct remote_state
*rs
= get_remote_state ();
3613 int lose
, num_segments
= 0, do_sections
, do_segments
;
3614 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3615 struct section_offsets
*offs
;
3616 struct symfile_segment_data
*data
;
3618 if (symfile_objfile
== NULL
)
3621 putpkt ("qOffsets");
3622 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3625 if (buf
[0] == '\000')
3626 return; /* Return silently. Stub doesn't support
3630 warning (_("Remote failure reply: %s"), buf
);
3634 /* Pick up each field in turn. This used to be done with scanf, but
3635 scanf will make trouble if CORE_ADDR size doesn't match
3636 conversion directives correctly. The following code will work
3637 with any size of CORE_ADDR. */
3638 text_addr
= data_addr
= bss_addr
= 0;
3642 if (startswith (ptr
, "Text="))
3645 /* Don't use strtol, could lose on big values. */
3646 while (*ptr
&& *ptr
!= ';')
3647 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3649 if (startswith (ptr
, ";Data="))
3652 while (*ptr
&& *ptr
!= ';')
3653 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3658 if (!lose
&& startswith (ptr
, ";Bss="))
3661 while (*ptr
&& *ptr
!= ';')
3662 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3664 if (bss_addr
!= data_addr
)
3665 warning (_("Target reported unsupported offsets: %s"), buf
);
3670 else if (startswith (ptr
, "TextSeg="))
3673 /* Don't use strtol, could lose on big values. */
3674 while (*ptr
&& *ptr
!= ';')
3675 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3678 if (startswith (ptr
, ";DataSeg="))
3681 while (*ptr
&& *ptr
!= ';')
3682 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3690 error (_("Malformed response to offset query, %s"), buf
);
3691 else if (*ptr
!= '\0')
3692 warning (_("Target reported unsupported offsets: %s"), buf
);
3694 offs
= ((struct section_offsets
*)
3695 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3696 memcpy (offs
, symfile_objfile
->section_offsets
,
3697 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3699 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3700 do_segments
= (data
!= NULL
);
3701 do_sections
= num_segments
== 0;
3703 if (num_segments
> 0)
3705 segments
[0] = text_addr
;
3706 segments
[1] = data_addr
;
3708 /* If we have two segments, we can still try to relocate everything
3709 by assuming that the .text and .data offsets apply to the whole
3710 text and data segments. Convert the offsets given in the packet
3711 to base addresses for symfile_map_offsets_to_segments. */
3712 else if (data
&& data
->num_segments
== 2)
3714 segments
[0] = data
->segment_bases
[0] + text_addr
;
3715 segments
[1] = data
->segment_bases
[1] + data_addr
;
3718 /* If the object file has only one segment, assume that it is text
3719 rather than data; main programs with no writable data are rare,
3720 but programs with no code are useless. Of course the code might
3721 have ended up in the data segment... to detect that we would need
3722 the permissions here. */
3723 else if (data
&& data
->num_segments
== 1)
3725 segments
[0] = data
->segment_bases
[0] + text_addr
;
3728 /* There's no way to relocate by segment. */
3734 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3735 offs
, num_segments
, segments
);
3737 if (ret
== 0 && !do_sections
)
3738 error (_("Can not handle qOffsets TextSeg "
3739 "response with this symbol file"));
3746 free_symfile_segment_data (data
);
3750 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3752 /* This is a temporary kludge to force data and bss to use the
3753 same offsets because that's what nlmconv does now. The real
3754 solution requires changes to the stub and remote.c that I
3755 don't have time to do right now. */
3757 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3758 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3761 objfile_relocate (symfile_objfile
, offs
);
3764 /* Send interrupt_sequence to remote target. */
3766 send_interrupt_sequence (void)
3768 struct remote_state
*rs
= get_remote_state ();
3770 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3771 remote_serial_write ("\x03", 1);
3772 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3773 serial_send_break (rs
->remote_desc
);
3774 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3776 serial_send_break (rs
->remote_desc
);
3777 remote_serial_write ("g", 1);
3780 internal_error (__FILE__
, __LINE__
,
3781 _("Invalid value for interrupt_sequence_mode: %s."),
3782 interrupt_sequence_mode
);
3786 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3787 and extract the PTID. Returns NULL_PTID if not found. */
3790 stop_reply_extract_thread (char *stop_reply
)
3792 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3796 /* Txx r:val ; r:val (...) */
3799 /* Look for "register" named "thread". */
3804 p1
= strchr (p
, ':');
3808 if (strncmp (p
, "thread", p1
- p
) == 0)
3809 return read_ptid (++p1
, &p
);
3811 p1
= strchr (p
, ';');
3823 /* Determine the remote side's current thread. If we have a stop
3824 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3825 "thread" register we can extract the current thread from. If not,
3826 ask the remote which is the current thread with qC. The former
3827 method avoids a roundtrip. */
3830 get_current_thread (char *wait_status
)
3832 ptid_t ptid
= null_ptid
;
3834 /* Note we don't use remote_parse_stop_reply as that makes use of
3835 the target architecture, which we haven't yet fully determined at
3837 if (wait_status
!= NULL
)
3838 ptid
= stop_reply_extract_thread (wait_status
);
3839 if (ptid_equal (ptid
, null_ptid
))
3840 ptid
= remote_current_thread (inferior_ptid
);
3845 /* Query the remote target for which is the current thread/process,
3846 add it to our tables, and update INFERIOR_PTID. The caller is
3847 responsible for setting the state such that the remote end is ready
3848 to return the current thread.
3850 This function is called after handling the '?' or 'vRun' packets,
3851 whose response is a stop reply from which we can also try
3852 extracting the thread. If the target doesn't support the explicit
3853 qC query, we infer the current thread from that stop reply, passed
3854 in in WAIT_STATUS, which may be NULL. */
3857 add_current_inferior_and_thread (char *wait_status
)
3859 struct remote_state
*rs
= get_remote_state ();
3862 inferior_ptid
= null_ptid
;
3864 /* Now, if we have thread information, update inferior_ptid. */
3865 ptid_t curr_ptid
= get_current_thread (wait_status
);
3867 if (curr_ptid
!= null_ptid
)
3869 if (!remote_multi_process_p (rs
))
3874 /* Without this, some commands which require an active target
3875 (such as kill) won't work. This variable serves (at least)
3876 double duty as both the pid of the target process (if it has
3877 such), and as a flag indicating that a target is active. */
3878 curr_ptid
= magic_null_ptid
;
3882 remote_add_inferior (fake_pid_p
, ptid_get_pid (curr_ptid
), -1, 1);
3884 /* Add the main thread and switch to it. Don't try reading
3885 registers yet, since we haven't fetched the target description
3887 thread_info
*tp
= add_thread_silent (curr_ptid
);
3888 switch_to_thread_no_regs (tp
);
3891 /* Print info about a thread that was found already stopped on
3895 print_one_stopped_thread (struct thread_info
*thread
)
3897 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
3899 switch_to_thread (thread
->ptid
);
3900 stop_pc
= get_frame_pc (get_current_frame ());
3901 set_current_sal_from_frame (get_current_frame ());
3903 thread
->suspend
.waitstatus_pending_p
= 0;
3905 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
3907 enum gdb_signal sig
= ws
->value
.sig
;
3909 if (signal_print_state (sig
))
3910 observer_notify_signal_received (sig
);
3912 observer_notify_normal_stop (NULL
, 1);
3915 /* Process all initial stop replies the remote side sent in response
3916 to the ? packet. These indicate threads that were already stopped
3917 on initial connection. We mark these threads as stopped and print
3918 their current frame before giving the user the prompt. */
3921 process_initial_stop_replies (int from_tty
)
3923 int pending_stop_replies
= stop_reply_queue_length ();
3924 struct inferior
*inf
;
3925 struct thread_info
*thread
;
3926 struct thread_info
*selected
= NULL
;
3927 struct thread_info
*lowest_stopped
= NULL
;
3928 struct thread_info
*first
= NULL
;
3930 /* Consume the initial pending events. */
3931 while (pending_stop_replies
-- > 0)
3933 ptid_t waiton_ptid
= minus_one_ptid
;
3935 struct target_waitstatus ws
;
3936 int ignore_event
= 0;
3937 struct thread_info
*thread
;
3939 memset (&ws
, 0, sizeof (ws
));
3940 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
3942 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
3946 case TARGET_WAITKIND_IGNORE
:
3947 case TARGET_WAITKIND_NO_RESUMED
:
3948 case TARGET_WAITKIND_SIGNALLED
:
3949 case TARGET_WAITKIND_EXITED
:
3950 /* We shouldn't see these, but if we do, just ignore. */
3952 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
3956 case TARGET_WAITKIND_EXECD
:
3957 xfree (ws
.value
.execd_pathname
);
3966 thread
= find_thread_ptid (event_ptid
);
3968 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
3970 enum gdb_signal sig
= ws
.value
.sig
;
3972 /* Stubs traditionally report SIGTRAP as initial signal,
3973 instead of signal 0. Suppress it. */
3974 if (sig
== GDB_SIGNAL_TRAP
)
3976 thread
->suspend
.stop_signal
= sig
;
3980 thread
->suspend
.waitstatus
= ws
;
3982 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
3983 || ws
.value
.sig
!= GDB_SIGNAL_0
)
3984 thread
->suspend
.waitstatus_pending_p
= 1;
3986 set_executing (event_ptid
, 0);
3987 set_running (event_ptid
, 0);
3988 thread
->priv
->vcont_resumed
= 0;
3991 /* "Notice" the new inferiors before anything related to
3992 registers/memory. */
3998 inf
->needs_setup
= 1;
4002 thread
= any_live_thread_of_process (inf
->pid
);
4003 notice_new_inferior (thread
->ptid
,
4004 thread
->state
== THREAD_RUNNING
,
4009 /* If all-stop on top of non-stop, pause all threads. Note this
4010 records the threads' stop pc, so must be done after "noticing"
4014 stop_all_threads ();
4016 /* If all threads of an inferior were already stopped, we
4017 haven't setup the inferior yet. */
4023 if (inf
->needs_setup
)
4025 thread
= any_live_thread_of_process (inf
->pid
);
4026 switch_to_thread_no_regs (thread
);
4032 /* Now go over all threads that are stopped, and print their current
4033 frame. If all-stop, then if there's a signalled thread, pick
4035 ALL_NON_EXITED_THREADS (thread
)
4041 set_running (thread
->ptid
, 0);
4042 else if (thread
->state
!= THREAD_STOPPED
)
4045 if (selected
== NULL
4046 && thread
->suspend
.waitstatus_pending_p
)
4049 if (lowest_stopped
== NULL
4050 || thread
->inf
->num
< lowest_stopped
->inf
->num
4051 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4052 lowest_stopped
= thread
;
4055 print_one_stopped_thread (thread
);
4058 /* In all-stop, we only print the status of one thread, and leave
4059 others with their status pending. */
4064 thread
= lowest_stopped
;
4068 print_one_stopped_thread (thread
);
4071 /* For "info program". */
4072 thread
= inferior_thread ();
4073 if (thread
->state
== THREAD_STOPPED
)
4074 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4077 /* Start the remote connection and sync state. */
4080 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
4082 struct remote_state
*rs
= get_remote_state ();
4083 struct packet_config
*noack_config
;
4084 char *wait_status
= NULL
;
4086 /* Signal other parts that we're going through the initial setup,
4087 and so things may not be stable yet. E.g., we don't try to
4088 install tracepoints until we've relocated symbols. Also, a
4089 Ctrl-C before we're connected and synced up can't interrupt the
4090 target. Instead, it offers to drop the (potentially wedged)
4092 rs
->starting_up
= 1;
4096 if (interrupt_on_connect
)
4097 send_interrupt_sequence ();
4099 /* Ack any packet which the remote side has already sent. */
4100 remote_serial_write ("+", 1);
4102 /* The first packet we send to the target is the optional "supported
4103 packets" request. If the target can answer this, it will tell us
4104 which later probes to skip. */
4105 remote_query_supported ();
4107 /* If the stub wants to get a QAllow, compose one and send it. */
4108 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4109 remote_set_permissions (target
);
4111 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4112 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4113 as a reply to known packet. For packet "vFile:setfs:" it is an
4114 invalid reply and GDB would return error in
4115 remote_hostio_set_filesystem, making remote files access impossible.
4116 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4117 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4119 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4121 putpkt (v_mustreplyempty
);
4122 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4123 if (strcmp (rs
->buf
, "OK") == 0)
4124 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4125 else if (strcmp (rs
->buf
, "") != 0)
4126 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4130 /* Next, we possibly activate noack mode.
4132 If the QStartNoAckMode packet configuration is set to AUTO,
4133 enable noack mode if the stub reported a wish for it with
4136 If set to TRUE, then enable noack mode even if the stub didn't
4137 report it in qSupported. If the stub doesn't reply OK, the
4138 session ends with an error.
4140 If FALSE, then don't activate noack mode, regardless of what the
4141 stub claimed should be the default with qSupported. */
4143 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4144 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4146 putpkt ("QStartNoAckMode");
4147 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4148 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4154 /* Tell the remote that we are using the extended protocol. */
4156 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4159 /* Let the target know which signals it is allowed to pass down to
4161 update_signals_program_target ();
4163 /* Next, if the target can specify a description, read it. We do
4164 this before anything involving memory or registers. */
4165 target_find_description ();
4167 /* Next, now that we know something about the target, update the
4168 address spaces in the program spaces. */
4169 update_address_spaces ();
4171 /* On OSs where the list of libraries is global to all
4172 processes, we fetch them early. */
4173 if (gdbarch_has_global_solist (target_gdbarch ()))
4174 solib_add (NULL
, from_tty
, auto_solib_add
);
4176 if (target_is_non_stop_p ())
4178 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4179 error (_("Non-stop mode requested, but remote "
4180 "does not support non-stop"));
4182 putpkt ("QNonStop:1");
4183 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4185 if (strcmp (rs
->buf
, "OK") != 0)
4186 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
4188 /* Find about threads and processes the stub is already
4189 controlling. We default to adding them in the running state.
4190 The '?' query below will then tell us about which threads are
4192 remote_update_thread_list (target
);
4194 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4196 /* Don't assume that the stub can operate in all-stop mode.
4197 Request it explicitly. */
4198 putpkt ("QNonStop:0");
4199 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4201 if (strcmp (rs
->buf
, "OK") != 0)
4202 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
4205 /* Upload TSVs regardless of whether the target is running or not. The
4206 remote stub, such as GDBserver, may have some predefined or builtin
4207 TSVs, even if the target is not running. */
4208 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4210 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4212 remote_upload_trace_state_variables (target
, &uploaded_tsvs
);
4213 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4216 /* Check whether the target is running now. */
4218 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4220 if (!target_is_non_stop_p ())
4222 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4225 error (_("The target is not running (try extended-remote?)"));
4227 /* We're connected, but not running. Drop out before we
4228 call start_remote. */
4229 rs
->starting_up
= 0;
4234 /* Save the reply for later. */
4235 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
4236 strcpy (wait_status
, rs
->buf
);
4239 /* Fetch thread list. */
4240 target_update_thread_list ();
4242 /* Let the stub know that we want it to return the thread. */
4243 set_continue_thread (minus_one_ptid
);
4245 if (thread_count () == 0)
4247 /* Target has no concept of threads at all. GDB treats
4248 non-threaded target as single-threaded; add a main
4250 add_current_inferior_and_thread (wait_status
);
4254 /* We have thread information; select the thread the target
4255 says should be current. If we're reconnecting to a
4256 multi-threaded program, this will ideally be the thread
4257 that last reported an event before GDB disconnected. */
4258 inferior_ptid
= get_current_thread (wait_status
);
4259 if (ptid_equal (inferior_ptid
, null_ptid
))
4261 /* Odd... The target was able to list threads, but not
4262 tell us which thread was current (no "thread"
4263 register in T stop reply?). Just pick the first
4264 thread in the thread list then. */
4267 fprintf_unfiltered (gdb_stdlog
,
4268 "warning: couldn't determine remote "
4269 "current thread; picking first in list.\n");
4271 inferior_ptid
= thread_list
->ptid
;
4275 /* init_wait_for_inferior should be called before get_offsets in order
4276 to manage `inserted' flag in bp loc in a correct state.
4277 breakpoint_init_inferior, called from init_wait_for_inferior, set
4278 `inserted' flag to 0, while before breakpoint_re_set, called from
4279 start_remote, set `inserted' flag to 1. In the initialization of
4280 inferior, breakpoint_init_inferior should be called first, and then
4281 breakpoint_re_set can be called. If this order is broken, state of
4282 `inserted' flag is wrong, and cause some problems on breakpoint
4284 init_wait_for_inferior ();
4286 get_offsets (); /* Get text, data & bss offsets. */
4288 /* If we could not find a description using qXfer, and we know
4289 how to do it some other way, try again. This is not
4290 supported for non-stop; it could be, but it is tricky if
4291 there are no stopped threads when we connect. */
4292 if (remote_read_description_p (target
)
4293 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4295 target_clear_description ();
4296 target_find_description ();
4299 /* Use the previously fetched status. */
4300 gdb_assert (wait_status
!= NULL
);
4301 strcpy (rs
->buf
, wait_status
);
4302 rs
->cached_wait_status
= 1;
4304 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4308 /* Clear WFI global state. Do this before finding about new
4309 threads and inferiors, and setting the current inferior.
4310 Otherwise we would clear the proceed status of the current
4311 inferior when we want its stop_soon state to be preserved
4312 (see notice_new_inferior). */
4313 init_wait_for_inferior ();
4315 /* In non-stop, we will either get an "OK", meaning that there
4316 are no stopped threads at this time; or, a regular stop
4317 reply. In the latter case, there may be more than one thread
4318 stopped --- we pull them all out using the vStopped
4320 if (strcmp (rs
->buf
, "OK") != 0)
4322 struct notif_client
*notif
= ¬if_client_stop
;
4324 /* remote_notif_get_pending_replies acks this one, and gets
4326 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4327 = remote_notif_parse (notif
, rs
->buf
);
4328 remote_notif_get_pending_events (notif
);
4331 if (thread_count () == 0)
4334 error (_("The target is not running (try extended-remote?)"));
4336 /* We're connected, but not running. Drop out before we
4337 call start_remote. */
4338 rs
->starting_up
= 0;
4342 /* In non-stop mode, any cached wait status will be stored in
4343 the stop reply queue. */
4344 gdb_assert (wait_status
== NULL
);
4346 /* Report all signals during attach/startup. */
4347 remote_pass_signals (target
, 0, NULL
);
4349 /* If there are already stopped threads, mark them stopped and
4350 report their stops before giving the prompt to the user. */
4351 process_initial_stop_replies (from_tty
);
4353 if (target_can_async_p ())
4357 /* If we connected to a live target, do some additional setup. */
4358 if (target_has_execution
)
4360 if (symfile_objfile
) /* No use without a symbol-file. */
4361 remote_check_symbols ();
4364 /* Possibly the target has been engaged in a trace run started
4365 previously; find out where things are at. */
4366 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4368 struct uploaded_tp
*uploaded_tps
= NULL
;
4370 if (current_trace_status ()->running
)
4371 printf_filtered (_("Trace is already running on the target.\n"));
4373 remote_upload_tracepoints (target
, &uploaded_tps
);
4375 merge_uploaded_tracepoints (&uploaded_tps
);
4378 /* Possibly the target has been engaged in a btrace record started
4379 previously; find out where things are at. */
4380 remote_btrace_maybe_reopen ();
4382 /* The thread and inferior lists are now synchronized with the
4383 target, our symbols have been relocated, and we're merged the
4384 target's tracepoints with ours. We're done with basic start
4386 rs
->starting_up
= 0;
4388 /* Maybe breakpoints are global and need to be inserted now. */
4389 if (breakpoints_should_be_inserted_now ())
4390 insert_breakpoints ();
4393 /* Open a connection to a remote debugger.
4394 NAME is the filename used for communication. */
4397 remote_open (const char *name
, int from_tty
)
4399 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
4402 /* Open a connection to a remote debugger using the extended
4403 remote gdb protocol. NAME is the filename used for communication. */
4406 extended_remote_open (const char *name
, int from_tty
)
4408 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
4411 /* Reset all packets back to "unknown support". Called when opening a
4412 new connection to a remote target. */
4415 reset_all_packet_configs_support (void)
4419 for (i
= 0; i
< PACKET_MAX
; i
++)
4420 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4423 /* Initialize all packet configs. */
4426 init_all_packet_configs (void)
4430 for (i
= 0; i
< PACKET_MAX
; i
++)
4432 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4433 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4437 /* Symbol look-up. */
4440 remote_check_symbols (void)
4442 struct remote_state
*rs
= get_remote_state ();
4443 char *msg
, *reply
, *tmp
;
4446 struct cleanup
*old_chain
;
4448 /* The remote side has no concept of inferiors that aren't running
4449 yet, it only knows about running processes. If we're connected
4450 but our current inferior is not running, we should not invite the
4451 remote target to request symbol lookups related to its
4452 (unrelated) current process. */
4453 if (!target_has_execution
)
4456 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4459 /* Make sure the remote is pointing at the right process. Note
4460 there's no way to select "no process". */
4461 set_general_process ();
4463 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4464 because we need both at the same time. */
4465 msg
= (char *) xmalloc (get_remote_packet_size ());
4466 old_chain
= make_cleanup (xfree
, msg
);
4467 reply
= (char *) xmalloc (get_remote_packet_size ());
4468 make_cleanup (free_current_contents
, &reply
);
4469 reply_size
= get_remote_packet_size ();
4471 /* Invite target to request symbol lookups. */
4473 putpkt ("qSymbol::");
4474 getpkt (&reply
, &reply_size
, 0);
4475 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4477 while (startswith (reply
, "qSymbol:"))
4479 struct bound_minimal_symbol sym
;
4482 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
4484 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
4485 if (sym
.minsym
== NULL
)
4486 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
4489 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4490 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4492 /* If this is a function address, return the start of code
4493 instead of any data function descriptor. */
4494 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4498 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
4499 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4503 getpkt (&reply
, &reply_size
, 0);
4506 do_cleanups (old_chain
);
4509 static struct serial
*
4510 remote_serial_open (const char *name
)
4512 static int udp_warning
= 0;
4514 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4515 of in ser-tcp.c, because it is the remote protocol assuming that the
4516 serial connection is reliable and not the serial connection promising
4518 if (!udp_warning
&& startswith (name
, "udp:"))
4520 warning (_("The remote protocol may be unreliable over UDP.\n"
4521 "Some events may be lost, rendering further debugging "
4526 return serial_open (name
);
4529 /* Inform the target of our permission settings. The permission flags
4530 work without this, but if the target knows the settings, it can do
4531 a couple things. First, it can add its own check, to catch cases
4532 that somehow manage to get by the permissions checks in target
4533 methods. Second, if the target is wired to disallow particular
4534 settings (for instance, a system in the field that is not set up to
4535 be able to stop at a breakpoint), it can object to any unavailable
4539 remote_set_permissions (struct target_ops
*self
)
4541 struct remote_state
*rs
= get_remote_state ();
4543 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
4544 "WriteReg:%x;WriteMem:%x;"
4545 "InsertBreak:%x;InsertTrace:%x;"
4546 "InsertFastTrace:%x;Stop:%x",
4547 may_write_registers
, may_write_memory
,
4548 may_insert_breakpoints
, may_insert_tracepoints
,
4549 may_insert_fast_tracepoints
, may_stop
);
4551 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4553 /* If the target didn't like the packet, warn the user. Do not try
4554 to undo the user's settings, that would just be maddening. */
4555 if (strcmp (rs
->buf
, "OK") != 0)
4556 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
4559 /* This type describes each known response to the qSupported
4561 struct protocol_feature
4563 /* The name of this protocol feature. */
4566 /* The default for this protocol feature. */
4567 enum packet_support default_support
;
4569 /* The function to call when this feature is reported, or after
4570 qSupported processing if the feature is not supported.
4571 The first argument points to this structure. The second
4572 argument indicates whether the packet requested support be
4573 enabled, disabled, or probed (or the default, if this function
4574 is being called at the end of processing and this feature was
4575 not reported). The third argument may be NULL; if not NULL, it
4576 is a NUL-terminated string taken from the packet following
4577 this feature's name and an equals sign. */
4578 void (*func
) (const struct protocol_feature
*, enum packet_support
,
4581 /* The corresponding packet for this feature. Only used if
4582 FUNC is remote_supported_packet. */
4587 remote_supported_packet (const struct protocol_feature
*feature
,
4588 enum packet_support support
,
4589 const char *argument
)
4593 warning (_("Remote qSupported response supplied an unexpected value for"
4594 " \"%s\"."), feature
->name
);
4598 remote_protocol_packets
[feature
->packet
].support
= support
;
4602 remote_packet_size (const struct protocol_feature
*feature
,
4603 enum packet_support support
, const char *value
)
4605 struct remote_state
*rs
= get_remote_state ();
4610 if (support
!= PACKET_ENABLE
)
4613 if (value
== NULL
|| *value
== '\0')
4615 warning (_("Remote target reported \"%s\" without a size."),
4621 packet_size
= strtol (value
, &value_end
, 16);
4622 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
4624 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4625 feature
->name
, value
);
4629 /* Record the new maximum packet size. */
4630 rs
->explicit_packet_size
= packet_size
;
4633 static const struct protocol_feature remote_protocol_features
[] = {
4634 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4635 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4636 PACKET_qXfer_auxv
},
4637 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
4638 PACKET_qXfer_exec_file
},
4639 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4640 PACKET_qXfer_features
},
4641 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4642 PACKET_qXfer_libraries
},
4643 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4644 PACKET_qXfer_libraries_svr4
},
4645 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4646 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
4647 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4648 PACKET_qXfer_memory_map
},
4649 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4650 PACKET_qXfer_spu_read
},
4651 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4652 PACKET_qXfer_spu_write
},
4653 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4654 PACKET_qXfer_osdata
},
4655 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4656 PACKET_qXfer_threads
},
4657 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4658 PACKET_qXfer_traceframe_info
},
4659 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4660 PACKET_QPassSignals
},
4661 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
4662 PACKET_QCatchSyscalls
},
4663 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4664 PACKET_QProgramSignals
},
4665 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
4666 PACKET_QStartupWithShell
},
4667 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
4668 PACKET_QEnvironmentHexEncoded
},
4669 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
4670 PACKET_QEnvironmentReset
},
4671 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
4672 PACKET_QEnvironmentUnset
},
4673 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4674 PACKET_QStartNoAckMode
},
4675 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
4676 PACKET_multiprocess_feature
},
4677 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
4678 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4679 PACKET_qXfer_siginfo_read
},
4680 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4681 PACKET_qXfer_siginfo_write
},
4682 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4683 PACKET_ConditionalTracepoints
},
4684 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
4685 PACKET_ConditionalBreakpoints
},
4686 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
4687 PACKET_BreakpointCommands
},
4688 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4689 PACKET_FastTracepoints
},
4690 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4691 PACKET_StaticTracepoints
},
4692 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
4693 PACKET_InstallInTrace
},
4694 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
4695 PACKET_DisconnectedTracing_feature
},
4696 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4698 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4700 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4701 PACKET_TracepointSource
},
4702 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4704 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4705 PACKET_EnableDisableTracepoints_feature
},
4706 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4707 PACKET_qXfer_fdpic
},
4708 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4710 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4711 PACKET_QDisableRandomization
},
4712 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4713 { "QTBuffer:size", PACKET_DISABLE
,
4714 remote_supported_packet
, PACKET_QTBuffer_size
},
4715 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
4716 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4717 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4718 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
4719 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4720 PACKET_qXfer_btrace
},
4721 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
4722 PACKET_qXfer_btrace_conf
},
4723 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
4724 PACKET_Qbtrace_conf_bts_size
},
4725 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
4726 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
4727 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
4728 PACKET_fork_event_feature
},
4729 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
4730 PACKET_vfork_event_feature
},
4731 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
4732 PACKET_exec_event_feature
},
4733 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
4734 PACKET_Qbtrace_conf_pt_size
},
4735 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
4736 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
4737 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
4740 static char *remote_support_xml
;
4742 /* Register string appended to "xmlRegisters=" in qSupported query. */
4745 register_remote_support_xml (const char *xml
)
4747 #if defined(HAVE_LIBEXPAT)
4748 if (remote_support_xml
== NULL
)
4749 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4752 char *copy
= xstrdup (remote_support_xml
+ 13);
4753 char *p
= strtok (copy
, ",");
4757 if (strcmp (p
, xml
) == 0)
4764 while ((p
= strtok (NULL
, ",")) != NULL
);
4767 remote_support_xml
= reconcat (remote_support_xml
,
4768 remote_support_xml
, ",", xml
,
4775 remote_query_supported_append (char *msg
, const char *append
)
4778 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4780 return xstrdup (append
);
4784 remote_query_supported (void)
4786 struct remote_state
*rs
= get_remote_state ();
4789 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4791 /* The packet support flags are handled differently for this packet
4792 than for most others. We treat an error, a disabled packet, and
4793 an empty response identically: any features which must be reported
4794 to be used will be automatically disabled. An empty buffer
4795 accomplishes this, since that is also the representation for a list
4796 containing no features. */
4799 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
4802 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4804 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
4805 q
= remote_query_supported_append (q
, "multiprocess+");
4807 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4808 q
= remote_query_supported_append (q
, "swbreak+");
4809 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4810 q
= remote_query_supported_append (q
, "hwbreak+");
4812 q
= remote_query_supported_append (q
, "qRelocInsn+");
4814 if (packet_set_cmd_state (PACKET_fork_event_feature
)
4815 != AUTO_BOOLEAN_FALSE
)
4816 q
= remote_query_supported_append (q
, "fork-events+");
4817 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
4818 != AUTO_BOOLEAN_FALSE
)
4819 q
= remote_query_supported_append (q
, "vfork-events+");
4820 if (packet_set_cmd_state (PACKET_exec_event_feature
)
4821 != AUTO_BOOLEAN_FALSE
)
4822 q
= remote_query_supported_append (q
, "exec-events+");
4824 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
4825 q
= remote_query_supported_append (q
, "vContSupported+");
4827 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
4828 q
= remote_query_supported_append (q
, "QThreadEvents+");
4830 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
4831 q
= remote_query_supported_append (q
, "no-resumed+");
4833 /* Keep this one last to work around a gdbserver <= 7.10 bug in
4834 the qSupported:xmlRegisters=i386 handling. */
4835 if (remote_support_xml
!= NULL
)
4836 q
= remote_query_supported_append (q
, remote_support_xml
);
4838 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4841 do_cleanups (old_chain
);
4843 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4845 /* If an error occured, warn, but do not return - just reset the
4846 buffer to empty and go on to disable features. */
4847 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4850 warning (_("Remote failure reply: %s"), rs
->buf
);
4855 memset (seen
, 0, sizeof (seen
));
4860 enum packet_support is_supported
;
4861 char *p
, *end
, *name_end
, *value
;
4863 /* First separate out this item from the rest of the packet. If
4864 there's another item after this, we overwrite the separator
4865 (terminated strings are much easier to work with). */
4867 end
= strchr (p
, ';');
4870 end
= p
+ strlen (p
);
4880 warning (_("empty item in \"qSupported\" response"));
4885 name_end
= strchr (p
, '=');
4888 /* This is a name=value entry. */
4889 is_supported
= PACKET_ENABLE
;
4890 value
= name_end
+ 1;
4899 is_supported
= PACKET_ENABLE
;
4903 is_supported
= PACKET_DISABLE
;
4907 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4911 warning (_("unrecognized item \"%s\" "
4912 "in \"qSupported\" response"), p
);
4918 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4919 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4921 const struct protocol_feature
*feature
;
4924 feature
= &remote_protocol_features
[i
];
4925 feature
->func (feature
, is_supported
, value
);
4930 /* If we increased the packet size, make sure to increase the global
4931 buffer size also. We delay this until after parsing the entire
4932 qSupported packet, because this is the same buffer we were
4934 if (rs
->buf_size
< rs
->explicit_packet_size
)
4936 rs
->buf_size
= rs
->explicit_packet_size
;
4937 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
4940 /* Handle the defaults for unmentioned features. */
4941 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4944 const struct protocol_feature
*feature
;
4946 feature
= &remote_protocol_features
[i
];
4947 feature
->func (feature
, feature
->default_support
, NULL
);
4951 /* Serial QUIT handler for the remote serial descriptor.
4953 Defers handling a Ctrl-C until we're done with the current
4954 command/response packet sequence, unless:
4956 - We're setting up the connection. Don't send a remote interrupt
4957 request, as we're not fully synced yet. Quit immediately
4960 - The target has been resumed in the foreground
4961 (target_terminal::is_ours is false) with a synchronous resume
4962 packet, and we're blocked waiting for the stop reply, thus a
4963 Ctrl-C should be immediately sent to the target.
4965 - We get a second Ctrl-C while still within the same serial read or
4966 write. In that case the serial is seemingly wedged --- offer to
4969 - We see a second Ctrl-C without target response, after having
4970 previously interrupted the target. In that case the target/stub
4971 is probably wedged --- offer to quit/disconnect.
4975 remote_serial_quit_handler (void)
4977 struct remote_state
*rs
= get_remote_state ();
4979 if (check_quit_flag ())
4981 /* If we're starting up, we're not fully synced yet. Quit
4983 if (rs
->starting_up
)
4985 else if (rs
->got_ctrlc_during_io
)
4987 if (query (_("The target is not responding to GDB commands.\n"
4988 "Stop debugging it? ")))
4989 remote_unpush_and_throw ();
4991 /* If ^C has already been sent once, offer to disconnect. */
4992 else if (!target_terminal::is_ours () && rs
->ctrlc_pending_p
)
4994 /* All-stop protocol, and blocked waiting for stop reply. Send
4995 an interrupt request. */
4996 else if (!target_terminal::is_ours () && rs
->waiting_for_stop_reply
)
4997 target_interrupt (inferior_ptid
);
4999 rs
->got_ctrlc_during_io
= 1;
5003 /* Remove any of the remote.c targets from target stack. Upper targets depend
5004 on it so remove them first. */
5007 remote_unpush_target (void)
5009 pop_all_targets_at_and_above (process_stratum
);
5013 remote_unpush_and_throw (void)
5015 remote_unpush_target ();
5016 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
5020 remote_open_1 (const char *name
, int from_tty
,
5021 struct target_ops
*target
, int extended_p
)
5023 struct remote_state
*rs
= get_remote_state ();
5026 error (_("To open a remote debug connection, you need to specify what\n"
5027 "serial device is attached to the remote system\n"
5028 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5030 /* See FIXME above. */
5031 if (!target_async_permitted
)
5032 wait_forever_enabled_p
= 1;
5034 /* If we're connected to a running target, target_preopen will kill it.
5035 Ask this question first, before target_preopen has a chance to kill
5037 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
5040 && !query (_("Already connected to a remote target. Disconnect? ")))
5041 error (_("Still connected."));
5044 /* Here the possibly existing remote target gets unpushed. */
5045 target_preopen (from_tty
);
5047 /* Make sure we send the passed signals list the next time we resume. */
5048 xfree (rs
->last_pass_packet
);
5049 rs
->last_pass_packet
= NULL
;
5051 /* Make sure we send the program signals list the next time we
5053 xfree (rs
->last_program_signals_packet
);
5054 rs
->last_program_signals_packet
= NULL
;
5056 remote_fileio_reset ();
5057 reopen_exec_file ();
5060 rs
->remote_desc
= remote_serial_open (name
);
5061 if (!rs
->remote_desc
)
5062 perror_with_name (name
);
5064 if (baud_rate
!= -1)
5066 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5068 /* The requested speed could not be set. Error out to
5069 top level after closing remote_desc. Take care to
5070 set remote_desc to NULL to avoid closing remote_desc
5072 serial_close (rs
->remote_desc
);
5073 rs
->remote_desc
= NULL
;
5074 perror_with_name (name
);
5078 serial_setparity (rs
->remote_desc
, serial_parity
);
5079 serial_raw (rs
->remote_desc
);
5081 /* If there is something sitting in the buffer we might take it as a
5082 response to a command, which would be bad. */
5083 serial_flush_input (rs
->remote_desc
);
5087 puts_filtered ("Remote debugging using ");
5088 puts_filtered (name
);
5089 puts_filtered ("\n");
5091 push_target (target
); /* Switch to using remote target now. */
5093 /* Register extra event sources in the event loop. */
5094 remote_async_inferior_event_token
5095 = create_async_event_handler (remote_async_inferior_event_handler
,
5097 rs
->notif_state
= remote_notif_state_allocate ();
5099 /* Reset the target state; these things will be queried either by
5100 remote_query_supported or as they are needed. */
5101 reset_all_packet_configs_support ();
5102 rs
->cached_wait_status
= 0;
5103 rs
->explicit_packet_size
= 0;
5105 rs
->extended
= extended_p
;
5106 rs
->waiting_for_stop_reply
= 0;
5107 rs
->ctrlc_pending_p
= 0;
5108 rs
->got_ctrlc_during_io
= 0;
5110 rs
->general_thread
= not_sent_ptid
;
5111 rs
->continue_thread
= not_sent_ptid
;
5112 rs
->remote_traceframe_number
= -1;
5114 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5116 /* Probe for ability to use "ThreadInfo" query, as required. */
5117 rs
->use_threadinfo_query
= 1;
5118 rs
->use_threadextra_query
= 1;
5120 readahead_cache_invalidate ();
5122 /* Start out by owning the terminal. */
5123 remote_async_terminal_ours_p
= 1;
5125 if (target_async_permitted
)
5127 /* FIXME: cagney/1999-09-23: During the initial connection it is
5128 assumed that the target is already ready and able to respond to
5129 requests. Unfortunately remote_start_remote() eventually calls
5130 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5131 around this. Eventually a mechanism that allows
5132 wait_for_inferior() to expect/get timeouts will be
5134 wait_forever_enabled_p
= 0;
5137 /* First delete any symbols previously loaded from shared libraries. */
5138 no_shared_libraries (NULL
, 0);
5141 init_thread_list ();
5143 /* Start the remote connection. If error() or QUIT, discard this
5144 target (we'd otherwise be in an inconsistent state) and then
5145 propogate the error on up the exception chain. This ensures that
5146 the caller doesn't stumble along blindly assuming that the
5147 function succeeded. The CLI doesn't have this problem but other
5148 UI's, such as MI do.
5150 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5151 this function should return an error indication letting the
5152 caller restore the previous state. Unfortunately the command
5153 ``target remote'' is directly wired to this function making that
5154 impossible. On a positive note, the CLI side of this problem has
5155 been fixed - the function set_cmd_context() makes it possible for
5156 all the ``target ....'' commands to share a common callback
5157 function. See cli-dump.c. */
5162 remote_start_remote (from_tty
, target
, extended_p
);
5164 CATCH (ex
, RETURN_MASK_ALL
)
5166 /* Pop the partially set up target - unless something else did
5167 already before throwing the exception. */
5168 if (rs
->remote_desc
!= NULL
)
5169 remote_unpush_target ();
5170 if (target_async_permitted
)
5171 wait_forever_enabled_p
= 1;
5172 throw_exception (ex
);
5177 remote_btrace_reset ();
5179 if (target_async_permitted
)
5180 wait_forever_enabled_p
= 1;
5183 /* Detach the specified process. */
5186 remote_detach_pid (int pid
)
5188 struct remote_state
*rs
= get_remote_state ();
5190 if (remote_multi_process_p (rs
))
5191 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
5193 strcpy (rs
->buf
, "D");
5196 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5198 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5200 else if (rs
->buf
[0] == '\0')
5201 error (_("Remote doesn't know how to detach"));
5203 error (_("Can't detach process."));
5206 /* This detaches a program to which we previously attached, using
5207 inferior_ptid to identify the process. After this is done, GDB
5208 can be used to debug some other program. We better not have left
5209 any breakpoints in the target program or it'll die when it hits
5213 remote_detach_1 (const char *args
, int from_tty
)
5215 int pid
= ptid_get_pid (inferior_ptid
);
5216 struct remote_state
*rs
= get_remote_state ();
5217 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5221 error (_("Argument given to \"detach\" when remotely debugging."));
5223 if (!target_has_execution
)
5224 error (_("No process to detach from."));
5226 target_announce_detach (from_tty
);
5228 /* Tell the remote target to detach. */
5229 remote_detach_pid (pid
);
5231 /* Exit only if this is the only active inferior. */
5232 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5233 puts_filtered (_("Ending remote debugging.\n"));
5235 /* Check to see if we are detaching a fork parent. Note that if we
5236 are detaching a fork child, tp == NULL. */
5237 is_fork_parent
= (tp
!= NULL
5238 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5240 /* If doing detach-on-fork, we don't mourn, because that will delete
5241 breakpoints that should be available for the followed inferior. */
5242 if (!is_fork_parent
)
5243 target_mourn_inferior (inferior_ptid
);
5246 inferior_ptid
= null_ptid
;
5247 detach_inferior (pid
);
5252 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5254 remote_detach_1 (args
, from_tty
);
5258 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5260 remote_detach_1 (args
, from_tty
);
5263 /* Target follow-fork function for remote targets. On entry, and
5264 at return, the current inferior is the fork parent.
5266 Note that although this is currently only used for extended-remote,
5267 it is named remote_follow_fork in anticipation of using it for the
5268 remote target as well. */
5271 remote_follow_fork (struct target_ops
*ops
, int follow_child
,
5274 struct remote_state
*rs
= get_remote_state ();
5275 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5277 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5278 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5280 /* When following the parent and detaching the child, we detach
5281 the child here. For the case of following the child and
5282 detaching the parent, the detach is done in the target-
5283 independent follow fork code in infrun.c. We can't use
5284 target_detach when detaching an unfollowed child because
5285 the client side doesn't know anything about the child. */
5286 if (detach_fork
&& !follow_child
)
5288 /* Detach the fork child. */
5292 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5293 child_pid
= ptid_get_pid (child_ptid
);
5295 remote_detach_pid (child_pid
);
5296 detach_inferior (child_pid
);
5302 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5303 in the program space of the new inferior. On entry and at return the
5304 current inferior is the exec'ing inferior. INF is the new exec'd
5305 inferior, which may be the same as the exec'ing inferior unless
5306 follow-exec-mode is "new". */
5309 remote_follow_exec (struct target_ops
*ops
,
5310 struct inferior
*inf
, char *execd_pathname
)
5312 /* We know that this is a target file name, so if it has the "target:"
5313 prefix we strip it off before saving it in the program space. */
5314 if (is_target_filename (execd_pathname
))
5315 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5317 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5320 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5323 remote_disconnect (struct target_ops
*target
, const char *args
, int from_tty
)
5326 error (_("Argument given to \"disconnect\" when remotely debugging."));
5328 /* Make sure we unpush even the extended remote targets. Calling
5329 target_mourn_inferior won't unpush, and remote_mourn won't
5330 unpush if there is more than one inferior left. */
5331 unpush_target (target
);
5332 generic_mourn_inferior ();
5335 puts_filtered ("Ending remote debugging.\n");
5338 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5339 be chatty about it. */
5342 extended_remote_attach (struct target_ops
*target
, const char *args
,
5345 struct remote_state
*rs
= get_remote_state ();
5347 char *wait_status
= NULL
;
5349 pid
= parse_pid_to_attach (args
);
5351 /* Remote PID can be freely equal to getpid, do not check it here the same
5352 way as in other targets. */
5354 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5355 error (_("This target does not support attaching to a process"));
5359 char *exec_file
= get_exec_file (0);
5362 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5363 target_pid_to_str (pid_to_ptid (pid
)));
5365 printf_unfiltered (_("Attaching to %s\n"),
5366 target_pid_to_str (pid_to_ptid (pid
)));
5368 gdb_flush (gdb_stdout
);
5371 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
5373 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5375 switch (packet_ok (rs
->buf
,
5376 &remote_protocol_packets
[PACKET_vAttach
]))
5379 if (!target_is_non_stop_p ())
5381 /* Save the reply for later. */
5382 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
5383 strcpy (wait_status
, rs
->buf
);
5385 else if (strcmp (rs
->buf
, "OK") != 0)
5386 error (_("Attaching to %s failed with: %s"),
5387 target_pid_to_str (pid_to_ptid (pid
)),
5390 case PACKET_UNKNOWN
:
5391 error (_("This target does not support attaching to a process"));
5393 error (_("Attaching to %s failed"),
5394 target_pid_to_str (pid_to_ptid (pid
)));
5397 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
5399 inferior_ptid
= pid_to_ptid (pid
);
5401 if (target_is_non_stop_p ())
5403 struct thread_info
*thread
;
5405 /* Get list of threads. */
5406 remote_update_thread_list (target
);
5408 thread
= first_thread_of_process (pid
);
5410 inferior_ptid
= thread
->ptid
;
5412 inferior_ptid
= pid_to_ptid (pid
);
5414 /* Invalidate our notion of the remote current thread. */
5415 record_currthread (rs
, minus_one_ptid
);
5419 /* Now, if we have thread information, update inferior_ptid. */
5420 inferior_ptid
= remote_current_thread (inferior_ptid
);
5422 /* Add the main thread to the thread list. */
5423 add_thread_silent (inferior_ptid
);
5426 /* Next, if the target can specify a description, read it. We do
5427 this before anything involving memory or registers. */
5428 target_find_description ();
5430 if (!target_is_non_stop_p ())
5432 /* Use the previously fetched status. */
5433 gdb_assert (wait_status
!= NULL
);
5435 if (target_can_async_p ())
5437 struct notif_event
*reply
5438 = remote_notif_parse (¬if_client_stop
, wait_status
);
5440 push_stop_reply ((struct stop_reply
*) reply
);
5446 gdb_assert (wait_status
!= NULL
);
5447 strcpy (rs
->buf
, wait_status
);
5448 rs
->cached_wait_status
= 1;
5452 gdb_assert (wait_status
== NULL
);
5455 /* Implementation of the to_post_attach method. */
5458 extended_remote_post_attach (struct target_ops
*ops
, int pid
)
5460 /* Get text, data & bss offsets. */
5463 /* In certain cases GDB might not have had the chance to start
5464 symbol lookup up until now. This could happen if the debugged
5465 binary is not using shared libraries, the vsyscall page is not
5466 present (on Linux) and the binary itself hadn't changed since the
5467 debugging process was started. */
5468 if (symfile_objfile
!= NULL
)
5469 remote_check_symbols();
5473 /* Check for the availability of vCont. This function should also check
5477 remote_vcont_probe (struct remote_state
*rs
)
5481 strcpy (rs
->buf
, "vCont?");
5483 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5486 /* Make sure that the features we assume are supported. */
5487 if (startswith (buf
, "vCont"))
5490 int support_c
, support_C
;
5492 rs
->supports_vCont
.s
= 0;
5493 rs
->supports_vCont
.S
= 0;
5496 rs
->supports_vCont
.t
= 0;
5497 rs
->supports_vCont
.r
= 0;
5498 while (p
&& *p
== ';')
5501 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5502 rs
->supports_vCont
.s
= 1;
5503 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5504 rs
->supports_vCont
.S
= 1;
5505 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5507 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5509 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5510 rs
->supports_vCont
.t
= 1;
5511 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5512 rs
->supports_vCont
.r
= 1;
5514 p
= strchr (p
, ';');
5517 /* If c, and C are not all supported, we can't use vCont. Clearing
5518 BUF will make packet_ok disable the packet. */
5519 if (!support_c
|| !support_C
)
5523 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
5526 /* Helper function for building "vCont" resumptions. Write a
5527 resumption to P. ENDP points to one-passed-the-end of the buffer
5528 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5529 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5530 resumed thread should be single-stepped and/or signalled. If PTID
5531 equals minus_one_ptid, then all threads are resumed; if PTID
5532 represents a process, then all threads of the process are resumed;
5533 the thread to be stepped and/or signalled is given in the global
5537 append_resumption (char *p
, char *endp
,
5538 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5540 struct remote_state
*rs
= get_remote_state ();
5542 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5543 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5545 /* GDB is willing to range step. */
5546 && use_range_stepping
5547 /* Target supports range stepping. */
5548 && rs
->supports_vCont
.r
5549 /* We don't currently support range stepping multiple
5550 threads with a wildcard (though the protocol allows it,
5551 so stubs shouldn't make an active effort to forbid
5553 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5555 struct thread_info
*tp
;
5557 if (ptid_equal (ptid
, minus_one_ptid
))
5559 /* If we don't know about the target thread's tid, then
5560 we're resuming magic_null_ptid (see caller). */
5561 tp
= find_thread_ptid (magic_null_ptid
);
5564 tp
= find_thread_ptid (ptid
);
5565 gdb_assert (tp
!= NULL
);
5567 if (tp
->control
.may_range_step
)
5569 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5571 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
5572 phex_nz (tp
->control
.step_range_start
,
5574 phex_nz (tp
->control
.step_range_end
,
5578 p
+= xsnprintf (p
, endp
- p
, ";s");
5581 p
+= xsnprintf (p
, endp
- p
, ";s");
5582 else if (siggnal
!= GDB_SIGNAL_0
)
5583 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
5585 p
+= xsnprintf (p
, endp
- p
, ";c");
5587 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
5591 /* All (-1) threads of process. */
5592 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
5594 p
+= xsnprintf (p
, endp
- p
, ":");
5595 p
= write_ptid (p
, endp
, nptid
);
5597 else if (!ptid_equal (ptid
, minus_one_ptid
))
5599 p
+= xsnprintf (p
, endp
- p
, ":");
5600 p
= write_ptid (p
, endp
, ptid
);
5606 /* Clear the thread's private info on resume. */
5609 resume_clear_thread_private_info (struct thread_info
*thread
)
5611 if (thread
->priv
!= NULL
)
5613 thread
->priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
5614 thread
->priv
->watch_data_address
= 0;
5618 /* Append a vCont continue-with-signal action for threads that have a
5619 non-zero stop signal. */
5622 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
5624 struct thread_info
*thread
;
5626 ALL_NON_EXITED_THREADS (thread
)
5627 if (ptid_match (thread
->ptid
, ptid
)
5628 && !ptid_equal (inferior_ptid
, thread
->ptid
)
5629 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
5631 p
= append_resumption (p
, endp
, thread
->ptid
,
5632 0, thread
->suspend
.stop_signal
);
5633 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5634 resume_clear_thread_private_info (thread
);
5640 /* Set the target running, using the packets that use Hc
5644 remote_resume_with_hc (struct target_ops
*ops
,
5645 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5647 struct remote_state
*rs
= get_remote_state ();
5648 struct thread_info
*thread
;
5651 rs
->last_sent_signal
= siggnal
;
5652 rs
->last_sent_step
= step
;
5654 /* The c/s/C/S resume packets use Hc, so set the continue
5656 if (ptid_equal (ptid
, minus_one_ptid
))
5657 set_continue_thread (any_thread_ptid
);
5659 set_continue_thread (ptid
);
5661 ALL_NON_EXITED_THREADS (thread
)
5662 resume_clear_thread_private_info (thread
);
5665 if (execution_direction
== EXEC_REVERSE
)
5667 /* We don't pass signals to the target in reverse exec mode. */
5668 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5669 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5672 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
5673 error (_("Remote reverse-step not supported."));
5674 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
5675 error (_("Remote reverse-continue not supported."));
5677 strcpy (buf
, step
? "bs" : "bc");
5679 else if (siggnal
!= GDB_SIGNAL_0
)
5681 buf
[0] = step
? 'S' : 'C';
5682 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5683 buf
[2] = tohex (((int) siggnal
) & 0xf);
5687 strcpy (buf
, step
? "s" : "c");
5692 /* Resume the remote inferior by using a "vCont" packet. The thread
5693 to be resumed is PTID; STEP and SIGGNAL indicate whether the
5694 resumed thread should be single-stepped and/or signalled. If PTID
5695 equals minus_one_ptid, then all threads are resumed; the thread to
5696 be stepped and/or signalled is given in the global INFERIOR_PTID.
5697 This function returns non-zero iff it resumes the inferior.
5699 This function issues a strict subset of all possible vCont commands
5703 remote_resume_with_vcont (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5705 struct remote_state
*rs
= get_remote_state ();
5709 /* No reverse execution actions defined for vCont. */
5710 if (execution_direction
== EXEC_REVERSE
)
5713 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
5714 remote_vcont_probe (rs
);
5716 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
5720 endp
= rs
->buf
+ get_remote_packet_size ();
5722 /* If we could generate a wider range of packets, we'd have to worry
5723 about overflowing BUF. Should there be a generic
5724 "multi-part-packet" packet? */
5726 p
+= xsnprintf (p
, endp
- p
, "vCont");
5728 if (ptid_equal (ptid
, magic_null_ptid
))
5730 /* MAGIC_NULL_PTID means that we don't have any active threads,
5731 so we don't have any TID numbers the inferior will
5732 understand. Make sure to only send forms that do not specify
5734 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
5736 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
5738 /* Resume all threads (of all processes, or of a single
5739 process), with preference for INFERIOR_PTID. This assumes
5740 inferior_ptid belongs to the set of all threads we are about
5742 if (step
|| siggnal
!= GDB_SIGNAL_0
)
5744 /* Step inferior_ptid, with or without signal. */
5745 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
5748 /* Also pass down any pending signaled resumption for other
5749 threads not the current. */
5750 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
5752 /* And continue others without a signal. */
5753 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
5757 /* Scheduler locking; resume only PTID. */
5758 append_resumption (p
, endp
, ptid
, step
, siggnal
);
5761 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
5764 if (target_is_non_stop_p ())
5766 /* In non-stop, the stub replies to vCont with "OK". The stop
5767 reply will be reported asynchronously by means of a `%Stop'
5769 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5770 if (strcmp (rs
->buf
, "OK") != 0)
5771 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5777 /* Tell the remote machine to resume. */
5780 remote_resume (struct target_ops
*ops
,
5781 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5783 struct remote_state
*rs
= get_remote_state ();
5785 /* When connected in non-stop mode, the core resumes threads
5786 individually. Resuming remote threads directly in target_resume
5787 would thus result in sending one packet per thread. Instead, to
5788 minimize roundtrip latency, here we just store the resume
5789 request; the actual remote resumption will be done in
5790 target_commit_resume / remote_commit_resume, where we'll be able
5791 to do vCont action coalescing. */
5792 if (target_is_non_stop_p () && execution_direction
!= EXEC_REVERSE
)
5794 struct private_thread_info
*remote_thr
;
5796 if (ptid_equal (minus_one_ptid
, ptid
) || ptid_is_pid (ptid
))
5797 remote_thr
= get_private_info_ptid (inferior_ptid
);
5799 remote_thr
= get_private_info_ptid (ptid
);
5800 remote_thr
->last_resume_step
= step
;
5801 remote_thr
->last_resume_sig
= siggnal
;
5805 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5806 (explained in remote-notif.c:handle_notification) so
5807 remote_notif_process is not called. We need find a place where
5808 it is safe to start a 'vNotif' sequence. It is good to do it
5809 before resuming inferior, because inferior was stopped and no RSP
5810 traffic at that moment. */
5811 if (!target_is_non_stop_p ())
5812 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
5814 rs
->last_resume_exec_dir
= execution_direction
;
5816 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
5817 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
5818 remote_resume_with_hc (ops
, ptid
, step
, siggnal
);
5820 /* We are about to start executing the inferior, let's register it
5821 with the event loop. NOTE: this is the one place where all the
5822 execution commands end up. We could alternatively do this in each
5823 of the execution commands in infcmd.c. */
5824 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5825 into infcmd.c in order to allow inferior function calls to work
5826 NOT asynchronously. */
5827 if (target_can_async_p ())
5830 /* We've just told the target to resume. The remote server will
5831 wait for the inferior to stop, and then send a stop reply. In
5832 the mean time, we can't start another command/query ourselves
5833 because the stub wouldn't be ready to process it. This applies
5834 only to the base all-stop protocol, however. In non-stop (which
5835 only supports vCont), the stub replies with an "OK", and is
5836 immediate able to process further serial input. */
5837 if (!target_is_non_stop_p ())
5838 rs
->waiting_for_stop_reply
= 1;
5841 static void check_pending_events_prevent_wildcard_vcont
5842 (int *may_global_wildcard_vcont
);
5843 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
5845 /* Private per-inferior info for target remote processes. */
5847 struct private_inferior
5849 /* Whether we can send a wildcard vCont for this process. */
5850 int may_wildcard_vcont
;
5853 /* Structure used to track the construction of a vCont packet in the
5854 outgoing packet buffer. This is used to send multiple vCont
5855 packets if we have more actions than would fit a single packet. */
5857 struct vcont_builder
5859 /* Pointer to the first action. P points here if no action has been
5863 /* Where the next action will be appended. */
5866 /* The end of the buffer. Must never write past this. */
5870 /* Prepare the outgoing buffer for a new vCont packet. */
5873 vcont_builder_restart (struct vcont_builder
*builder
)
5875 struct remote_state
*rs
= get_remote_state ();
5877 builder
->p
= rs
->buf
;
5878 builder
->endp
= rs
->buf
+ get_remote_packet_size ();
5879 builder
->p
+= xsnprintf (builder
->p
, builder
->endp
- builder
->p
, "vCont");
5880 builder
->first_action
= builder
->p
;
5883 /* If the vCont packet being built has any action, send it to the
5887 vcont_builder_flush (struct vcont_builder
*builder
)
5889 struct remote_state
*rs
;
5891 if (builder
->p
== builder
->first_action
)
5894 rs
= get_remote_state ();
5896 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5897 if (strcmp (rs
->buf
, "OK") != 0)
5898 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5901 /* The largest action is range-stepping, with its two addresses. This
5902 is more than sufficient. If a new, bigger action is created, it'll
5903 quickly trigger a failed assertion in append_resumption (and we'll
5905 #define MAX_ACTION_SIZE 200
5907 /* Append a new vCont action in the outgoing packet being built. If
5908 the action doesn't fit the packet along with previous actions, push
5909 what we've got so far to the remote end and start over a new vCont
5910 packet (with the new action). */
5913 vcont_builder_push_action (struct vcont_builder
*builder
,
5914 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5916 char buf
[MAX_ACTION_SIZE
+ 1];
5920 endp
= append_resumption (buf
, buf
+ sizeof (buf
),
5921 ptid
, step
, siggnal
);
5923 /* Check whether this new action would fit in the vCont packet along
5924 with previous actions. If not, send what we've got so far and
5925 start a new vCont packet. */
5927 if (rsize
> builder
->endp
- builder
->p
)
5929 vcont_builder_flush (builder
);
5930 vcont_builder_restart (builder
);
5932 /* Should now fit. */
5933 gdb_assert (rsize
<= builder
->endp
- builder
->p
);
5936 memcpy (builder
->p
, buf
, rsize
);
5937 builder
->p
+= rsize
;
5941 /* to_commit_resume implementation. */
5944 remote_commit_resume (struct target_ops
*ops
)
5946 struct remote_state
*rs
= get_remote_state ();
5947 struct inferior
*inf
;
5948 struct thread_info
*tp
;
5949 int any_process_wildcard
;
5950 int may_global_wildcard_vcont
;
5951 struct vcont_builder vcont_builder
;
5953 /* If connected in all-stop mode, we'd send the remote resume
5954 request directly from remote_resume. Likewise if
5955 reverse-debugging, as there are no defined vCont actions for
5956 reverse execution. */
5957 if (!target_is_non_stop_p () || execution_direction
== EXEC_REVERSE
)
5960 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
5961 instead of resuming all threads of each process individually.
5962 However, if any thread of a process must remain halted, we can't
5963 send wildcard resumes and must send one action per thread.
5965 Care must be taken to not resume threads/processes the server
5966 side already told us are stopped, but the core doesn't know about
5967 yet, because the events are still in the vStopped notification
5970 #1 => vCont s:p1.1;c
5972 #3 <= %Stopped T05 p1.1
5977 #8 (infrun handles the stop for p1.1 and continues stepping)
5978 #9 => vCont s:p1.1;c
5980 The last vCont above would resume thread p1.2 by mistake, because
5981 the server has no idea that the event for p1.2 had not been
5984 The server side must similarly ignore resume actions for the
5985 thread that has a pending %Stopped notification (and any other
5986 threads with events pending), until GDB acks the notification
5987 with vStopped. Otherwise, e.g., the following case is
5990 #1 => g (or any other packet)
5992 #3 <= %Stopped T05 p1.2
5993 #4 => vCont s:p1.1;c
5996 Above, the server must not resume thread p1.2. GDB can't know
5997 that p1.2 stopped until it acks the %Stopped notification, and
5998 since from GDB's perspective all threads should be running, it
6001 Finally, special care must also be given to handling fork/vfork
6002 events. A (v)fork event actually tells us that two processes
6003 stopped -- the parent and the child. Until we follow the fork,
6004 we must not resume the child. Therefore, if we have a pending
6005 fork follow, we must not send a global wildcard resume action
6006 (vCont;c). We can still send process-wide wildcards though. */
6008 /* Start by assuming a global wildcard (vCont;c) is possible. */
6009 may_global_wildcard_vcont
= 1;
6011 /* And assume every process is individually wildcard-able too. */
6012 ALL_NON_EXITED_INFERIORS (inf
)
6014 if (inf
->priv
== NULL
)
6015 inf
->priv
= XNEW (struct private_inferior
);
6016 inf
->priv
->may_wildcard_vcont
= 1;
6019 /* Check for any pending events (not reported or processed yet) and
6020 disable process and global wildcard resumes appropriately. */
6021 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6023 ALL_NON_EXITED_THREADS (tp
)
6025 /* If a thread of a process is not meant to be resumed, then we
6026 can't wildcard that process. */
6029 tp
->inf
->priv
->may_wildcard_vcont
= 0;
6031 /* And if we can't wildcard a process, we can't wildcard
6032 everything either. */
6033 may_global_wildcard_vcont
= 0;
6037 /* If a thread is the parent of an unfollowed fork, then we
6038 can't do a global wildcard, as that would resume the fork
6040 if (is_pending_fork_parent_thread (tp
))
6041 may_global_wildcard_vcont
= 0;
6044 /* Now let's build the vCont packet(s). Actions must be appended
6045 from narrower to wider scopes (thread -> process -> global). If
6046 we end up with too many actions for a single packet vcont_builder
6047 flushes the current vCont packet to the remote side and starts a
6049 vcont_builder_restart (&vcont_builder
);
6051 /* Threads first. */
6052 ALL_NON_EXITED_THREADS (tp
)
6054 struct private_thread_info
*remote_thr
= tp
->priv
;
6056 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6059 gdb_assert (!thread_is_in_step_over_chain (tp
));
6061 if (!remote_thr
->last_resume_step
6062 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6063 && tp
->inf
->priv
->may_wildcard_vcont
)
6065 /* We'll send a wildcard resume instead. */
6066 remote_thr
->vcont_resumed
= 1;
6070 vcont_builder_push_action (&vcont_builder
, tp
->ptid
,
6071 remote_thr
->last_resume_step
,
6072 remote_thr
->last_resume_sig
);
6073 remote_thr
->vcont_resumed
= 1;
6076 /* Now check whether we can send any process-wide wildcard. This is
6077 to avoid sending a global wildcard in the case nothing is
6078 supposed to be resumed. */
6079 any_process_wildcard
= 0;
6081 ALL_NON_EXITED_INFERIORS (inf
)
6083 if (inf
->priv
->may_wildcard_vcont
)
6085 any_process_wildcard
= 1;
6090 if (any_process_wildcard
)
6092 /* If all processes are wildcard-able, then send a single "c"
6093 action, otherwise, send an "all (-1) threads of process"
6094 continue action for each running process, if any. */
6095 if (may_global_wildcard_vcont
)
6097 vcont_builder_push_action (&vcont_builder
, minus_one_ptid
,
6102 ALL_NON_EXITED_INFERIORS (inf
)
6104 if (inf
->priv
->may_wildcard_vcont
)
6106 vcont_builder_push_action (&vcont_builder
,
6107 pid_to_ptid (inf
->pid
),
6114 vcont_builder_flush (&vcont_builder
);
6119 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6120 thread, all threads of a remote process, or all threads of all
6124 remote_stop_ns (ptid_t ptid
)
6126 struct remote_state
*rs
= get_remote_state ();
6128 char *endp
= rs
->buf
+ get_remote_packet_size ();
6130 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6131 remote_vcont_probe (rs
);
6133 if (!rs
->supports_vCont
.t
)
6134 error (_("Remote server does not support stopping threads"));
6136 if (ptid_equal (ptid
, minus_one_ptid
)
6137 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
6138 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6143 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6145 if (ptid_is_pid (ptid
))
6146 /* All (-1) threads of process. */
6147 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
6150 /* Small optimization: if we already have a stop reply for
6151 this thread, no use in telling the stub we want this
6153 if (peek_stop_reply (ptid
))
6159 write_ptid (p
, endp
, nptid
);
6162 /* In non-stop, we get an immediate OK reply. The stop reply will
6163 come in asynchronously by notification. */
6165 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6166 if (strcmp (rs
->buf
, "OK") != 0)
6167 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
6170 /* All-stop version of target_interrupt. Sends a break or a ^C to
6171 interrupt the remote target. It is undefined which thread of which
6172 process reports the interrupt. */
6175 remote_interrupt_as (void)
6177 struct remote_state
*rs
= get_remote_state ();
6179 rs
->ctrlc_pending_p
= 1;
6181 /* If the inferior is stopped already, but the core didn't know
6182 about it yet, just ignore the request. The cached wait status
6183 will be collected in remote_wait. */
6184 if (rs
->cached_wait_status
)
6187 /* Send interrupt_sequence to remote target. */
6188 send_interrupt_sequence ();
6191 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6192 the remote target. It is undefined which thread of which process
6193 reports the interrupt. Throws an error if the packet is not
6194 supported by the server. */
6197 remote_interrupt_ns (void)
6199 struct remote_state
*rs
= get_remote_state ();
6201 char *endp
= rs
->buf
+ get_remote_packet_size ();
6203 xsnprintf (p
, endp
- p
, "vCtrlC");
6205 /* In non-stop, we get an immediate OK reply. The stop reply will
6206 come in asynchronously by notification. */
6208 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6210 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6214 case PACKET_UNKNOWN
:
6215 error (_("No support for interrupting the remote target."));
6217 error (_("Interrupting target failed: %s"), rs
->buf
);
6221 /* Implement the to_stop function for the remote targets. */
6224 remote_stop (struct target_ops
*self
, ptid_t ptid
)
6227 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6229 if (target_is_non_stop_p ())
6230 remote_stop_ns (ptid
);
6233 /* We don't currently have a way to transparently pause the
6234 remote target in all-stop mode. Interrupt it instead. */
6235 remote_interrupt_as ();
6239 /* Implement the to_interrupt function for the remote targets. */
6242 remote_interrupt (struct target_ops
*self
, ptid_t ptid
)
6244 struct remote_state
*rs
= get_remote_state ();
6247 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6249 if (target_is_non_stop_p ())
6250 remote_interrupt_ns ();
6252 remote_interrupt_as ();
6255 /* Implement the to_pass_ctrlc function for the remote targets. */
6258 remote_pass_ctrlc (struct target_ops
*self
)
6260 struct remote_state
*rs
= get_remote_state ();
6263 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6265 /* If we're starting up, we're not fully synced yet. Quit
6267 if (rs
->starting_up
)
6269 /* If ^C has already been sent once, offer to disconnect. */
6270 else if (rs
->ctrlc_pending_p
)
6273 target_interrupt (inferior_ptid
);
6276 /* Ask the user what to do when an interrupt is received. */
6279 interrupt_query (void)
6281 struct remote_state
*rs
= get_remote_state ();
6283 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6285 if (query (_("The target is not responding to interrupt requests.\n"
6286 "Stop debugging it? ")))
6288 remote_unpush_target ();
6289 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6294 if (query (_("Interrupted while waiting for the program.\n"
6295 "Give up waiting? ")))
6300 /* Enable/disable target terminal ownership. Most targets can use
6301 terminal groups to control terminal ownership. Remote targets are
6302 different in that explicit transfer of ownership to/from GDB/target
6306 remote_terminal_inferior (struct target_ops
*self
)
6308 /* FIXME: cagney/1999-09-27: Make calls to target_terminal::*()
6309 idempotent. The event-loop GDB talking to an asynchronous target
6310 with a synchronous command calls this function from both
6311 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
6312 transfer the terminal to the target when it shouldn't this guard
6314 if (!remote_async_terminal_ours_p
)
6316 remote_async_terminal_ours_p
= 0;
6317 /* NOTE: At this point we could also register our selves as the
6318 recipient of all input. Any characters typed could then be
6319 passed on down to the target. */
6323 remote_terminal_ours (struct target_ops
*self
)
6325 /* See FIXME in remote_terminal_inferior. */
6326 if (remote_async_terminal_ours_p
)
6328 remote_async_terminal_ours_p
= 1;
6332 remote_console_output (char *msg
)
6336 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6339 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6343 fputs_unfiltered (tb
, gdb_stdtarg
);
6345 gdb_flush (gdb_stdtarg
);
6348 DEF_VEC_O(cached_reg_t
);
6350 typedef struct stop_reply
6352 struct notif_event base
;
6354 /* The identifier of the thread about this event */
6357 /* The remote state this event is associated with. When the remote
6358 connection, represented by a remote_state object, is closed,
6359 all the associated stop_reply events should be released. */
6360 struct remote_state
*rs
;
6362 struct target_waitstatus ws
;
6364 /* Expedited registers. This makes remote debugging a bit more
6365 efficient for those targets that provide critical registers as
6366 part of their normal status mechanism (as another roundtrip to
6367 fetch them is avoided). */
6368 VEC(cached_reg_t
) *regcache
;
6370 enum target_stop_reason stop_reason
;
6372 CORE_ADDR watch_data_address
;
6377 DECLARE_QUEUE_P (stop_reply_p
);
6378 DEFINE_QUEUE_P (stop_reply_p
);
6379 /* The list of already fetched and acknowledged stop events. This
6380 queue is used for notification Stop, and other notifications
6381 don't need queue for their events, because the notification events
6382 of Stop can't be consumed immediately, so that events should be
6383 queued first, and be consumed by remote_wait_{ns,as} one per
6384 time. Other notifications can consume their events immediately,
6385 so queue is not needed for them. */
6386 static QUEUE (stop_reply_p
) *stop_reply_queue
;
6389 stop_reply_xfree (struct stop_reply
*r
)
6391 notif_event_xfree ((struct notif_event
*) r
);
6394 /* Return the length of the stop reply queue. */
6397 stop_reply_queue_length (void)
6399 return QUEUE_length (stop_reply_p
, stop_reply_queue
);
6403 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
6404 struct notif_event
*event
)
6406 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6410 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
6411 struct notif_event
*event
)
6413 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6416 putpkt (self
->ack_command
);
6418 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6419 /* We got an unknown stop reply. */
6420 error (_("Unknown stop reply"));
6422 push_stop_reply (stop_reply
);
6426 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
6428 /* We can't get pending events in remote_notif_process for
6429 notification stop, and we have to do this in remote_wait_ns
6430 instead. If we fetch all queued events from stub, remote stub
6431 may exit and we have no chance to process them back in
6433 mark_async_event_handler (remote_async_inferior_event_token
);
6438 stop_reply_dtr (struct notif_event
*event
)
6440 struct stop_reply
*r
= (struct stop_reply
*) event
;
6445 VEC_iterate (cached_reg_t
, r
->regcache
, ix
, reg
);
6449 VEC_free (cached_reg_t
, r
->regcache
);
6452 static struct notif_event
*
6453 remote_notif_stop_alloc_reply (void)
6455 /* We cast to a pointer to the "base class". */
6456 struct notif_event
*r
= (struct notif_event
*) XNEW (struct stop_reply
);
6458 r
->dtr
= stop_reply_dtr
;
6463 /* A client of notification Stop. */
6465 struct notif_client notif_client_stop
=
6469 remote_notif_stop_parse
,
6470 remote_notif_stop_ack
,
6471 remote_notif_stop_can_get_pending_events
,
6472 remote_notif_stop_alloc_reply
,
6476 /* A parameter to pass data in and out. */
6478 struct queue_iter_param
6481 struct stop_reply
*output
;
6484 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6485 the pid of the process that owns the threads we want to check, or
6486 -1 if we want to check all threads. */
6489 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6492 if (ws
->kind
== TARGET_WAITKIND_FORKED
6493 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6495 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
6502 /* Return the thread's pending status used to determine whether the
6503 thread is a fork parent stopped at a fork event. */
6505 static struct target_waitstatus
*
6506 thread_pending_fork_status (struct thread_info
*thread
)
6508 if (thread
->suspend
.waitstatus_pending_p
)
6509 return &thread
->suspend
.waitstatus
;
6511 return &thread
->pending_follow
;
6514 /* Determine if THREAD is a pending fork parent thread. */
6517 is_pending_fork_parent_thread (struct thread_info
*thread
)
6519 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6522 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6525 /* Check whether EVENT is a fork event, and if it is, remove the
6526 fork child from the context list passed in DATA. */
6529 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
6530 QUEUE_ITER (stop_reply_p
) *iter
,
6534 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6535 struct threads_listing_context
*context
6536 = (struct threads_listing_context
*) param
->input
;
6538 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6539 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6540 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6541 threads_listing_context_remove (&event
->ws
, context
);
6546 /* If CONTEXT contains any fork child threads that have not been
6547 reported yet, remove them from the CONTEXT list. If such a
6548 thread exists it is because we are stopped at a fork catchpoint
6549 and have not yet called follow_fork, which will set up the
6550 host-side data structures for the new process. */
6553 remove_new_fork_children (struct threads_listing_context
*context
)
6555 struct thread_info
* thread
;
6557 struct notif_client
*notif
= ¬if_client_stop
;
6558 struct queue_iter_param param
;
6560 /* For any threads stopped at a fork event, remove the corresponding
6561 fork child threads from the CONTEXT list. */
6562 ALL_NON_EXITED_THREADS (thread
)
6564 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6566 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6568 threads_listing_context_remove (ws
, context
);
6572 /* Check for any pending fork events (not reported or processed yet)
6573 in process PID and remove those fork child threads from the
6574 CONTEXT list as well. */
6575 remote_notif_get_pending_events (notif
);
6576 param
.input
= context
;
6577 param
.output
= NULL
;
6578 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6579 remove_child_of_pending_fork
, ¶m
);
6582 /* Check whether EVENT would prevent a global or process wildcard
6586 check_pending_event_prevents_wildcard_vcont_callback
6587 (QUEUE (stop_reply_p
) *q
,
6588 QUEUE_ITER (stop_reply_p
) *iter
,
6592 struct inferior
*inf
;
6593 int *may_global_wildcard_vcont
= (int *) data
;
6595 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6596 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6599 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6600 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6601 *may_global_wildcard_vcont
= 0;
6603 inf
= find_inferior_ptid (event
->ptid
);
6605 /* This may be the first time we heard about this process.
6606 Regardless, we must not do a global wildcard resume, otherwise
6607 we'd resume this process too. */
6608 *may_global_wildcard_vcont
= 0;
6610 inf
->priv
->may_wildcard_vcont
= 0;
6615 /* Check whether any event pending in the vStopped queue would prevent
6616 a global or process wildcard vCont action. Clear
6617 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6618 and clear the event inferior's may_wildcard_vcont flag if we can't
6619 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6622 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard
)
6624 struct notif_client
*notif
= ¬if_client_stop
;
6626 remote_notif_get_pending_events (notif
);
6627 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6628 check_pending_event_prevents_wildcard_vcont_callback
,
6629 may_global_wildcard
);
6632 /* Remove stop replies in the queue if its pid is equal to the given
6636 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
6637 QUEUE_ITER (stop_reply_p
) *iter
,
6641 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6642 struct inferior
*inf
= (struct inferior
*) param
->input
;
6644 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
6646 stop_reply_xfree (event
);
6647 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6653 /* Discard all pending stop replies of inferior INF. */
6656 discard_pending_stop_replies (struct inferior
*inf
)
6658 struct queue_iter_param param
;
6659 struct stop_reply
*reply
;
6660 struct remote_state
*rs
= get_remote_state ();
6661 struct remote_notif_state
*rns
= rs
->notif_state
;
6663 /* This function can be notified when an inferior exists. When the
6664 target is not remote, the notification state is NULL. */
6665 if (rs
->remote_desc
== NULL
)
6668 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
6670 /* Discard the in-flight notification. */
6671 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
6673 stop_reply_xfree (reply
);
6674 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
6678 param
.output
= NULL
;
6679 /* Discard the stop replies we have already pulled with
6681 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6682 remove_stop_reply_for_inferior
, ¶m
);
6685 /* If its remote state is equal to the given remote state,
6686 remove EVENT from the stop reply queue. */
6689 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
6690 QUEUE_ITER (stop_reply_p
) *iter
,
6694 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6695 struct remote_state
*rs
= (struct remote_state
*) param
->input
;
6697 if (event
->rs
== rs
)
6699 stop_reply_xfree (event
);
6700 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6706 /* Discard the stop replies for RS in stop_reply_queue. */
6709 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
6711 struct queue_iter_param param
;
6714 param
.output
= NULL
;
6715 /* Discard the stop replies we have already pulled with
6717 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6718 remove_stop_reply_of_remote_state
, ¶m
);
6721 /* A parameter to pass data in and out. */
6724 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
6725 QUEUE_ITER (stop_reply_p
) *iter
,
6729 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6730 ptid_t
*ptid
= (ptid_t
*) param
->input
;
6732 if (ptid_match (event
->ptid
, *ptid
))
6734 param
->output
= event
;
6735 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6742 /* Remove the first reply in 'stop_reply_queue' which matches
6745 static struct stop_reply
*
6746 remote_notif_remove_queued_reply (ptid_t ptid
)
6748 struct queue_iter_param param
;
6750 param
.input
= &ptid
;
6751 param
.output
= NULL
;
6753 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6754 remote_notif_remove_once_on_match
, ¶m
);
6756 fprintf_unfiltered (gdb_stdlog
,
6757 "notif: discard queued event: 'Stop' in %s\n",
6758 target_pid_to_str (ptid
));
6760 return param
.output
;
6763 /* Look for a queued stop reply belonging to PTID. If one is found,
6764 remove it from the queue, and return it. Returns NULL if none is
6765 found. If there are still queued events left to process, tell the
6766 event loop to get back to target_wait soon. */
6768 static struct stop_reply
*
6769 queued_stop_reply (ptid_t ptid
)
6771 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
6773 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6774 /* There's still at least an event left. */
6775 mark_async_event_handler (remote_async_inferior_event_token
);
6780 /* Push a fully parsed stop reply in the stop reply queue. Since we
6781 know that we now have at least one queued event left to pass to the
6782 core side, tell the event loop to get back to target_wait soon. */
6785 push_stop_reply (struct stop_reply
*new_event
)
6787 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
6790 fprintf_unfiltered (gdb_stdlog
,
6791 "notif: push 'Stop' %s to queue %d\n",
6792 target_pid_to_str (new_event
->ptid
),
6793 QUEUE_length (stop_reply_p
,
6796 mark_async_event_handler (remote_async_inferior_event_token
);
6800 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
6801 QUEUE_ITER (stop_reply_p
) *iter
,
6802 struct stop_reply
*event
,
6805 ptid_t
*ptid
= (ptid_t
*) data
;
6807 return !(ptid_equal (*ptid
, event
->ptid
)
6808 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
6811 /* Returns true if we have a stop reply for PTID. */
6814 peek_stop_reply (ptid_t ptid
)
6816 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6817 stop_reply_match_ptid_and_ws
, &ptid
);
6820 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6821 starting with P and ending with PEND matches PREFIX. */
6824 strprefix (const char *p
, const char *pend
, const char *prefix
)
6826 for ( ; p
< pend
; p
++, prefix
++)
6829 return *prefix
== '\0';
6832 /* Parse the stop reply in BUF. Either the function succeeds, and the
6833 result is stored in EVENT, or throws an error. */
6836 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
6838 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6843 event
->ptid
= null_ptid
;
6844 event
->rs
= get_remote_state ();
6845 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
6846 event
->ws
.value
.integer
= 0;
6847 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6848 event
->regcache
= NULL
;
6853 case 'T': /* Status with PC, SP, FP, ... */
6854 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6855 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6857 n... = register number
6858 r... = register contents
6861 p
= &buf
[3]; /* after Txx */
6867 p1
= strchr (p
, ':');
6869 error (_("Malformed packet(a) (missing colon): %s\n\
6873 error (_("Malformed packet(a) (missing register number): %s\n\
6877 /* Some "registers" are actually extended stop information.
6878 Note if you're adding a new entry here: GDB 7.9 and
6879 earlier assume that all register "numbers" that start
6880 with an hex digit are real register numbers. Make sure
6881 the server only sends such a packet if it knows the
6882 client understands it. */
6884 if (strprefix (p
, p1
, "thread"))
6885 event
->ptid
= read_ptid (++p1
, &p
);
6886 else if (strprefix (p
, p1
, "syscall_entry"))
6890 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
6891 p
= unpack_varlen_hex (++p1
, &sysno
);
6892 event
->ws
.value
.syscall_number
= (int) sysno
;
6894 else if (strprefix (p
, p1
, "syscall_return"))
6898 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
6899 p
= unpack_varlen_hex (++p1
, &sysno
);
6900 event
->ws
.value
.syscall_number
= (int) sysno
;
6902 else if (strprefix (p
, p1
, "watch")
6903 || strprefix (p
, p1
, "rwatch")
6904 || strprefix (p
, p1
, "awatch"))
6906 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
6907 p
= unpack_varlen_hex (++p1
, &addr
);
6908 event
->watch_data_address
= (CORE_ADDR
) addr
;
6910 else if (strprefix (p
, p1
, "swbreak"))
6912 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
6914 /* Make sure the stub doesn't forget to indicate support
6916 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
6917 error (_("Unexpected swbreak stop reason"));
6919 /* The value part is documented as "must be empty",
6920 though we ignore it, in case we ever decide to make
6921 use of it in a backward compatible way. */
6922 p
= strchrnul (p1
+ 1, ';');
6924 else if (strprefix (p
, p1
, "hwbreak"))
6926 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
6928 /* Make sure the stub doesn't forget to indicate support
6930 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
6931 error (_("Unexpected hwbreak stop reason"));
6934 p
= strchrnul (p1
+ 1, ';');
6936 else if (strprefix (p
, p1
, "library"))
6938 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
6939 p
= strchrnul (p1
+ 1, ';');
6941 else if (strprefix (p
, p1
, "replaylog"))
6943 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
6944 /* p1 will indicate "begin" or "end", but it makes
6945 no difference for now, so ignore it. */
6946 p
= strchrnul (p1
+ 1, ';');
6948 else if (strprefix (p
, p1
, "core"))
6952 p
= unpack_varlen_hex (++p1
, &c
);
6955 else if (strprefix (p
, p1
, "fork"))
6957 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6958 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
6960 else if (strprefix (p
, p1
, "vfork"))
6962 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6963 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
6965 else if (strprefix (p
, p1
, "vforkdone"))
6967 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
6968 p
= strchrnul (p1
+ 1, ';');
6970 else if (strprefix (p
, p1
, "exec"))
6973 char pathname
[PATH_MAX
];
6976 /* Determine the length of the execd pathname. */
6977 p
= unpack_varlen_hex (++p1
, &ignored
);
6978 pathlen
= (p
- p1
) / 2;
6980 /* Save the pathname for event reporting and for
6981 the next run command. */
6982 hex2bin (p1
, (gdb_byte
*) pathname
, pathlen
);
6983 pathname
[pathlen
] = '\0';
6985 /* This is freed during event handling. */
6986 event
->ws
.value
.execd_pathname
= xstrdup (pathname
);
6987 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
6989 /* Skip the registers included in this packet, since
6990 they may be for an architecture different from the
6991 one used by the original program. */
6994 else if (strprefix (p
, p1
, "create"))
6996 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
6997 p
= strchrnul (p1
+ 1, ';');
7006 p
= strchrnul (p1
+ 1, ';');
7011 /* Maybe a real ``P'' register number. */
7012 p_temp
= unpack_varlen_hex (p
, &pnum
);
7013 /* If the first invalid character is the colon, we got a
7014 register number. Otherwise, it's an unknown stop
7018 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
7019 cached_reg_t cached_reg
;
7020 struct gdbarch
*gdbarch
= target_gdbarch ();
7023 error (_("Remote sent bad register number %s: %s\n\
7025 hex_string (pnum
), p
, buf
);
7027 cached_reg
.num
= reg
->regnum
;
7028 cached_reg
.data
= (gdb_byte
*)
7029 xmalloc (register_size (gdbarch
, reg
->regnum
));
7032 fieldsize
= hex2bin (p
, cached_reg
.data
,
7033 register_size (gdbarch
, reg
->regnum
));
7035 if (fieldsize
< register_size (gdbarch
, reg
->regnum
))
7036 warning (_("Remote reply is too short: %s"), buf
);
7038 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
7042 /* Not a number. Silently skip unknown optional
7044 p
= strchrnul (p1
+ 1, ';');
7049 error (_("Remote register badly formatted: %s\nhere: %s"),
7054 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7058 case 'S': /* Old style status, just signal only. */
7062 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7063 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7064 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7065 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7067 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7070 case 'w': /* Thread exited. */
7075 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7076 p
= unpack_varlen_hex (&buf
[1], &value
);
7077 event
->ws
.value
.integer
= value
;
7079 error (_("stop reply packet badly formatted: %s"), buf
);
7080 event
->ptid
= read_ptid (++p
, NULL
);
7083 case 'W': /* Target exited. */
7090 /* GDB used to accept only 2 hex chars here. Stubs should
7091 only send more if they detect GDB supports multi-process
7093 p
= unpack_varlen_hex (&buf
[1], &value
);
7097 /* The remote process exited. */
7098 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7099 event
->ws
.value
.integer
= value
;
7103 /* The remote process exited with a signal. */
7104 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7105 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7106 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7108 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7111 /* If no process is specified, assume inferior_ptid. */
7112 pid
= ptid_get_pid (inferior_ptid
);
7121 else if (startswith (p
, "process:"))
7125 p
+= sizeof ("process:") - 1;
7126 unpack_varlen_hex (p
, &upid
);
7130 error (_("unknown stop reply packet: %s"), buf
);
7133 error (_("unknown stop reply packet: %s"), buf
);
7134 event
->ptid
= pid_to_ptid (pid
);
7138 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7139 event
->ptid
= minus_one_ptid
;
7143 if (target_is_non_stop_p () && ptid_equal (event
->ptid
, null_ptid
))
7144 error (_("No process or thread specified in stop reply: %s"), buf
);
7147 /* When the stub wants to tell GDB about a new notification reply, it
7148 sends a notification (%Stop, for example). Those can come it at
7149 any time, hence, we have to make sure that any pending
7150 putpkt/getpkt sequence we're making is finished, before querying
7151 the stub for more events with the corresponding ack command
7152 (vStopped, for example). E.g., if we started a vStopped sequence
7153 immediately upon receiving the notification, something like this
7161 1.6) <-- (registers reply to step #1.3)
7163 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7166 To solve this, whenever we parse a %Stop notification successfully,
7167 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7168 doing whatever we were doing:
7174 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7175 2.5) <-- (registers reply to step #2.3)
7177 Eventualy after step #2.5, we return to the event loop, which
7178 notices there's an event on the
7179 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7180 associated callback --- the function below. At this point, we're
7181 always safe to start a vStopped sequence. :
7184 2.7) <-- T05 thread:2
7190 remote_notif_get_pending_events (struct notif_client
*nc
)
7192 struct remote_state
*rs
= get_remote_state ();
7194 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7197 fprintf_unfiltered (gdb_stdlog
,
7198 "notif: process: '%s' ack pending event\n",
7202 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
7203 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7207 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7208 if (strcmp (rs
->buf
, "OK") == 0)
7211 remote_notif_ack (nc
, rs
->buf
);
7217 fprintf_unfiltered (gdb_stdlog
,
7218 "notif: process: '%s' no pending reply\n",
7223 /* Called when it is decided that STOP_REPLY holds the info of the
7224 event that is to be returned to the core. This function always
7225 destroys STOP_REPLY. */
7228 process_stop_reply (struct stop_reply
*stop_reply
,
7229 struct target_waitstatus
*status
)
7233 *status
= stop_reply
->ws
;
7234 ptid
= stop_reply
->ptid
;
7236 /* If no thread/process was reported by the stub, assume the current
7238 if (ptid_equal (ptid
, null_ptid
))
7239 ptid
= inferior_ptid
;
7241 if (status
->kind
!= TARGET_WAITKIND_EXITED
7242 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7243 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7245 struct private_thread_info
*remote_thr
;
7247 /* Expedited registers. */
7248 if (stop_reply
->regcache
)
7250 struct regcache
*regcache
7251 = get_thread_arch_regcache (ptid
, target_gdbarch ());
7256 VEC_iterate (cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
7259 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
7263 VEC_free (cached_reg_t
, stop_reply
->regcache
);
7266 remote_notice_new_inferior (ptid
, 0);
7267 remote_thr
= get_private_info_ptid (ptid
);
7268 remote_thr
->core
= stop_reply
->core
;
7269 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7270 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7271 remote_thr
->vcont_resumed
= 0;
7274 stop_reply_xfree (stop_reply
);
7278 /* The non-stop mode version of target_wait. */
7281 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7283 struct remote_state
*rs
= get_remote_state ();
7284 struct stop_reply
*stop_reply
;
7288 /* If in non-stop mode, get out of getpkt even if a
7289 notification is received. */
7291 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7292 0 /* forever */, &is_notif
);
7295 if (ret
!= -1 && !is_notif
)
7298 case 'E': /* Error of some sort. */
7299 /* We're out of sync with the target now. Did it continue
7300 or not? We can't tell which thread it was in non-stop,
7301 so just ignore this. */
7302 warning (_("Remote failure reply: %s"), rs
->buf
);
7304 case 'O': /* Console output. */
7305 remote_console_output (rs
->buf
+ 1);
7308 warning (_("Invalid remote reply: %s"), rs
->buf
);
7312 /* Acknowledge a pending stop reply that may have arrived in the
7314 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7315 remote_notif_get_pending_events (¬if_client_stop
);
7317 /* If indeed we noticed a stop reply, we're done. */
7318 stop_reply
= queued_stop_reply (ptid
);
7319 if (stop_reply
!= NULL
)
7320 return process_stop_reply (stop_reply
, status
);
7322 /* Still no event. If we're just polling for an event, then
7323 return to the event loop. */
7324 if (options
& TARGET_WNOHANG
)
7326 status
->kind
= TARGET_WAITKIND_IGNORE
;
7327 return minus_one_ptid
;
7330 /* Otherwise do a blocking wait. */
7331 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7332 1 /* forever */, &is_notif
);
7336 /* Wait until the remote machine stops, then return, storing status in
7337 STATUS just as `wait' would. */
7340 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7342 struct remote_state
*rs
= get_remote_state ();
7343 ptid_t event_ptid
= null_ptid
;
7345 struct stop_reply
*stop_reply
;
7349 status
->kind
= TARGET_WAITKIND_IGNORE
;
7350 status
->value
.integer
= 0;
7352 stop_reply
= queued_stop_reply (ptid
);
7353 if (stop_reply
!= NULL
)
7354 return process_stop_reply (stop_reply
, status
);
7356 if (rs
->cached_wait_status
)
7357 /* Use the cached wait status, but only once. */
7358 rs
->cached_wait_status
= 0;
7363 int forever
= ((options
& TARGET_WNOHANG
) == 0
7364 && wait_forever_enabled_p
);
7366 if (!rs
->waiting_for_stop_reply
)
7368 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7369 return minus_one_ptid
;
7372 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7373 _never_ wait for ever -> test on target_is_async_p().
7374 However, before we do that we need to ensure that the caller
7375 knows how to take the target into/out of async mode. */
7376 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7377 forever
, &is_notif
);
7379 /* GDB gets a notification. Return to core as this event is
7381 if (ret
!= -1 && is_notif
)
7382 return minus_one_ptid
;
7384 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7385 return minus_one_ptid
;
7390 /* Assume that the target has acknowledged Ctrl-C unless we receive
7391 an 'F' or 'O' packet. */
7392 if (buf
[0] != 'F' && buf
[0] != 'O')
7393 rs
->ctrlc_pending_p
= 0;
7397 case 'E': /* Error of some sort. */
7398 /* We're out of sync with the target now. Did it continue or
7399 not? Not is more likely, so report a stop. */
7400 rs
->waiting_for_stop_reply
= 0;
7402 warning (_("Remote failure reply: %s"), buf
);
7403 status
->kind
= TARGET_WAITKIND_STOPPED
;
7404 status
->value
.sig
= GDB_SIGNAL_0
;
7406 case 'F': /* File-I/O request. */
7407 /* GDB may access the inferior memory while handling the File-I/O
7408 request, but we don't want GDB accessing memory while waiting
7409 for a stop reply. See the comments in putpkt_binary. Set
7410 waiting_for_stop_reply to 0 temporarily. */
7411 rs
->waiting_for_stop_reply
= 0;
7412 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
7413 rs
->ctrlc_pending_p
= 0;
7414 /* GDB handled the File-I/O request, and the target is running
7415 again. Keep waiting for events. */
7416 rs
->waiting_for_stop_reply
= 1;
7418 case 'N': case 'T': case 'S': case 'X': case 'W':
7420 struct stop_reply
*stop_reply
;
7422 /* There is a stop reply to handle. */
7423 rs
->waiting_for_stop_reply
= 0;
7426 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
7429 event_ptid
= process_stop_reply (stop_reply
, status
);
7432 case 'O': /* Console output. */
7433 remote_console_output (buf
+ 1);
7436 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7438 /* Zero length reply means that we tried 'S' or 'C' and the
7439 remote system doesn't support it. */
7440 target_terminal::ours_for_output ();
7442 ("Can't send signals to this remote system. %s not sent.\n",
7443 gdb_signal_to_name (rs
->last_sent_signal
));
7444 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7445 target_terminal::inferior ();
7447 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7451 /* else fallthrough */
7453 warning (_("Invalid remote reply: %s"), buf
);
7457 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7458 return minus_one_ptid
;
7459 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7461 /* Nothing interesting happened. If we're doing a non-blocking
7462 poll, we're done. Otherwise, go back to waiting. */
7463 if (options
& TARGET_WNOHANG
)
7464 return minus_one_ptid
;
7468 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7469 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7471 if (!ptid_equal (event_ptid
, null_ptid
))
7472 record_currthread (rs
, event_ptid
);
7474 event_ptid
= inferior_ptid
;
7477 /* A process exit. Invalidate our notion of current thread. */
7478 record_currthread (rs
, minus_one_ptid
);
7483 /* Wait until the remote machine stops, then return, storing status in
7484 STATUS just as `wait' would. */
7487 remote_wait (struct target_ops
*ops
,
7488 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7492 if (target_is_non_stop_p ())
7493 event_ptid
= remote_wait_ns (ptid
, status
, options
);
7495 event_ptid
= remote_wait_as (ptid
, status
, options
);
7497 if (target_is_async_p ())
7499 /* If there are are events left in the queue tell the event loop
7501 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
7502 mark_async_event_handler (remote_async_inferior_event_token
);
7508 /* Fetch a single register using a 'p' packet. */
7511 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
7513 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7514 struct remote_state
*rs
= get_remote_state ();
7516 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7519 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7522 if (reg
->pnum
== -1)
7527 p
+= hexnumstr (p
, reg
->pnum
);
7530 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7534 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
7538 case PACKET_UNKNOWN
:
7541 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7542 gdbarch_register_name (get_regcache_arch (regcache
),
7547 /* If this register is unfetchable, tell the regcache. */
7550 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7554 /* Otherwise, parse and supply the value. */
7560 error (_("fetch_register_using_p: early buf termination"));
7562 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7565 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
7569 /* Fetch the registers included in the target's 'g' packet. */
7572 send_g_packet (void)
7574 struct remote_state
*rs
= get_remote_state ();
7577 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
7578 remote_send (&rs
->buf
, &rs
->buf_size
);
7580 /* We can get out of synch in various cases. If the first character
7581 in the buffer is not a hex character, assume that has happened
7582 and try to fetch another packet to read. */
7583 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7584 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7585 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7586 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7589 fprintf_unfiltered (gdb_stdlog
,
7590 "Bad register packet; fetching a new packet\n");
7591 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7594 buf_len
= strlen (rs
->buf
);
7596 /* Sanity check the received packet. */
7597 if (buf_len
% 2 != 0)
7598 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
7604 process_g_packet (struct regcache
*regcache
)
7606 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7607 struct remote_state
*rs
= get_remote_state ();
7608 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7613 buf_len
= strlen (rs
->buf
);
7615 /* Further sanity checks, with knowledge of the architecture. */
7616 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7617 error (_("Remote 'g' packet reply is too long (expected %ld bytes, got %d "
7618 "bytes): %s"), rsa
->sizeof_g_packet
, buf_len
/ 2, rs
->buf
);
7620 /* Save the size of the packet sent to us by the target. It is used
7621 as a heuristic when determining the max size of packets that the
7622 target can safely receive. */
7623 if (rsa
->actual_register_packet_size
== 0)
7624 rsa
->actual_register_packet_size
= buf_len
;
7626 /* If this is smaller than we guessed the 'g' packet would be,
7627 update our records. A 'g' reply that doesn't include a register's
7628 value implies either that the register is not available, or that
7629 the 'p' packet must be used. */
7630 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7632 long sizeof_g_packet
= buf_len
/ 2;
7634 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7636 long offset
= rsa
->regs
[i
].offset
;
7637 long reg_size
= register_size (gdbarch
, i
);
7639 if (rsa
->regs
[i
].pnum
== -1)
7642 if (offset
>= sizeof_g_packet
)
7643 rsa
->regs
[i
].in_g_packet
= 0;
7644 else if (offset
+ reg_size
> sizeof_g_packet
)
7645 error (_("Truncated register %d in remote 'g' packet"), i
);
7647 rsa
->regs
[i
].in_g_packet
= 1;
7650 /* Looks valid enough, we can assume this is the correct length
7651 for a 'g' packet. It's important not to adjust
7652 rsa->sizeof_g_packet if we have truncated registers otherwise
7653 this "if" won't be run the next time the method is called
7654 with a packet of the same size and one of the internal errors
7655 below will trigger instead. */
7656 rsa
->sizeof_g_packet
= sizeof_g_packet
;
7659 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
7661 /* Unimplemented registers read as all bits zero. */
7662 memset (regs
, 0, rsa
->sizeof_g_packet
);
7664 /* Reply describes registers byte by byte, each byte encoded as two
7665 hex characters. Suck them all up, then supply them to the
7666 register cacheing/storage mechanism. */
7669 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
7671 if (p
[0] == 0 || p
[1] == 0)
7672 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7673 internal_error (__FILE__
, __LINE__
,
7674 _("unexpected end of 'g' packet reply"));
7676 if (p
[0] == 'x' && p
[1] == 'x')
7677 regs
[i
] = 0; /* 'x' */
7679 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7683 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7685 struct packet_reg
*r
= &rsa
->regs
[i
];
7686 long reg_size
= register_size (gdbarch
, i
);
7690 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
))
7691 /* This shouldn't happen - we adjusted in_g_packet above. */
7692 internal_error (__FILE__
, __LINE__
,
7693 _("unexpected end of 'g' packet reply"));
7694 else if (rs
->buf
[r
->offset
* 2] == 'x')
7696 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
7697 /* The register isn't available, mark it as such (at
7698 the same time setting the value to zero). */
7699 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
7702 regcache_raw_supply (regcache
, r
->regnum
,
7709 fetch_registers_using_g (struct regcache
*regcache
)
7712 process_g_packet (regcache
);
7715 /* Make the remote selected traceframe match GDB's selected
7719 set_remote_traceframe (void)
7722 struct remote_state
*rs
= get_remote_state ();
7724 if (rs
->remote_traceframe_number
== get_traceframe_number ())
7727 /* Avoid recursion, remote_trace_find calls us again. */
7728 rs
->remote_traceframe_number
= get_traceframe_number ();
7730 newnum
= target_trace_find (tfind_number
,
7731 get_traceframe_number (), 0, 0, NULL
);
7733 /* Should not happen. If it does, all bets are off. */
7734 if (newnum
!= get_traceframe_number ())
7735 warning (_("could not set remote traceframe"));
7739 remote_fetch_registers (struct target_ops
*ops
,
7740 struct regcache
*regcache
, int regnum
)
7742 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7745 set_remote_traceframe ();
7746 set_general_thread (regcache_get_ptid (regcache
));
7750 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7752 gdb_assert (reg
!= NULL
);
7754 /* If this register might be in the 'g' packet, try that first -
7755 we are likely to read more than one register. If this is the
7756 first 'g' packet, we might be overly optimistic about its
7757 contents, so fall back to 'p'. */
7758 if (reg
->in_g_packet
)
7760 fetch_registers_using_g (regcache
);
7761 if (reg
->in_g_packet
)
7765 if (fetch_register_using_p (regcache
, reg
))
7768 /* This register is not available. */
7769 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7774 fetch_registers_using_g (regcache
);
7776 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7777 if (!rsa
->regs
[i
].in_g_packet
)
7778 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
7780 /* This register is not available. */
7781 regcache_raw_supply (regcache
, i
, NULL
);
7785 /* Prepare to store registers. Since we may send them all (using a
7786 'G' request), we have to read out the ones we don't want to change
7790 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
7792 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7795 /* Make sure the entire registers array is valid. */
7796 switch (packet_support (PACKET_P
))
7798 case PACKET_DISABLE
:
7799 case PACKET_SUPPORT_UNKNOWN
:
7800 /* Make sure all the necessary registers are cached. */
7801 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7802 if (rsa
->regs
[i
].in_g_packet
)
7803 regcache_raw_update (regcache
, rsa
->regs
[i
].regnum
);
7810 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7811 packet was not recognized. */
7814 store_register_using_P (const struct regcache
*regcache
,
7815 struct packet_reg
*reg
)
7817 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7818 struct remote_state
*rs
= get_remote_state ();
7819 /* Try storing a single register. */
7820 char *buf
= rs
->buf
;
7821 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7824 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
7827 if (reg
->pnum
== -1)
7830 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
7831 p
= buf
+ strlen (buf
);
7832 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
7833 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
7835 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7837 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
7842 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7843 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
7844 case PACKET_UNKNOWN
:
7847 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
7851 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7852 contents of the register cache buffer. FIXME: ignores errors. */
7855 store_registers_using_G (const struct regcache
*regcache
)
7857 struct remote_state
*rs
= get_remote_state ();
7858 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7862 /* Extract all the registers in the regcache copying them into a
7867 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
7868 memset (regs
, 0, rsa
->sizeof_g_packet
);
7869 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7871 struct packet_reg
*r
= &rsa
->regs
[i
];
7874 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
7878 /* Command describes registers byte by byte,
7879 each byte encoded as two hex characters. */
7882 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7884 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7885 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7886 error (_("Could not write registers; remote failure reply '%s'"),
7890 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7891 of the register cache buffer. FIXME: ignores errors. */
7894 remote_store_registers (struct target_ops
*ops
,
7895 struct regcache
*regcache
, int regnum
)
7897 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7900 set_remote_traceframe ();
7901 set_general_thread (regcache_get_ptid (regcache
));
7905 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7907 gdb_assert (reg
!= NULL
);
7909 /* Always prefer to store registers using the 'P' packet if
7910 possible; we often change only a small number of registers.
7911 Sometimes we change a larger number; we'd need help from a
7912 higher layer to know to use 'G'. */
7913 if (store_register_using_P (regcache
, reg
))
7916 /* For now, don't complain if we have no way to write the
7917 register. GDB loses track of unavailable registers too
7918 easily. Some day, this may be an error. We don't have
7919 any way to read the register, either... */
7920 if (!reg
->in_g_packet
)
7923 store_registers_using_G (regcache
);
7927 store_registers_using_G (regcache
);
7929 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7930 if (!rsa
->regs
[i
].in_g_packet
)
7931 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7932 /* See above for why we do not issue an error here. */
7937 /* Return the number of hex digits in num. */
7940 hexnumlen (ULONGEST num
)
7944 for (i
= 0; num
!= 0; i
++)
7947 return std::max (i
, 1);
7950 /* Set BUF to the minimum number of hex digits representing NUM. */
7953 hexnumstr (char *buf
, ULONGEST num
)
7955 int len
= hexnumlen (num
);
7957 return hexnumnstr (buf
, num
, len
);
7961 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7964 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7970 for (i
= width
- 1; i
>= 0; i
--)
7972 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7979 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7982 remote_address_masked (CORE_ADDR addr
)
7984 unsigned int address_size
= remote_address_size
;
7986 /* If "remoteaddresssize" was not set, default to target address size. */
7988 address_size
= gdbarch_addr_bit (target_gdbarch ());
7990 if (address_size
> 0
7991 && address_size
< (sizeof (ULONGEST
) * 8))
7993 /* Only create a mask when that mask can safely be constructed
7994 in a ULONGEST variable. */
7997 mask
= (mask
<< address_size
) - 1;
8003 /* Determine whether the remote target supports binary downloading.
8004 This is accomplished by sending a no-op memory write of zero length
8005 to the target at the specified address. It does not suffice to send
8006 the whole packet, since many stubs strip the eighth bit and
8007 subsequently compute a wrong checksum, which causes real havoc with
8010 NOTE: This can still lose if the serial line is not eight-bit
8011 clean. In cases like this, the user should clear "remote
8015 check_binary_download (CORE_ADDR addr
)
8017 struct remote_state
*rs
= get_remote_state ();
8019 switch (packet_support (PACKET_X
))
8021 case PACKET_DISABLE
:
8025 case PACKET_SUPPORT_UNKNOWN
:
8031 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8033 p
+= hexnumstr (p
, (ULONGEST
) 0);
8037 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8038 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8040 if (rs
->buf
[0] == '\0')
8043 fprintf_unfiltered (gdb_stdlog
,
8044 "binary downloading NOT "
8045 "supported by target\n");
8046 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8051 fprintf_unfiltered (gdb_stdlog
,
8052 "binary downloading supported by target\n");
8053 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8060 /* Helper function to resize the payload in order to try to get a good
8061 alignment. We try to write an amount of data such that the next write will
8062 start on an address aligned on REMOTE_ALIGN_WRITES. */
8065 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8067 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8070 /* Write memory data directly to the remote machine.
8071 This does not inform the data cache; the data cache uses this.
8072 HEADER is the starting part of the packet.
8073 MEMADDR is the address in the remote memory space.
8074 MYADDR is the address of the buffer in our space.
8075 LEN_UNITS is the number of addressable units to write.
8076 UNIT_SIZE is the length in bytes of an addressable unit.
8077 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8078 should send data as binary ('X'), or hex-encoded ('M').
8080 The function creates packet of the form
8081 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8083 where encoding of <DATA> is terminated by PACKET_FORMAT.
8085 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8088 Return the transferred status, error or OK (an
8089 'enum target_xfer_status' value). Save the number of addressable units
8090 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8092 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8093 exchange between gdb and the stub could look like (?? in place of the
8099 -> $M1000,3:eeeeffffeeee#??
8103 <- eeeeffffeeeedddd */
8105 static enum target_xfer_status
8106 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8107 const gdb_byte
*myaddr
, ULONGEST len_units
,
8108 int unit_size
, ULONGEST
*xfered_len_units
,
8109 char packet_format
, int use_length
)
8111 struct remote_state
*rs
= get_remote_state ();
8117 int payload_capacity_bytes
;
8118 int payload_length_bytes
;
8120 if (packet_format
!= 'X' && packet_format
!= 'M')
8121 internal_error (__FILE__
, __LINE__
,
8122 _("remote_write_bytes_aux: bad packet format"));
8125 return TARGET_XFER_EOF
;
8127 payload_capacity_bytes
= get_memory_write_packet_size ();
8129 /* The packet buffer will be large enough for the payload;
8130 get_memory_packet_size ensures this. */
8133 /* Compute the size of the actual payload by subtracting out the
8134 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8136 payload_capacity_bytes
-= strlen ("$,:#NN");
8138 /* The comma won't be used. */
8139 payload_capacity_bytes
+= 1;
8140 payload_capacity_bytes
-= strlen (header
);
8141 payload_capacity_bytes
-= hexnumlen (memaddr
);
8143 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8145 strcat (rs
->buf
, header
);
8146 p
= rs
->buf
+ strlen (header
);
8148 /* Compute a best guess of the number of bytes actually transfered. */
8149 if (packet_format
== 'X')
8151 /* Best guess at number of bytes that will fit. */
8152 todo_units
= std::min (len_units
,
8153 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8155 payload_capacity_bytes
-= hexnumlen (todo_units
);
8156 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8160 /* Number of bytes that will fit. */
8162 = std::min (len_units
,
8163 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8165 payload_capacity_bytes
-= hexnumlen (todo_units
);
8166 todo_units
= std::min (todo_units
,
8167 (payload_capacity_bytes
/ unit_size
) / 2);
8170 if (todo_units
<= 0)
8171 internal_error (__FILE__
, __LINE__
,
8172 _("minimum packet size too small to write data"));
8174 /* If we already need another packet, then try to align the end
8175 of this packet to a useful boundary. */
8176 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8177 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8179 /* Append "<memaddr>". */
8180 memaddr
= remote_address_masked (memaddr
);
8181 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8188 /* Append the length and retain its location and size. It may need to be
8189 adjusted once the packet body has been created. */
8191 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8199 /* Append the packet body. */
8200 if (packet_format
== 'X')
8202 /* Binary mode. Send target system values byte by byte, in
8203 increasing byte addresses. Only escape certain critical
8205 payload_length_bytes
=
8206 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8207 &units_written
, payload_capacity_bytes
);
8209 /* If not all TODO units fit, then we'll need another packet. Make
8210 a second try to keep the end of the packet aligned. Don't do
8211 this if the packet is tiny. */
8212 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8216 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8218 if (new_todo_units
!= units_written
)
8219 payload_length_bytes
=
8220 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8221 (gdb_byte
*) p
, &units_written
,
8222 payload_capacity_bytes
);
8225 p
+= payload_length_bytes
;
8226 if (use_length
&& units_written
< todo_units
)
8228 /* Escape chars have filled up the buffer prematurely,
8229 and we have actually sent fewer units than planned.
8230 Fix-up the length field of the packet. Use the same
8231 number of characters as before. */
8232 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8234 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8239 /* Normal mode: Send target system values byte by byte, in
8240 increasing byte addresses. Each byte is encoded as a two hex
8242 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8243 units_written
= todo_units
;
8246 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8247 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8249 if (rs
->buf
[0] == 'E')
8250 return TARGET_XFER_E_IO
;
8252 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8253 send fewer units than we'd planned. */
8254 *xfered_len_units
= (ULONGEST
) units_written
;
8255 return TARGET_XFER_OK
;
8258 /* Write memory data directly to the remote machine.
8259 This does not inform the data cache; the data cache uses this.
8260 MEMADDR is the address in the remote memory space.
8261 MYADDR is the address of the buffer in our space.
8262 LEN is the number of bytes.
8264 Return the transferred status, error or OK (an
8265 'enum target_xfer_status' value). Save the number of bytes
8266 transferred in *XFERED_LEN. Only transfer a single packet. */
8268 static enum target_xfer_status
8269 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8270 int unit_size
, ULONGEST
*xfered_len
)
8272 const char *packet_format
= NULL
;
8274 /* Check whether the target supports binary download. */
8275 check_binary_download (memaddr
);
8277 switch (packet_support (PACKET_X
))
8280 packet_format
= "X";
8282 case PACKET_DISABLE
:
8283 packet_format
= "M";
8285 case PACKET_SUPPORT_UNKNOWN
:
8286 internal_error (__FILE__
, __LINE__
,
8287 _("remote_write_bytes: bad internal state"));
8289 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8292 return remote_write_bytes_aux (packet_format
,
8293 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8294 packet_format
[0], 1);
8297 /* Read memory data directly from the remote machine.
8298 This does not use the data cache; the data cache uses this.
8299 MEMADDR is the address in the remote memory space.
8300 MYADDR is the address of the buffer in our space.
8301 LEN_UNITS is the number of addressable memory units to read..
8302 UNIT_SIZE is the length in bytes of an addressable unit.
8304 Return the transferred status, error or OK (an
8305 'enum target_xfer_status' value). Save the number of bytes
8306 transferred in *XFERED_LEN_UNITS.
8308 See the comment of remote_write_bytes_aux for an example of
8309 memory read/write exchange between gdb and the stub. */
8311 static enum target_xfer_status
8312 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8313 int unit_size
, ULONGEST
*xfered_len_units
)
8315 struct remote_state
*rs
= get_remote_state ();
8316 int buf_size_bytes
; /* Max size of packet output buffer. */
8321 buf_size_bytes
= get_memory_read_packet_size ();
8322 /* The packet buffer will be large enough for the payload;
8323 get_memory_packet_size ensures this. */
8325 /* Number of units that will fit. */
8326 todo_units
= std::min (len_units
,
8327 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8329 /* Construct "m"<memaddr>","<len>". */
8330 memaddr
= remote_address_masked (memaddr
);
8333 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8335 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8338 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8339 if (rs
->buf
[0] == 'E'
8340 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8341 && rs
->buf
[3] == '\0')
8342 return TARGET_XFER_E_IO
;
8343 /* Reply describes memory byte by byte, each byte encoded as two hex
8346 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8347 /* Return what we have. Let higher layers handle partial reads. */
8348 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8349 return TARGET_XFER_OK
;
8352 /* Using the set of read-only target sections of remote, read live
8355 For interface/parameters/return description see target.h,
8358 static enum target_xfer_status
8359 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8360 ULONGEST memaddr
, ULONGEST len
,
8361 int unit_size
, ULONGEST
*xfered_len
)
8363 struct target_section
*secp
;
8364 struct target_section_table
*table
;
8366 secp
= target_section_by_addr (ops
, memaddr
);
8368 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8369 secp
->the_bfd_section
)
8372 struct target_section
*p
;
8373 ULONGEST memend
= memaddr
+ len
;
8375 table
= target_get_section_table (ops
);
8377 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8379 if (memaddr
>= p
->addr
)
8381 if (memend
<= p
->endaddr
)
8383 /* Entire transfer is within this section. */
8384 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8387 else if (memaddr
>= p
->endaddr
)
8389 /* This section ends before the transfer starts. */
8394 /* This section overlaps the transfer. Just do half. */
8395 len
= p
->endaddr
- memaddr
;
8396 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8403 return TARGET_XFER_EOF
;
8406 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8407 first if the requested memory is unavailable in traceframe.
8408 Otherwise, fall back to remote_read_bytes_1. */
8410 static enum target_xfer_status
8411 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8412 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8413 ULONGEST
*xfered_len
)
8416 return TARGET_XFER_EOF
;
8418 if (get_traceframe_number () != -1)
8420 VEC(mem_range_s
) *available
;
8422 /* If we fail to get the set of available memory, then the
8423 target does not support querying traceframe info, and so we
8424 attempt reading from the traceframe anyway (assuming the
8425 target implements the old QTro packet then). */
8426 if (traceframe_available_memory (&available
, memaddr
, len
))
8428 struct cleanup
*old_chain
;
8430 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8432 if (VEC_empty (mem_range_s
, available
)
8433 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8435 enum target_xfer_status res
;
8437 /* Don't read into the traceframe's available
8439 if (!VEC_empty (mem_range_s
, available
))
8441 LONGEST oldlen
= len
;
8443 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8444 gdb_assert (len
<= oldlen
);
8447 do_cleanups (old_chain
);
8449 /* This goes through the topmost target again. */
8450 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8451 len
, unit_size
, xfered_len
);
8452 if (res
== TARGET_XFER_OK
)
8453 return TARGET_XFER_OK
;
8456 /* No use trying further, we know some memory starting
8457 at MEMADDR isn't available. */
8459 return TARGET_XFER_UNAVAILABLE
;
8463 /* Don't try to read more than how much is available, in
8464 case the target implements the deprecated QTro packet to
8465 cater for older GDBs (the target's knowledge of read-only
8466 sections may be outdated by now). */
8467 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8469 do_cleanups (old_chain
);
8473 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8478 /* Sends a packet with content determined by the printf format string
8479 FORMAT and the remaining arguments, then gets the reply. Returns
8480 whether the packet was a success, a failure, or unknown. */
8482 static enum packet_result
remote_send_printf (const char *format
, ...)
8483 ATTRIBUTE_PRINTF (1, 2);
8485 static enum packet_result
8486 remote_send_printf (const char *format
, ...)
8488 struct remote_state
*rs
= get_remote_state ();
8489 int max_size
= get_remote_packet_size ();
8492 va_start (ap
, format
);
8495 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8496 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8498 if (putpkt (rs
->buf
) < 0)
8499 error (_("Communication problem with target."));
8502 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8504 return packet_check_result (rs
->buf
);
8507 /* Flash writing can take quite some time. We'll set
8508 effectively infinite timeout for flash operations.
8509 In future, we'll need to decide on a better approach. */
8510 static const int remote_flash_timeout
= 1000;
8513 remote_flash_erase (struct target_ops
*ops
,
8514 ULONGEST address
, LONGEST length
)
8516 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8517 enum packet_result ret
;
8518 scoped_restore restore_timeout
8519 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8521 ret
= remote_send_printf ("vFlashErase:%s,%s",
8522 phex (address
, addr_size
),
8526 case PACKET_UNKNOWN
:
8527 error (_("Remote target does not support flash erase"));
8529 error (_("Error erasing flash with vFlashErase packet"));
8535 static enum target_xfer_status
8536 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8537 ULONGEST length
, ULONGEST
*xfered_len
,
8538 const gdb_byte
*data
)
8540 scoped_restore restore_timeout
8541 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8542 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8547 remote_flash_done (struct target_ops
*ops
)
8551 scoped_restore restore_timeout
8552 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8554 ret
= remote_send_printf ("vFlashDone");
8558 case PACKET_UNKNOWN
:
8559 error (_("Remote target does not support vFlashDone"));
8561 error (_("Error finishing flash operation"));
8568 remote_files_info (struct target_ops
*ignore
)
8570 puts_filtered ("Debugging a target over a serial line.\n");
8573 /* Stuff for dealing with the packets which are part of this protocol.
8574 See comment at top of file for details. */
8576 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8577 error to higher layers. Called when a serial error is detected.
8578 The exception message is STRING, followed by a colon and a blank,
8579 the system error message for errno at function entry and final dot
8580 for output compatibility with throw_perror_with_name. */
8583 unpush_and_perror (const char *string
)
8585 int saved_errno
= errno
;
8587 remote_unpush_target ();
8588 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8589 safe_strerror (saved_errno
));
8592 /* Read a single character from the remote end. The current quit
8593 handler is overridden to avoid quitting in the middle of packet
8594 sequence, as that would break communication with the remote server.
8595 See remote_serial_quit_handler for more detail. */
8598 readchar (int timeout
)
8601 struct remote_state
*rs
= get_remote_state ();
8604 scoped_restore restore_quit
8605 = make_scoped_restore (&quit_handler
, remote_serial_quit_handler
);
8607 rs
->got_ctrlc_during_io
= 0;
8609 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8611 if (rs
->got_ctrlc_during_io
)
8618 switch ((enum serial_rc
) ch
)
8621 remote_unpush_target ();
8622 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8625 unpush_and_perror (_("Remote communication error. "
8626 "Target disconnected."));
8628 case SERIAL_TIMEOUT
:
8634 /* Wrapper for serial_write that closes the target and throws if
8635 writing fails. The current quit handler is overridden to avoid
8636 quitting in the middle of packet sequence, as that would break
8637 communication with the remote server. See
8638 remote_serial_quit_handler for more detail. */
8641 remote_serial_write (const char *str
, int len
)
8643 struct remote_state
*rs
= get_remote_state ();
8645 scoped_restore restore_quit
8646 = make_scoped_restore (&quit_handler
, remote_serial_quit_handler
);
8648 rs
->got_ctrlc_during_io
= 0;
8650 if (serial_write (rs
->remote_desc
, str
, len
))
8652 unpush_and_perror (_("Remote communication error. "
8653 "Target disconnected."));
8656 if (rs
->got_ctrlc_during_io
)
8660 /* Send the command in *BUF to the remote machine, and read the reply
8661 into *BUF. Report an error if we get an error reply. Resize
8662 *BUF using xrealloc if necessary to hold the result, and update
8666 remote_send (char **buf
,
8670 getpkt (buf
, sizeof_buf
, 0);
8672 if ((*buf
)[0] == 'E')
8673 error (_("Remote failure reply: %s"), *buf
);
8676 /* Return a string representing an escaped version of BUF, of len N.
8677 E.g. \n is converted to \\n, \t to \\t, etc. */
8680 escape_buffer (const char *buf
, int n
)
8684 stb
.putstrn (buf
, n
, '\\');
8685 return std::move (stb
.string ());
8688 /* Display a null-terminated packet on stdout, for debugging, using C
8692 print_packet (const char *buf
)
8694 puts_filtered ("\"");
8695 fputstr_filtered (buf
, '"', gdb_stdout
);
8696 puts_filtered ("\"");
8700 putpkt (const char *buf
)
8702 return putpkt_binary (buf
, strlen (buf
));
8705 /* Send a packet to the remote machine, with error checking. The data
8706 of the packet is in BUF. The string in BUF can be at most
8707 get_remote_packet_size () - 5 to account for the $, # and checksum,
8708 and for a possible /0 if we are debugging (remote_debug) and want
8709 to print the sent packet as a string. */
8712 putpkt_binary (const char *buf
, int cnt
)
8714 struct remote_state
*rs
= get_remote_state ();
8716 unsigned char csum
= 0;
8717 char *buf2
= (char *) xmalloc (cnt
+ 6);
8718 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8724 /* Catch cases like trying to read memory or listing threads while
8725 we're waiting for a stop reply. The remote server wouldn't be
8726 ready to handle this request, so we'd hang and timeout. We don't
8727 have to worry about this in synchronous mode, because in that
8728 case it's not possible to issue a command while the target is
8729 running. This is not a problem in non-stop mode, because in that
8730 case, the stub is always ready to process serial input. */
8731 if (!target_is_non_stop_p ()
8732 && target_is_async_p ()
8733 && rs
->waiting_for_stop_reply
)
8735 error (_("Cannot execute this command while the target is running.\n"
8736 "Use the \"interrupt\" command to stop the target\n"
8737 "and then try again."));
8740 /* We're sending out a new packet. Make sure we don't look at a
8741 stale cached response. */
8742 rs
->cached_wait_status
= 0;
8744 /* Copy the packet into buffer BUF2, encapsulating it
8745 and giving it a checksum. */
8750 for (i
= 0; i
< cnt
; i
++)
8756 *p
++ = tohex ((csum
>> 4) & 0xf);
8757 *p
++ = tohex (csum
& 0xf);
8759 /* Send it over and over until we get a positive ack. */
8763 int started_error_output
= 0;
8769 int len
= (int) (p
- buf2
);
8772 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
8774 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
8776 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
8778 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
8779 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
8782 fprintf_unfiltered (gdb_stdlog
, "...");
8784 gdb_flush (gdb_stdlog
);
8786 remote_serial_write (buf2
, p
- buf2
);
8788 /* If this is a no acks version of the remote protocol, send the
8789 packet and move on. */
8793 /* Read until either a timeout occurs (-2) or '+' is read.
8794 Handle any notification that arrives in the mean time. */
8797 ch
= readchar (remote_timeout
);
8805 case SERIAL_TIMEOUT
:
8808 if (started_error_output
)
8810 putchar_unfiltered ('\n');
8811 started_error_output
= 0;
8820 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8821 do_cleanups (old_chain
);
8825 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8827 case SERIAL_TIMEOUT
:
8831 do_cleanups (old_chain
);
8834 break; /* Retransmit buffer. */
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
8845 remote_serial_write ("+", 1);
8846 continue; /* Now, go look for +. */
8853 /* If we got a notification, handle it, and go back to looking
8855 /* We've found the start of a notification. Now
8856 collect the data. */
8857 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8862 std::string str
= escape_buffer (rs
->buf
, val
);
8864 fprintf_unfiltered (gdb_stdlog
,
8865 " Notification received: %s\n",
8868 handle_notification (rs
->notif_state
, rs
->buf
);
8869 /* We're in sync now, rewait for the ack. */
8876 if (!started_error_output
)
8878 started_error_output
= 1;
8879 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8881 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8882 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8891 if (!started_error_output
)
8893 started_error_output
= 1;
8894 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8896 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8900 break; /* Here to retransmit. */
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. */
8917 do_cleanups (old_chain
);
8921 /* Come here after finding the start of a frame when we expected an
8922 ack. Do our best to discard the rest of this packet. */
8931 c
= readchar (remote_timeout
);
8934 case SERIAL_TIMEOUT
:
8935 /* Nothing we can do. */
8938 /* Discard the two bytes of checksum and stop. */
8939 c
= readchar (remote_timeout
);
8941 c
= readchar (remote_timeout
);
8944 case '*': /* Run length encoding. */
8945 /* Discard the repeat count. */
8946 c
= readchar (remote_timeout
);
8951 /* A regular character. */
8957 /* Come here after finding the start of the frame. Collect the rest
8958 into *BUF, verifying the checksum, length, and handling run-length
8959 compression. NUL terminate the buffer. If there is not enough room,
8960 expand *BUF using xrealloc.
8962 Returns -1 on error, number of characters in buffer (ignoring the
8963 trailing NULL) on success. (could be extended to return one of the
8964 SERIAL status indications). */
8967 read_frame (char **buf_p
,
8974 struct remote_state
*rs
= get_remote_state ();
8981 c
= readchar (remote_timeout
);
8984 case SERIAL_TIMEOUT
:
8986 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8990 fputs_filtered ("Saw new packet start in middle of old one\n",
8992 return -1; /* Start a new packet, count retries. */
8995 unsigned char pktcsum
;
9001 check_0
= readchar (remote_timeout
);
9003 check_1
= readchar (remote_timeout
);
9005 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
9008 fputs_filtered ("Timeout in checksum, retrying\n",
9012 else if (check_0
< 0 || check_1
< 0)
9015 fputs_filtered ("Communication error in checksum\n",
9020 /* Don't recompute the checksum; with no ack packets we
9021 don't have any way to indicate a packet retransmission
9026 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9027 if (csum
== pktcsum
)
9032 std::string str
= escape_buffer (buf
, bc
);
9034 fprintf_unfiltered (gdb_stdlog
,
9035 "Bad checksum, sentsum=0x%x, "
9036 "csum=0x%x, buf=%s\n",
9037 pktcsum
, csum
, str
.c_str ());
9039 /* Number of characters in buffer ignoring trailing
9043 case '*': /* Run length encoding. */
9048 c
= readchar (remote_timeout
);
9050 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9052 /* The character before ``*'' is repeated. */
9054 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9056 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9058 /* Make some more room in the buffer. */
9059 *sizeof_buf
+= repeat
;
9060 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9064 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9070 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9074 if (bc
>= *sizeof_buf
- 1)
9076 /* Make some more room in the buffer. */
9078 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9089 /* Read a packet from the remote machine, with error checking, and
9090 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9091 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9092 rather than timing out; this is used (in synchronous mode) to wait
9093 for a target that is is executing user code to stop. */
9094 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9095 don't have to change all the calls to getpkt to deal with the
9096 return value, because at the moment I don't know what the right
9097 thing to do it for those. */
9103 getpkt_sane (buf
, sizeof_buf
, forever
);
9107 /* Read a packet from the remote machine, with error checking, and
9108 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9109 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9110 rather than timing out; this is used (in synchronous mode) to wait
9111 for a target that is is executing user code to stop. If FOREVER ==
9112 0, this function is allowed to time out gracefully and return an
9113 indication of this to the caller. Otherwise return the number of
9114 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9115 enough reason to return to the caller. *IS_NOTIF is an output
9116 boolean that indicates whether *BUF holds a notification or not
9117 (a regular packet). */
9120 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9121 int expecting_notif
, int *is_notif
)
9123 struct remote_state
*rs
= get_remote_state ();
9129 /* We're reading a new response. Make sure we don't look at a
9130 previously cached response. */
9131 rs
->cached_wait_status
= 0;
9133 strcpy (*buf
, "timeout");
9136 timeout
= watchdog
> 0 ? watchdog
: -1;
9137 else if (expecting_notif
)
9138 timeout
= 0; /* There should already be a char in the buffer. If
9141 timeout
= remote_timeout
;
9145 /* Process any number of notifications, and then return when
9149 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9151 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9153 /* This can loop forever if the remote side sends us
9154 characters continuously, but if it pauses, we'll get
9155 SERIAL_TIMEOUT from readchar because of timeout. Then
9156 we'll count that as a retry.
9158 Note that even when forever is set, we will only wait
9159 forever prior to the start of a packet. After that, we
9160 expect characters to arrive at a brisk pace. They should
9161 show up within remote_timeout intervals. */
9163 c
= readchar (timeout
);
9164 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9166 if (c
== SERIAL_TIMEOUT
)
9168 if (expecting_notif
)
9169 return -1; /* Don't complain, it's normal to not get
9170 anything in this case. */
9172 if (forever
) /* Watchdog went off? Kill the target. */
9174 remote_unpush_target ();
9175 throw_error (TARGET_CLOSE_ERROR
,
9176 _("Watchdog timeout has expired. "
9177 "Target detached."));
9180 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9184 /* We've found the start of a packet or notification.
9185 Now collect the data. */
9186 val
= read_frame (buf
, sizeof_buf
);
9191 remote_serial_write ("-", 1);
9194 if (tries
> MAX_TRIES
)
9196 /* We have tried hard enough, and just can't receive the
9197 packet/notification. Give up. */
9198 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9200 /* Skip the ack char if we're in no-ack mode. */
9201 if (!rs
->noack_mode
)
9202 remote_serial_write ("+", 1);
9206 /* If we got an ordinary packet, return that to our caller. */
9212 = escape_buffer (*buf
,
9213 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9215 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9218 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
9220 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
9221 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
9224 fprintf_unfiltered (gdb_stdlog
, "\n");
9227 /* Skip the ack char if we're in no-ack mode. */
9228 if (!rs
->noack_mode
)
9229 remote_serial_write ("+", 1);
9230 if (is_notif
!= NULL
)
9235 /* If we got a notification, handle it, and go back to looking
9239 gdb_assert (c
== '%');
9243 std::string str
= escape_buffer (*buf
, val
);
9245 fprintf_unfiltered (gdb_stdlog
,
9246 " Notification received: %s\n",
9249 if (is_notif
!= NULL
)
9252 handle_notification (rs
->notif_state
, *buf
);
9254 /* Notifications require no acknowledgement. */
9256 if (expecting_notif
)
9263 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9265 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9269 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9272 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9276 /* Check whether EVENT is a fork event for the process specified
9277 by the pid passed in DATA, and if it is, kill the fork child. */
9280 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9281 QUEUE_ITER (stop_reply_p
) *iter
,
9285 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9286 int parent_pid
= *(int *) param
->input
;
9288 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9290 struct remote_state
*rs
= get_remote_state ();
9291 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9294 res
= remote_vkill (child_pid
, rs
);
9296 error (_("Can't kill fork child process %d"), child_pid
);
9302 /* Kill any new fork children of process PID that haven't been
9303 processed by follow_fork. */
9306 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9308 struct thread_info
*thread
;
9309 struct notif_client
*notif
= ¬if_client_stop
;
9310 struct queue_iter_param param
;
9312 /* Kill the fork child threads of any threads in process PID
9313 that are stopped at a fork event. */
9314 ALL_NON_EXITED_THREADS (thread
)
9316 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9318 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9320 struct remote_state
*rs
= get_remote_state ();
9321 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9324 res
= remote_vkill (child_pid
, rs
);
9326 error (_("Can't kill fork child process %d"), child_pid
);
9330 /* Check for any pending fork events (not reported or processed yet)
9331 in process PID and kill those fork child threads as well. */
9332 remote_notif_get_pending_events (notif
);
9334 param
.output
= NULL
;
9335 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9336 kill_child_of_pending_fork
, ¶m
);
9340 /* Target hook to kill the current inferior. */
9343 remote_kill (struct target_ops
*ops
)
9346 int pid
= ptid_get_pid (inferior_ptid
);
9347 struct remote_state
*rs
= get_remote_state ();
9349 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9351 /* If we're stopped while forking and we haven't followed yet,
9352 kill the child task. We need to do this before killing the
9353 parent task because if this is a vfork then the parent will
9355 kill_new_fork_children (pid
, rs
);
9357 res
= remote_vkill (pid
, rs
);
9360 target_mourn_inferior (inferior_ptid
);
9365 /* If we are in 'target remote' mode and we are killing the only
9366 inferior, then we will tell gdbserver to exit and unpush the
9368 if (res
== -1 && !remote_multi_process_p (rs
)
9369 && number_of_live_inferiors () == 1)
9373 /* We've killed the remote end, we get to mourn it. If we are
9374 not in extended mode, mourning the inferior also unpushes
9375 remote_ops from the target stack, which closes the remote
9377 target_mourn_inferior (inferior_ptid
);
9382 error (_("Can't kill process"));
9385 /* Send a kill request to the target using the 'vKill' packet. */
9388 remote_vkill (int pid
, struct remote_state
*rs
)
9390 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9393 /* Tell the remote target to detach. */
9394 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9396 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9398 switch (packet_ok (rs
->buf
,
9399 &remote_protocol_packets
[PACKET_vKill
]))
9405 case PACKET_UNKNOWN
:
9408 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9412 /* Send a kill request to the target using the 'k' packet. */
9415 remote_kill_k (void)
9417 /* Catch errors so the user can quit from gdb even when we
9418 aren't on speaking terms with the remote system. */
9423 CATCH (ex
, RETURN_MASK_ERROR
)
9425 if (ex
.error
== TARGET_CLOSE_ERROR
)
9427 /* If we got an (EOF) error that caused the target
9428 to go away, then we're done, that's what we wanted.
9429 "k" is susceptible to cause a premature EOF, given
9430 that the remote server isn't actually required to
9431 reply to "k", and it can happen that it doesn't
9432 even get to reply ACK to the "k". */
9436 /* Otherwise, something went wrong. We didn't actually kill
9437 the target. Just propagate the exception, and let the
9438 user or higher layers decide what to do. */
9439 throw_exception (ex
);
9445 remote_mourn (struct target_ops
*target
)
9447 struct remote_state
*rs
= get_remote_state ();
9449 /* In 'target remote' mode with one inferior, we close the connection. */
9450 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9452 unpush_target (target
);
9454 /* remote_close takes care of doing most of the clean up. */
9455 generic_mourn_inferior ();
9459 /* In case we got here due to an error, but we're going to stay
9461 rs
->waiting_for_stop_reply
= 0;
9463 /* If the current general thread belonged to the process we just
9464 detached from or has exited, the remote side current general
9465 thread becomes undefined. Considering a case like this:
9467 - We just got here due to a detach.
9468 - The process that we're detaching from happens to immediately
9469 report a global breakpoint being hit in non-stop mode, in the
9470 same thread we had selected before.
9471 - GDB attaches to this process again.
9472 - This event happens to be the next event we handle.
9474 GDB would consider that the current general thread didn't need to
9475 be set on the stub side (with Hg), since for all it knew,
9476 GENERAL_THREAD hadn't changed.
9478 Notice that although in all-stop mode, the remote server always
9479 sets the current thread to the thread reporting the stop event,
9480 that doesn't happen in non-stop mode; in non-stop, the stub *must
9481 not* change the current thread when reporting a breakpoint hit,
9482 due to the decoupling of event reporting and event handling.
9484 To keep things simple, we always invalidate our notion of the
9486 record_currthread (rs
, minus_one_ptid
);
9488 /* Call common code to mark the inferior as not running. */
9489 generic_mourn_inferior ();
9491 if (!have_inferiors ())
9493 if (!remote_multi_process_p (rs
))
9495 /* Check whether the target is running now - some remote stubs
9496 automatically restart after kill. */
9498 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9500 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9502 /* Assume that the target has been restarted. Set
9503 inferior_ptid so that bits of core GDB realizes
9504 there's something here, e.g., so that the user can
9505 say "kill" again. */
9506 inferior_ptid
= magic_null_ptid
;
9513 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9515 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9519 extended_remote_disable_randomization (int val
)
9521 struct remote_state
*rs
= get_remote_state ();
9524 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9527 reply
= remote_get_noisy_reply ();
9529 error (_("Target does not support QDisableRandomization."));
9530 if (strcmp (reply
, "OK") != 0)
9531 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9535 extended_remote_run (const std::string
&args
)
9537 struct remote_state
*rs
= get_remote_state ();
9539 const char *remote_exec_file
= get_remote_exec_file ();
9541 /* If the user has disabled vRun support, or we have detected that
9542 support is not available, do not try it. */
9543 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9546 strcpy (rs
->buf
, "vRun;");
9547 len
= strlen (rs
->buf
);
9549 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9550 error (_("Remote file name too long for run packet"));
9551 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9552 strlen (remote_exec_file
));
9558 gdb_argv
argv (args
.c_str ());
9559 for (i
= 0; argv
[i
] != NULL
; i
++)
9561 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9562 error (_("Argument list too long for run packet"));
9563 rs
->buf
[len
++] = ';';
9564 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9569 rs
->buf
[len
++] = '\0';
9572 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9574 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9577 /* We have a wait response. All is well. */
9579 case PACKET_UNKNOWN
:
9582 if (remote_exec_file
[0] == '\0')
9583 error (_("Running the default executable on the remote target failed; "
9584 "try \"set remote exec-file\"?"));
9586 error (_("Running \"%s\" on the remote target failed"),
9589 gdb_assert_not_reached (_("bad switch"));
9593 /* Helper function to send set/unset environment packets. ACTION is
9594 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9595 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9599 send_environment_packet (struct remote_state
*rs
,
9604 /* Convert the environment variable to an hex string, which
9605 is the best format to be transmitted over the wire. */
9606 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9609 xsnprintf (rs
->buf
, get_remote_packet_size (),
9610 "%s:%s", packet
, encoded_value
.c_str ());
9613 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9614 if (strcmp (rs
->buf
, "OK") != 0)
9615 warning (_("Unable to %s environment variable '%s' on remote."),
9619 /* Helper function to handle the QEnvironment* packets. */
9622 extended_remote_environment_support (struct remote_state
*rs
)
9624 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9626 putpkt ("QEnvironmentReset");
9627 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9628 if (strcmp (rs
->buf
, "OK") != 0)
9629 warning (_("Unable to reset environment on remote."));
9632 gdb_environ
*e
= ¤t_inferior ()->environment
;
9634 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9635 for (const std::string
&el
: e
->user_set_env ())
9636 send_environment_packet (rs
, "set", "QEnvironmentHexEncoded",
9639 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9640 for (const std::string
&el
: e
->user_unset_env ())
9641 send_environment_packet (rs
, "unset", "QEnvironmentUnset", el
.c_str ());
9644 /* In the extended protocol we want to be able to do things like
9645 "run" and have them basically work as expected. So we need
9646 a special create_inferior function. We support changing the
9647 executable file and the command line arguments, but not the
9651 extended_remote_create_inferior (struct target_ops
*ops
,
9652 const char *exec_file
,
9653 const std::string
&args
,
9654 char **env
, int from_tty
)
9658 struct remote_state
*rs
= get_remote_state ();
9659 const char *remote_exec_file
= get_remote_exec_file ();
9661 /* If running asynchronously, register the target file descriptor
9662 with the event loop. */
9663 if (target_can_async_p ())
9666 /* Disable address space randomization if requested (and supported). */
9667 if (extended_remote_supports_disable_randomization (ops
))
9668 extended_remote_disable_randomization (disable_randomization
);
9670 /* If startup-with-shell is on, we inform gdbserver to start the
9671 remote inferior using a shell. */
9672 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
9674 xsnprintf (rs
->buf
, get_remote_packet_size (),
9675 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
9677 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9678 if (strcmp (rs
->buf
, "OK") != 0)
9680 Remote replied unexpectedly while setting startup-with-shell: %s"),
9684 extended_remote_environment_support (rs
);
9686 /* Now restart the remote server. */
9687 run_worked
= extended_remote_run (args
) != -1;
9690 /* vRun was not supported. Fail if we need it to do what the
9692 if (remote_exec_file
[0])
9693 error (_("Remote target does not support \"set remote exec-file\""));
9695 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9697 /* Fall back to "R". */
9698 extended_remote_restart ();
9701 if (!have_inferiors ())
9703 /* Clean up from the last time we ran, before we mark the target
9704 running again. This will mark breakpoints uninserted, and
9705 get_offsets may insert breakpoints. */
9706 init_thread_list ();
9707 init_wait_for_inferior ();
9710 /* vRun's success return is a stop reply. */
9711 stop_reply
= run_worked
? rs
->buf
: NULL
;
9712 add_current_inferior_and_thread (stop_reply
);
9714 /* Get updated offsets, if the stub uses qOffsets. */
9719 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9720 the list of conditions (in agent expression bytecode format), if any, the
9721 target needs to evaluate. The output is placed into the packet buffer
9722 started from BUF and ended at BUF_END. */
9725 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9726 struct bp_target_info
*bp_tgt
, char *buf
,
9729 if (bp_tgt
->conditions
.empty ())
9732 buf
+= strlen (buf
);
9733 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9736 /* Send conditions to the target. */
9737 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
9739 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9740 buf
+= strlen (buf
);
9741 for (int i
= 0; i
< aexpr
->len
; ++i
)
9742 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9749 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9750 struct bp_target_info
*bp_tgt
, char *buf
)
9752 if (bp_tgt
->tcommands
.empty ())
9755 buf
+= strlen (buf
);
9757 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9758 buf
+= strlen (buf
);
9760 /* Concatenate all the agent expressions that are commands into the
9762 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
9764 sprintf (buf
, "X%x,", aexpr
->len
);
9765 buf
+= strlen (buf
);
9766 for (int i
= 0; i
< aexpr
->len
; ++i
)
9767 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9772 /* Insert a breakpoint. On targets that have software breakpoint
9773 support, we ask the remote target to do the work; on targets
9774 which don't, we insert a traditional memory breakpoint. */
9777 remote_insert_breakpoint (struct target_ops
*ops
,
9778 struct gdbarch
*gdbarch
,
9779 struct bp_target_info
*bp_tgt
)
9781 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9782 If it succeeds, then set the support to PACKET_ENABLE. If it
9783 fails, and the user has explicitly requested the Z support then
9784 report an error, otherwise, mark it disabled and go on. */
9786 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9788 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9789 struct remote_state
*rs
;
9793 /* Make sure the remote is pointing at the right process, if
9795 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9796 set_general_process ();
9798 rs
= get_remote_state ();
9800 endbuf
= rs
->buf
+ get_remote_packet_size ();
9805 addr
= (ULONGEST
) remote_address_masked (addr
);
9806 p
+= hexnumstr (p
, addr
);
9807 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9809 if (remote_supports_cond_breakpoints (ops
))
9810 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9812 if (remote_can_run_breakpoint_commands (ops
))
9813 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9816 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9818 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9824 case PACKET_UNKNOWN
:
9829 /* If this breakpoint has target-side commands but this stub doesn't
9830 support Z0 packets, throw error. */
9831 if (!bp_tgt
->tcommands
.empty ())
9832 throw_error (NOT_SUPPORTED_ERROR
, _("\
9833 Target doesn't support breakpoints that have target side commands."));
9835 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9839 remote_remove_breakpoint (struct target_ops
*ops
,
9840 struct gdbarch
*gdbarch
,
9841 struct bp_target_info
*bp_tgt
,
9842 enum remove_bp_reason reason
)
9844 CORE_ADDR addr
= bp_tgt
->placed_address
;
9845 struct remote_state
*rs
= get_remote_state ();
9847 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9850 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9852 /* Make sure the remote is pointing at the right process, if
9854 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9855 set_general_process ();
9861 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9862 p
+= hexnumstr (p
, addr
);
9863 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9866 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9868 return (rs
->buf
[0] == 'E');
9871 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9874 static enum Z_packet_type
9875 watchpoint_to_Z_packet (int type
)
9880 return Z_PACKET_WRITE_WP
;
9883 return Z_PACKET_READ_WP
;
9886 return Z_PACKET_ACCESS_WP
;
9889 internal_error (__FILE__
, __LINE__
,
9890 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9895 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9896 enum target_hw_bp_type type
, struct expression
*cond
)
9898 struct remote_state
*rs
= get_remote_state ();
9899 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9901 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9903 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9906 /* Make sure the remote is pointing at the right process, if
9908 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9909 set_general_process ();
9911 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9912 p
= strchr (rs
->buf
, '\0');
9913 addr
= remote_address_masked (addr
);
9914 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9915 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9918 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9920 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9924 case PACKET_UNKNOWN
:
9929 internal_error (__FILE__
, __LINE__
,
9930 _("remote_insert_watchpoint: reached end of function"));
9934 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9935 CORE_ADDR start
, int length
)
9937 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9939 return diff
< length
;
9944 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9945 enum target_hw_bp_type type
, struct expression
*cond
)
9947 struct remote_state
*rs
= get_remote_state ();
9948 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9950 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9952 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9955 /* Make sure the remote is pointing at the right process, if
9957 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9958 set_general_process ();
9960 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9961 p
= strchr (rs
->buf
, '\0');
9962 addr
= remote_address_masked (addr
);
9963 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9964 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9966 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9968 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9971 case PACKET_UNKNOWN
:
9976 internal_error (__FILE__
, __LINE__
,
9977 _("remote_remove_watchpoint: reached end of function"));
9981 int remote_hw_watchpoint_limit
= -1;
9982 int remote_hw_watchpoint_length_limit
= -1;
9983 int remote_hw_breakpoint_limit
= -1;
9986 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9987 CORE_ADDR addr
, int len
)
9989 if (remote_hw_watchpoint_length_limit
== 0)
9991 else if (remote_hw_watchpoint_length_limit
< 0)
9993 else if (len
<= remote_hw_watchpoint_length_limit
)
10000 remote_check_watch_resources (struct target_ops
*self
,
10001 enum bptype type
, int cnt
, int ot
)
10003 if (type
== bp_hardware_breakpoint
)
10005 if (remote_hw_breakpoint_limit
== 0)
10007 else if (remote_hw_breakpoint_limit
< 0)
10009 else if (cnt
<= remote_hw_breakpoint_limit
)
10014 if (remote_hw_watchpoint_limit
== 0)
10016 else if (remote_hw_watchpoint_limit
< 0)
10020 else if (cnt
<= remote_hw_watchpoint_limit
)
10026 /* The to_stopped_by_sw_breakpoint method of target remote. */
10029 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
10031 struct thread_info
*thread
= inferior_thread ();
10033 return (thread
->priv
!= NULL
10034 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
10037 /* The to_supports_stopped_by_sw_breakpoint method of target
10041 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
10043 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10046 /* The to_stopped_by_hw_breakpoint method of target remote. */
10049 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10051 struct thread_info
*thread
= inferior_thread ();
10053 return (thread
->priv
!= NULL
10054 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
10057 /* The to_supports_stopped_by_hw_breakpoint method of target
10061 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10063 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10067 remote_stopped_by_watchpoint (struct target_ops
*ops
)
10069 struct thread_info
*thread
= inferior_thread ();
10071 return (thread
->priv
!= NULL
10072 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
10076 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
10078 struct thread_info
*thread
= inferior_thread ();
10080 if (thread
->priv
!= NULL
10081 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
10083 *addr_p
= thread
->priv
->watch_data_address
;
10092 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10093 struct bp_target_info
*bp_tgt
)
10095 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10096 struct remote_state
*rs
;
10100 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10103 /* Make sure the remote is pointing at the right process, if
10105 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10106 set_general_process ();
10108 rs
= get_remote_state ();
10110 endbuf
= rs
->buf
+ get_remote_packet_size ();
10116 addr
= remote_address_masked (addr
);
10117 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10118 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10120 if (remote_supports_cond_breakpoints (self
))
10121 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10123 if (remote_can_run_breakpoint_commands (self
))
10124 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10127 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10129 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10132 if (rs
->buf
[1] == '.')
10134 message
= strchr (rs
->buf
+ 2, '.');
10136 error (_("Remote failure reply: %s"), message
+ 1);
10139 case PACKET_UNKNOWN
:
10144 internal_error (__FILE__
, __LINE__
,
10145 _("remote_insert_hw_breakpoint: reached end of function"));
10150 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10151 struct bp_target_info
*bp_tgt
)
10154 struct remote_state
*rs
= get_remote_state ();
10156 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10158 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10161 /* Make sure the remote is pointing at the right process, if
10163 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10164 set_general_process ();
10170 addr
= remote_address_masked (bp_tgt
->placed_address
);
10171 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10172 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10175 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10177 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10180 case PACKET_UNKNOWN
:
10185 internal_error (__FILE__
, __LINE__
,
10186 _("remote_remove_hw_breakpoint: reached end of function"));
10189 /* Verify memory using the "qCRC:" request. */
10192 remote_verify_memory (struct target_ops
*ops
,
10193 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10195 struct remote_state
*rs
= get_remote_state ();
10196 unsigned long host_crc
, target_crc
;
10199 /* It doesn't make sense to use qCRC if the remote target is
10200 connected but not running. */
10201 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10203 enum packet_result result
;
10205 /* Make sure the remote is pointing at the right process. */
10206 set_general_process ();
10208 /* FIXME: assumes lma can fit into long. */
10209 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10210 (long) lma
, (long) size
);
10213 /* Be clever; compute the host_crc before waiting for target
10215 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10217 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10219 result
= packet_ok (rs
->buf
,
10220 &remote_protocol_packets
[PACKET_qCRC
]);
10221 if (result
== PACKET_ERROR
)
10223 else if (result
== PACKET_OK
)
10225 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10226 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10228 return (host_crc
== target_crc
);
10232 return simple_verify_memory (ops
, data
, lma
, size
);
10235 /* compare-sections command
10237 With no arguments, compares each loadable section in the exec bfd
10238 with the same memory range on the target, and reports mismatches.
10239 Useful for verifying the image on the target against the exec file. */
10242 compare_sections_command (const char *args
, int from_tty
)
10245 struct cleanup
*old_chain
;
10246 gdb_byte
*sectdata
;
10247 const char *sectname
;
10248 bfd_size_type size
;
10251 int mismatched
= 0;
10256 error (_("command cannot be used without an exec file"));
10258 /* Make sure the remote is pointing at the right process. */
10259 set_general_process ();
10261 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10267 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10269 if (!(s
->flags
& SEC_LOAD
))
10270 continue; /* Skip non-loadable section. */
10272 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10273 continue; /* Skip writeable sections */
10275 size
= bfd_get_section_size (s
);
10277 continue; /* Skip zero-length section. */
10279 sectname
= bfd_get_section_name (exec_bfd
, s
);
10280 if (args
&& strcmp (args
, sectname
) != 0)
10281 continue; /* Not the section selected by user. */
10283 matched
= 1; /* Do this section. */
10286 sectdata
= (gdb_byte
*) xmalloc (size
);
10287 old_chain
= make_cleanup (xfree
, sectdata
);
10288 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10290 res
= target_verify_memory (sectdata
, lma
, size
);
10293 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10294 paddress (target_gdbarch (), lma
),
10295 paddress (target_gdbarch (), lma
+ size
));
10297 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10298 paddress (target_gdbarch (), lma
),
10299 paddress (target_gdbarch (), lma
+ size
));
10301 printf_filtered ("matched.\n");
10304 printf_filtered ("MIS-MATCHED!\n");
10308 do_cleanups (old_chain
);
10310 if (mismatched
> 0)
10311 warning (_("One or more sections of the target image does not match\n\
10312 the loaded file\n"));
10313 if (args
&& !matched
)
10314 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10317 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10318 into remote target. The number of bytes written to the remote
10319 target is returned, or -1 for error. */
10321 static enum target_xfer_status
10322 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10323 const char *annex
, const gdb_byte
*writebuf
,
10324 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10325 struct packet_config
*packet
)
10329 struct remote_state
*rs
= get_remote_state ();
10330 int max_size
= get_memory_write_packet_size ();
10332 if (packet
->support
== PACKET_DISABLE
)
10333 return TARGET_XFER_E_IO
;
10335 /* Insert header. */
10336 i
= snprintf (rs
->buf
, max_size
,
10337 "qXfer:%s:write:%s:%s:",
10338 object_name
, annex
? annex
: "",
10339 phex_nz (offset
, sizeof offset
));
10340 max_size
-= (i
+ 1);
10342 /* Escape as much data as fits into rs->buf. */
10343 buf_len
= remote_escape_output
10344 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10346 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10347 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10348 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10349 return TARGET_XFER_E_IO
;
10351 unpack_varlen_hex (rs
->buf
, &n
);
10354 return TARGET_XFER_OK
;
10357 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10358 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10359 number of bytes read is returned, or 0 for EOF, or -1 for error.
10360 The number of bytes read may be less than LEN without indicating an
10361 EOF. PACKET is checked and updated to indicate whether the remote
10362 target supports this object. */
10364 static enum target_xfer_status
10365 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10367 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10368 ULONGEST
*xfered_len
,
10369 struct packet_config
*packet
)
10371 struct remote_state
*rs
= get_remote_state ();
10372 LONGEST i
, n
, packet_len
;
10374 if (packet
->support
== PACKET_DISABLE
)
10375 return TARGET_XFER_E_IO
;
10377 /* Check whether we've cached an end-of-object packet that matches
10379 if (rs
->finished_object
)
10381 if (strcmp (object_name
, rs
->finished_object
) == 0
10382 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10383 && offset
== rs
->finished_offset
)
10384 return TARGET_XFER_EOF
;
10387 /* Otherwise, we're now reading something different. Discard
10389 xfree (rs
->finished_object
);
10390 xfree (rs
->finished_annex
);
10391 rs
->finished_object
= NULL
;
10392 rs
->finished_annex
= NULL
;
10395 /* Request only enough to fit in a single packet. The actual data
10396 may not, since we don't know how much of it will need to be escaped;
10397 the target is free to respond with slightly less data. We subtract
10398 five to account for the response type and the protocol frame. */
10399 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10400 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10401 object_name
, annex
? annex
: "",
10402 phex_nz (offset
, sizeof offset
),
10403 phex_nz (n
, sizeof n
));
10404 i
= putpkt (rs
->buf
);
10406 return TARGET_XFER_E_IO
;
10409 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10410 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10411 return TARGET_XFER_E_IO
;
10413 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10414 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10416 /* 'm' means there is (or at least might be) more data after this
10417 batch. That does not make sense unless there's at least one byte
10418 of data in this reply. */
10419 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10420 error (_("Remote qXfer reply contained no data."));
10422 /* Got some data. */
10423 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10424 packet_len
- 1, readbuf
, n
);
10426 /* 'l' is an EOF marker, possibly including a final block of data,
10427 or possibly empty. If we have the final block of a non-empty
10428 object, record this fact to bypass a subsequent partial read. */
10429 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10431 rs
->finished_object
= xstrdup (object_name
);
10432 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10433 rs
->finished_offset
= offset
+ i
;
10437 return TARGET_XFER_EOF
;
10441 return TARGET_XFER_OK
;
10445 static enum target_xfer_status
10446 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10447 const char *annex
, gdb_byte
*readbuf
,
10448 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10449 ULONGEST
*xfered_len
)
10451 struct remote_state
*rs
;
10455 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10457 set_remote_traceframe ();
10458 set_general_thread (inferior_ptid
);
10460 rs
= get_remote_state ();
10462 /* Handle memory using the standard memory routines. */
10463 if (object
== TARGET_OBJECT_MEMORY
)
10465 /* If the remote target is connected but not running, we should
10466 pass this request down to a lower stratum (e.g. the executable
10468 if (!target_has_execution
)
10469 return TARGET_XFER_EOF
;
10471 if (writebuf
!= NULL
)
10472 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10475 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10479 /* Handle SPU memory using qxfer packets. */
10480 if (object
== TARGET_OBJECT_SPU
)
10483 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10484 xfered_len
, &remote_protocol_packets
10485 [PACKET_qXfer_spu_read
]);
10487 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10488 xfered_len
, &remote_protocol_packets
10489 [PACKET_qXfer_spu_write
]);
10492 /* Handle extra signal info using qxfer packets. */
10493 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10496 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10497 xfered_len
, &remote_protocol_packets
10498 [PACKET_qXfer_siginfo_read
]);
10500 return remote_write_qxfer (ops
, "siginfo", annex
,
10501 writebuf
, offset
, len
, xfered_len
,
10502 &remote_protocol_packets
10503 [PACKET_qXfer_siginfo_write
]);
10506 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10509 return remote_read_qxfer (ops
, "statictrace", annex
,
10510 readbuf
, offset
, len
, xfered_len
,
10511 &remote_protocol_packets
10512 [PACKET_qXfer_statictrace_read
]);
10514 return TARGET_XFER_E_IO
;
10517 /* Only handle flash writes. */
10518 if (writebuf
!= NULL
)
10522 case TARGET_OBJECT_FLASH
:
10523 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10527 return TARGET_XFER_E_IO
;
10531 /* Map pre-existing objects onto letters. DO NOT do this for new
10532 objects!!! Instead specify new query packets. */
10535 case TARGET_OBJECT_AVR
:
10539 case TARGET_OBJECT_AUXV
:
10540 gdb_assert (annex
== NULL
);
10541 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10543 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10545 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10546 return remote_read_qxfer
10547 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10548 &remote_protocol_packets
[PACKET_qXfer_features
]);
10550 case TARGET_OBJECT_LIBRARIES
:
10551 return remote_read_qxfer
10552 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10553 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10555 case TARGET_OBJECT_LIBRARIES_SVR4
:
10556 return remote_read_qxfer
10557 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10558 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10560 case TARGET_OBJECT_MEMORY_MAP
:
10561 gdb_assert (annex
== NULL
);
10562 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10564 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10566 case TARGET_OBJECT_OSDATA
:
10567 /* Should only get here if we're connected. */
10568 gdb_assert (rs
->remote_desc
);
10569 return remote_read_qxfer
10570 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10571 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10573 case TARGET_OBJECT_THREADS
:
10574 gdb_assert (annex
== NULL
);
10575 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10577 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10579 case TARGET_OBJECT_TRACEFRAME_INFO
:
10580 gdb_assert (annex
== NULL
);
10581 return remote_read_qxfer
10582 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10583 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10585 case TARGET_OBJECT_FDPIC
:
10586 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10588 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10590 case TARGET_OBJECT_OPENVMS_UIB
:
10591 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10593 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10595 case TARGET_OBJECT_BTRACE
:
10596 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10598 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10600 case TARGET_OBJECT_BTRACE_CONF
:
10601 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10603 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10605 case TARGET_OBJECT_EXEC_FILE
:
10606 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10608 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10611 return TARGET_XFER_E_IO
;
10614 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10615 large enough let the caller deal with it. */
10616 if (len
< get_remote_packet_size ())
10617 return TARGET_XFER_E_IO
;
10618 len
= get_remote_packet_size ();
10620 /* Except for querying the minimum buffer size, target must be open. */
10621 if (!rs
->remote_desc
)
10622 error (_("remote query is only available after target open"));
10624 gdb_assert (annex
!= NULL
);
10625 gdb_assert (readbuf
!= NULL
);
10629 *p2
++ = query_type
;
10631 /* We used one buffer char for the remote protocol q command and
10632 another for the query type. As the remote protocol encapsulation
10633 uses 4 chars plus one extra in case we are debugging
10634 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10637 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10639 /* Bad caller may have sent forbidden characters. */
10640 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10645 gdb_assert (annex
[i
] == '\0');
10647 i
= putpkt (rs
->buf
);
10649 return TARGET_XFER_E_IO
;
10651 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10652 strcpy ((char *) readbuf
, rs
->buf
);
10654 *xfered_len
= strlen ((char *) readbuf
);
10655 return TARGET_XFER_OK
;
10658 /* Implementation of to_get_memory_xfer_limit. */
10661 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10663 return get_memory_write_packet_size ();
10667 remote_search_memory (struct target_ops
* ops
,
10668 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10669 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10670 CORE_ADDR
*found_addrp
)
10672 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10673 struct remote_state
*rs
= get_remote_state ();
10674 int max_size
= get_memory_write_packet_size ();
10675 struct packet_config
*packet
=
10676 &remote_protocol_packets
[PACKET_qSearch_memory
];
10677 /* Number of packet bytes used to encode the pattern;
10678 this could be more than PATTERN_LEN due to escape characters. */
10679 int escaped_pattern_len
;
10680 /* Amount of pattern that was encodable in the packet. */
10681 int used_pattern_len
;
10684 ULONGEST found_addr
;
10686 /* Don't go to the target if we don't have to.
10687 This is done before checking packet->support to avoid the possibility that
10688 a success for this edge case means the facility works in general. */
10689 if (pattern_len
> search_space_len
)
10691 if (pattern_len
== 0)
10693 *found_addrp
= start_addr
;
10697 /* If we already know the packet isn't supported, fall back to the simple
10698 way of searching memory. */
10700 if (packet_config_support (packet
) == PACKET_DISABLE
)
10702 /* Target doesn't provided special support, fall back and use the
10703 standard support (copy memory and do the search here). */
10704 return simple_search_memory (ops
, start_addr
, search_space_len
,
10705 pattern
, pattern_len
, found_addrp
);
10708 /* Make sure the remote is pointing at the right process. */
10709 set_general_process ();
10711 /* Insert header. */
10712 i
= snprintf (rs
->buf
, max_size
,
10713 "qSearch:memory:%s;%s;",
10714 phex_nz (start_addr
, addr_size
),
10715 phex_nz (search_space_len
, sizeof (search_space_len
)));
10716 max_size
-= (i
+ 1);
10718 /* Escape as much data as fits into rs->buf. */
10719 escaped_pattern_len
=
10720 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10721 &used_pattern_len
, max_size
);
10723 /* Bail if the pattern is too large. */
10724 if (used_pattern_len
!= pattern_len
)
10725 error (_("Pattern is too large to transmit to remote target."));
10727 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10728 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10729 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10731 /* The request may not have worked because the command is not
10732 supported. If so, fall back to the simple way. */
10733 if (packet
->support
== PACKET_DISABLE
)
10735 return simple_search_memory (ops
, start_addr
, search_space_len
,
10736 pattern
, pattern_len
, found_addrp
);
10741 if (rs
->buf
[0] == '0')
10743 else if (rs
->buf
[0] == '1')
10746 if (rs
->buf
[1] != ',')
10747 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10748 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10749 *found_addrp
= found_addr
;
10752 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10758 remote_rcmd (struct target_ops
*self
, const char *command
,
10759 struct ui_file
*outbuf
)
10761 struct remote_state
*rs
= get_remote_state ();
10764 if (!rs
->remote_desc
)
10765 error (_("remote rcmd is only available after target open"));
10767 /* Send a NULL command across as an empty command. */
10768 if (command
== NULL
)
10771 /* The query prefix. */
10772 strcpy (rs
->buf
, "qRcmd,");
10773 p
= strchr (rs
->buf
, '\0');
10775 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10776 > get_remote_packet_size ())
10777 error (_("\"monitor\" command ``%s'' is too long."), command
);
10779 /* Encode the actual command. */
10780 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10782 if (putpkt (rs
->buf
) < 0)
10783 error (_("Communication problem with target."));
10785 /* get/display the response */
10790 /* XXX - see also remote_get_noisy_reply(). */
10791 QUIT
; /* Allow user to bail out with ^C. */
10793 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10795 /* Timeout. Continue to (try to) read responses.
10796 This is better than stopping with an error, assuming the stub
10797 is still executing the (long) monitor command.
10798 If needed, the user can interrupt gdb using C-c, obtaining
10799 an effect similar to stop on timeout. */
10803 if (buf
[0] == '\0')
10804 error (_("Target does not support this command."));
10805 if (buf
[0] == 'O' && buf
[1] != 'K')
10807 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10810 if (strcmp (buf
, "OK") == 0)
10812 if (strlen (buf
) == 3 && buf
[0] == 'E'
10813 && isdigit (buf
[1]) && isdigit (buf
[2]))
10815 error (_("Protocol error with Rcmd"));
10817 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10819 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10821 fputc_unfiltered (c
, outbuf
);
10827 static VEC(mem_region_s
) *
10828 remote_memory_map (struct target_ops
*ops
)
10830 VEC(mem_region_s
) *result
= NULL
;
10831 char *text
= target_read_stralloc (¤t_target
,
10832 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10836 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10838 result
= parse_memory_map (text
);
10839 do_cleanups (back_to
);
10846 packet_command (const char *args
, int from_tty
)
10848 struct remote_state
*rs
= get_remote_state ();
10850 if (!rs
->remote_desc
)
10851 error (_("command can only be used with remote target"));
10854 error (_("remote-packet command requires packet text as argument"));
10856 puts_filtered ("sending: ");
10857 print_packet (args
);
10858 puts_filtered ("\n");
10861 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10862 puts_filtered ("received: ");
10863 print_packet (rs
->buf
);
10864 puts_filtered ("\n");
10868 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10870 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10872 static void threadset_test_cmd (char *cmd
, int tty
);
10874 static void threadalive_test (char *cmd
, int tty
);
10876 static void threadlist_test_cmd (char *cmd
, int tty
);
10878 int get_and_display_threadinfo (threadref
*ref
);
10880 static void threadinfo_test_cmd (char *cmd
, int tty
);
10882 static int thread_display_step (threadref
*ref
, void *context
);
10884 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10886 static void init_remote_threadtests (void);
10888 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10891 threadset_test_cmd (char *cmd
, int tty
)
10893 int sample_thread
= SAMPLE_THREAD
;
10895 printf_filtered (_("Remote threadset test\n"));
10896 set_general_thread (sample_thread
);
10901 threadalive_test (char *cmd
, int tty
)
10903 int sample_thread
= SAMPLE_THREAD
;
10904 int pid
= ptid_get_pid (inferior_ptid
);
10905 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10907 if (remote_thread_alive (ptid
))
10908 printf_filtered ("PASS: Thread alive test\n");
10910 printf_filtered ("FAIL: Thread alive test\n");
10913 void output_threadid (char *title
, threadref
*ref
);
10916 output_threadid (char *title
, threadref
*ref
)
10920 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10922 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10926 threadlist_test_cmd (char *cmd
, int tty
)
10929 threadref nextthread
;
10930 int done
, result_count
;
10931 threadref threadlist
[3];
10933 printf_filtered ("Remote Threadlist test\n");
10934 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10935 &result_count
, &threadlist
[0]))
10936 printf_filtered ("FAIL: threadlist test\n");
10939 threadref
*scan
= threadlist
;
10940 threadref
*limit
= scan
+ result_count
;
10942 while (scan
< limit
)
10943 output_threadid (" thread ", scan
++);
10948 display_thread_info (struct gdb_ext_thread_info
*info
)
10950 output_threadid ("Threadid: ", &info
->threadid
);
10951 printf_filtered ("Name: %s\n ", info
->shortname
);
10952 printf_filtered ("State: %s\n", info
->display
);
10953 printf_filtered ("other: %s\n\n", info
->more_display
);
10957 get_and_display_threadinfo (threadref
*ref
)
10961 struct gdb_ext_thread_info threadinfo
;
10963 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10964 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10965 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10966 display_thread_info (&threadinfo
);
10971 threadinfo_test_cmd (char *cmd
, int tty
)
10973 int athread
= SAMPLE_THREAD
;
10977 int_to_threadref (&thread
, athread
);
10978 printf_filtered ("Remote Threadinfo test\n");
10979 if (!get_and_display_threadinfo (&thread
))
10980 printf_filtered ("FAIL cannot get thread info\n");
10984 thread_display_step (threadref
*ref
, void *context
)
10986 /* output_threadid(" threadstep ",ref); *//* simple test */
10987 return get_and_display_threadinfo (ref
);
10991 threadlist_update_test_cmd (char *cmd
, int tty
)
10993 printf_filtered ("Remote Threadlist update test\n");
10994 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10998 init_remote_threadtests (void)
11000 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
11001 _("Fetch and print the remote list of "
11002 "thread identifiers, one pkt only"));
11003 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
11004 _("Fetch and display info about one thread"));
11005 add_com ("tset", class_obscure
, threadset_test_cmd
,
11006 _("Test setting to a different thread"));
11007 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
11008 _("Iterate through updating all remote thread info"));
11009 add_com ("talive", class_obscure
, threadalive_test
,
11010 _(" Remote thread alive test "));
11015 /* Convert a thread ID to a string. Returns the string in a static
11018 static const char *
11019 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
11021 static char buf
[64];
11022 struct remote_state
*rs
= get_remote_state ();
11024 if (ptid_equal (ptid
, null_ptid
))
11025 return normal_pid_to_str (ptid
);
11026 else if (ptid_is_pid (ptid
))
11028 /* Printing an inferior target id. */
11030 /* When multi-process extensions are off, there's no way in the
11031 remote protocol to know the remote process id, if there's any
11032 at all. There's one exception --- when we're connected with
11033 target extended-remote, and we manually attached to a process
11034 with "attach PID". We don't record anywhere a flag that
11035 allows us to distinguish that case from the case of
11036 connecting with extended-remote and the stub already being
11037 attached to a process, and reporting yes to qAttached, hence
11038 no smart special casing here. */
11039 if (!remote_multi_process_p (rs
))
11041 xsnprintf (buf
, sizeof buf
, "Remote target");
11045 return normal_pid_to_str (ptid
);
11049 if (ptid_equal (magic_null_ptid
, ptid
))
11050 xsnprintf (buf
, sizeof buf
, "Thread <main>");
11051 else if (remote_multi_process_p (rs
))
11052 if (ptid_get_lwp (ptid
) == 0)
11053 return normal_pid_to_str (ptid
);
11055 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
11056 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
11058 xsnprintf (buf
, sizeof buf
, "Thread %ld",
11059 ptid_get_lwp (ptid
));
11064 /* Get the address of the thread local variable in OBJFILE which is
11065 stored at OFFSET within the thread local storage for thread PTID. */
11068 remote_get_thread_local_address (struct target_ops
*ops
,
11069 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
11071 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11073 struct remote_state
*rs
= get_remote_state ();
11075 char *endp
= rs
->buf
+ get_remote_packet_size ();
11076 enum packet_result result
;
11078 strcpy (p
, "qGetTLSAddr:");
11080 p
= write_ptid (p
, endp
, ptid
);
11082 p
+= hexnumstr (p
, offset
);
11084 p
+= hexnumstr (p
, lm
);
11088 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11089 result
= packet_ok (rs
->buf
,
11090 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11091 if (result
== PACKET_OK
)
11095 unpack_varlen_hex (rs
->buf
, &result
);
11098 else if (result
== PACKET_UNKNOWN
)
11099 throw_error (TLS_GENERIC_ERROR
,
11100 _("Remote target doesn't support qGetTLSAddr packet"));
11102 throw_error (TLS_GENERIC_ERROR
,
11103 _("Remote target failed to process qGetTLSAddr request"));
11106 throw_error (TLS_GENERIC_ERROR
,
11107 _("TLS not supported or disabled on this target"));
11112 /* Provide thread local base, i.e. Thread Information Block address.
11113 Returns 1 if ptid is found and thread_local_base is non zero. */
11116 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11118 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11120 struct remote_state
*rs
= get_remote_state ();
11122 char *endp
= rs
->buf
+ get_remote_packet_size ();
11123 enum packet_result result
;
11125 strcpy (p
, "qGetTIBAddr:");
11127 p
= write_ptid (p
, endp
, ptid
);
11131 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11132 result
= packet_ok (rs
->buf
,
11133 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11134 if (result
== PACKET_OK
)
11138 unpack_varlen_hex (rs
->buf
, &result
);
11140 *addr
= (CORE_ADDR
) result
;
11143 else if (result
== PACKET_UNKNOWN
)
11144 error (_("Remote target doesn't support qGetTIBAddr packet"));
11146 error (_("Remote target failed to process qGetTIBAddr request"));
11149 error (_("qGetTIBAddr not supported or disabled on this target"));
11154 /* Support for inferring a target description based on the current
11155 architecture and the size of a 'g' packet. While the 'g' packet
11156 can have any size (since optional registers can be left off the
11157 end), some sizes are easily recognizable given knowledge of the
11158 approximate architecture. */
11160 struct remote_g_packet_guess
11163 const struct target_desc
*tdesc
;
11165 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11166 DEF_VEC_O(remote_g_packet_guess_s
);
11168 struct remote_g_packet_data
11170 VEC(remote_g_packet_guess_s
) *guesses
;
11173 static struct gdbarch_data
*remote_g_packet_data_handle
;
11176 remote_g_packet_data_init (struct obstack
*obstack
)
11178 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11182 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11183 const struct target_desc
*tdesc
)
11185 struct remote_g_packet_data
*data
11186 = ((struct remote_g_packet_data
*)
11187 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11188 struct remote_g_packet_guess new_guess
, *guess
;
11191 gdb_assert (tdesc
!= NULL
);
11194 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11196 if (guess
->bytes
== bytes
)
11197 internal_error (__FILE__
, __LINE__
,
11198 _("Duplicate g packet description added for size %d"),
11201 new_guess
.bytes
= bytes
;
11202 new_guess
.tdesc
= tdesc
;
11203 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11206 /* Return 1 if remote_read_description would do anything on this target
11207 and architecture, 0 otherwise. */
11210 remote_read_description_p (struct target_ops
*target
)
11212 struct remote_g_packet_data
*data
11213 = ((struct remote_g_packet_data
*)
11214 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11216 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11222 static const struct target_desc
*
11223 remote_read_description (struct target_ops
*target
)
11225 struct remote_g_packet_data
*data
11226 = ((struct remote_g_packet_data
*)
11227 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11229 /* Do not try this during initial connection, when we do not know
11230 whether there is a running but stopped thread. */
11231 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11232 return target
->beneath
->to_read_description (target
->beneath
);
11234 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11236 struct remote_g_packet_guess
*guess
;
11238 int bytes
= send_g_packet ();
11241 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11243 if (guess
->bytes
== bytes
)
11244 return guess
->tdesc
;
11246 /* We discard the g packet. A minor optimization would be to
11247 hold on to it, and fill the register cache once we have selected
11248 an architecture, but it's too tricky to do safely. */
11251 return target
->beneath
->to_read_description (target
->beneath
);
11254 /* Remote file transfer support. This is host-initiated I/O, not
11255 target-initiated; for target-initiated, see remote-fileio.c. */
11257 /* If *LEFT is at least the length of STRING, copy STRING to
11258 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11259 decrease *LEFT. Otherwise raise an error. */
11262 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11264 int len
= strlen (string
);
11267 error (_("Packet too long for target."));
11269 memcpy (*buffer
, string
, len
);
11273 /* NUL-terminate the buffer as a convenience, if there is
11279 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11280 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11281 decrease *LEFT. Otherwise raise an error. */
11284 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11287 if (2 * len
> *left
)
11288 error (_("Packet too long for target."));
11290 bin2hex (bytes
, *buffer
, len
);
11291 *buffer
+= 2 * len
;
11294 /* NUL-terminate the buffer as a convenience, if there is
11300 /* If *LEFT is large enough, convert VALUE to hex and add it to
11301 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11302 decrease *LEFT. Otherwise raise an error. */
11305 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11307 int len
= hexnumlen (value
);
11310 error (_("Packet too long for target."));
11312 hexnumstr (*buffer
, value
);
11316 /* NUL-terminate the buffer as a convenience, if there is
11322 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11323 value, *REMOTE_ERRNO to the remote error number or zero if none
11324 was included, and *ATTACHMENT to point to the start of the annex
11325 if any. The length of the packet isn't needed here; there may
11326 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11328 Return 0 if the packet could be parsed, -1 if it could not. If
11329 -1 is returned, the other variables may not be initialized. */
11332 remote_hostio_parse_result (char *buffer
, int *retcode
,
11333 int *remote_errno
, char **attachment
)
11338 *attachment
= NULL
;
11340 if (buffer
[0] != 'F')
11344 *retcode
= strtol (&buffer
[1], &p
, 16);
11345 if (errno
!= 0 || p
== &buffer
[1])
11348 /* Check for ",errno". */
11352 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11353 if (errno
!= 0 || p
+ 1 == p2
)
11358 /* Check for ";attachment". If there is no attachment, the
11359 packet should end here. */
11362 *attachment
= p
+ 1;
11365 else if (*p
== '\0')
11371 /* Send a prepared I/O packet to the target and read its response.
11372 The prepared packet is in the global RS->BUF before this function
11373 is called, and the answer is there when we return.
11375 COMMAND_BYTES is the length of the request to send, which may include
11376 binary data. WHICH_PACKET is the packet configuration to check
11377 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11378 is set to the error number and -1 is returned. Otherwise the value
11379 returned by the function is returned.
11381 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11382 attachment is expected; an error will be reported if there's a
11383 mismatch. If one is found, *ATTACHMENT will be set to point into
11384 the packet buffer and *ATTACHMENT_LEN will be set to the
11385 attachment's length. */
11388 remote_hostio_send_command (int command_bytes
, int which_packet
,
11389 int *remote_errno
, char **attachment
,
11390 int *attachment_len
)
11392 struct remote_state
*rs
= get_remote_state ();
11393 int ret
, bytes_read
;
11394 char *attachment_tmp
;
11396 if (!rs
->remote_desc
11397 || packet_support (which_packet
) == PACKET_DISABLE
)
11399 *remote_errno
= FILEIO_ENOSYS
;
11403 putpkt_binary (rs
->buf
, command_bytes
);
11404 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11406 /* If it timed out, something is wrong. Don't try to parse the
11408 if (bytes_read
< 0)
11410 *remote_errno
= FILEIO_EINVAL
;
11414 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11417 *remote_errno
= FILEIO_EINVAL
;
11419 case PACKET_UNKNOWN
:
11420 *remote_errno
= FILEIO_ENOSYS
;
11426 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11429 *remote_errno
= FILEIO_EINVAL
;
11433 /* Make sure we saw an attachment if and only if we expected one. */
11434 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11435 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11437 *remote_errno
= FILEIO_EINVAL
;
11441 /* If an attachment was found, it must point into the packet buffer;
11442 work out how many bytes there were. */
11443 if (attachment_tmp
!= NULL
)
11445 *attachment
= attachment_tmp
;
11446 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11452 /* Invalidate the readahead cache. */
11455 readahead_cache_invalidate (void)
11457 struct remote_state
*rs
= get_remote_state ();
11459 rs
->readahead_cache
.fd
= -1;
11462 /* Invalidate the readahead cache if it is holding data for FD. */
11465 readahead_cache_invalidate_fd (int fd
)
11467 struct remote_state
*rs
= get_remote_state ();
11469 if (rs
->readahead_cache
.fd
== fd
)
11470 rs
->readahead_cache
.fd
= -1;
11473 /* Set the filesystem remote_hostio functions that take FILENAME
11474 arguments will use. Return 0 on success, or -1 if an error
11475 occurs (and set *REMOTE_ERRNO). */
11478 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11480 struct remote_state
*rs
= get_remote_state ();
11481 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11483 int left
= get_remote_packet_size () - 1;
11487 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11490 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11493 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11495 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11496 remote_buffer_add_string (&p
, &left
, arg
);
11498 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11499 remote_errno
, NULL
, NULL
);
11501 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11505 rs
->fs_pid
= required_pid
;
11510 /* Implementation of to_fileio_open. */
11513 remote_hostio_open (struct target_ops
*self
,
11514 struct inferior
*inf
, const char *filename
,
11515 int flags
, int mode
, int warn_if_slow
,
11518 struct remote_state
*rs
= get_remote_state ();
11520 int left
= get_remote_packet_size () - 1;
11524 static int warning_issued
= 0;
11526 printf_unfiltered (_("Reading %s from remote target...\n"),
11529 if (!warning_issued
)
11531 warning (_("File transfers from remote targets can be slow."
11532 " Use \"set sysroot\" to access files locally"
11534 warning_issued
= 1;
11538 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11541 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11543 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11544 strlen (filename
));
11545 remote_buffer_add_string (&p
, &left
, ",");
11547 remote_buffer_add_int (&p
, &left
, flags
);
11548 remote_buffer_add_string (&p
, &left
, ",");
11550 remote_buffer_add_int (&p
, &left
, mode
);
11552 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11553 remote_errno
, NULL
, NULL
);
11556 /* Implementation of to_fileio_pwrite. */
11559 remote_hostio_pwrite (struct target_ops
*self
,
11560 int fd
, const gdb_byte
*write_buf
, int len
,
11561 ULONGEST offset
, int *remote_errno
)
11563 struct remote_state
*rs
= get_remote_state ();
11565 int left
= get_remote_packet_size ();
11568 readahead_cache_invalidate_fd (fd
);
11570 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11572 remote_buffer_add_int (&p
, &left
, fd
);
11573 remote_buffer_add_string (&p
, &left
, ",");
11575 remote_buffer_add_int (&p
, &left
, offset
);
11576 remote_buffer_add_string (&p
, &left
, ",");
11578 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11579 get_remote_packet_size () - (p
- rs
->buf
));
11581 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11582 remote_errno
, NULL
, NULL
);
11585 /* Helper for the implementation of to_fileio_pread. Read the file
11586 from the remote side with vFile:pread. */
11589 remote_hostio_pread_vFile (struct target_ops
*self
,
11590 int fd
, gdb_byte
*read_buf
, int len
,
11591 ULONGEST offset
, int *remote_errno
)
11593 struct remote_state
*rs
= get_remote_state ();
11596 int left
= get_remote_packet_size ();
11597 int ret
, attachment_len
;
11600 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11602 remote_buffer_add_int (&p
, &left
, fd
);
11603 remote_buffer_add_string (&p
, &left
, ",");
11605 remote_buffer_add_int (&p
, &left
, len
);
11606 remote_buffer_add_string (&p
, &left
, ",");
11608 remote_buffer_add_int (&p
, &left
, offset
);
11610 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11611 remote_errno
, &attachment
,
11617 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11619 if (read_len
!= ret
)
11620 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11625 /* Serve pread from the readahead cache. Returns number of bytes
11626 read, or 0 if the request can't be served from the cache. */
11629 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11630 int fd
, gdb_byte
*read_buf
, size_t len
,
11633 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11635 if (cache
->fd
== fd
11636 && cache
->offset
<= offset
11637 && offset
< cache
->offset
+ cache
->bufsize
)
11639 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11641 if (offset
+ len
> max
)
11642 len
= max
- offset
;
11644 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11651 /* Implementation of to_fileio_pread. */
11654 remote_hostio_pread (struct target_ops
*self
,
11655 int fd
, gdb_byte
*read_buf
, int len
,
11656 ULONGEST offset
, int *remote_errno
)
11659 struct remote_state
*rs
= get_remote_state ();
11660 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11662 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11665 cache
->hit_count
++;
11668 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11669 pulongest (cache
->hit_count
));
11673 cache
->miss_count
++;
11675 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11676 pulongest (cache
->miss_count
));
11679 cache
->offset
= offset
;
11680 cache
->bufsize
= get_remote_packet_size ();
11681 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11683 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11684 cache
->offset
, remote_errno
);
11687 readahead_cache_invalidate_fd (fd
);
11691 cache
->bufsize
= ret
;
11692 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11695 /* Implementation of to_fileio_close. */
11698 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11700 struct remote_state
*rs
= get_remote_state ();
11702 int left
= get_remote_packet_size () - 1;
11704 readahead_cache_invalidate_fd (fd
);
11706 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11708 remote_buffer_add_int (&p
, &left
, fd
);
11710 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11711 remote_errno
, NULL
, NULL
);
11714 /* Implementation of to_fileio_unlink. */
11717 remote_hostio_unlink (struct target_ops
*self
,
11718 struct inferior
*inf
, const char *filename
,
11721 struct remote_state
*rs
= get_remote_state ();
11723 int left
= get_remote_packet_size () - 1;
11725 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11728 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11730 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11731 strlen (filename
));
11733 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11734 remote_errno
, NULL
, NULL
);
11737 /* Implementation of to_fileio_readlink. */
11740 remote_hostio_readlink (struct target_ops
*self
,
11741 struct inferior
*inf
, const char *filename
,
11744 struct remote_state
*rs
= get_remote_state ();
11747 int left
= get_remote_packet_size ();
11748 int len
, attachment_len
;
11752 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11755 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11757 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11758 strlen (filename
));
11760 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11761 remote_errno
, &attachment
,
11767 ret
= (char *) xmalloc (len
+ 1);
11769 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11770 (gdb_byte
*) ret
, len
);
11771 if (read_len
!= len
)
11772 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11778 /* Implementation of to_fileio_fstat. */
11781 remote_hostio_fstat (struct target_ops
*self
,
11782 int fd
, struct stat
*st
,
11785 struct remote_state
*rs
= get_remote_state ();
11787 int left
= get_remote_packet_size ();
11788 int attachment_len
, ret
;
11790 struct fio_stat fst
;
11793 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11795 remote_buffer_add_int (&p
, &left
, fd
);
11797 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11798 remote_errno
, &attachment
,
11802 if (*remote_errno
!= FILEIO_ENOSYS
)
11805 /* Strictly we should return -1, ENOSYS here, but when
11806 "set sysroot remote:" was implemented in August 2008
11807 BFD's need for a stat function was sidestepped with
11808 this hack. This was not remedied until March 2015
11809 so we retain the previous behavior to avoid breaking
11812 Note that the memset is a March 2015 addition; older
11813 GDBs set st_size *and nothing else* so the structure
11814 would have garbage in all other fields. This might
11815 break something but retaining the previous behavior
11816 here would be just too wrong. */
11818 memset (st
, 0, sizeof (struct stat
));
11819 st
->st_size
= INT_MAX
;
11823 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11824 (gdb_byte
*) &fst
, sizeof (fst
));
11826 if (read_len
!= ret
)
11827 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11829 if (read_len
!= sizeof (fst
))
11830 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11831 read_len
, (int) sizeof (fst
));
11833 remote_fileio_to_host_stat (&fst
, st
);
11838 /* Implementation of to_filesystem_is_local. */
11841 remote_filesystem_is_local (struct target_ops
*self
)
11843 /* Valgrind GDB presents itself as a remote target but works
11844 on the local filesystem: it does not implement remote get
11845 and users are not expected to set a sysroot. To handle
11846 this case we treat the remote filesystem as local if the
11847 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11848 does not support vFile:open. */
11849 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11851 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11853 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11855 int fd
, remote_errno
;
11857 /* Try opening a file to probe support. The supplied
11858 filename is irrelevant, we only care about whether
11859 the stub recognizes the packet or not. */
11860 fd
= remote_hostio_open (self
, NULL
, "just probing",
11861 FILEIO_O_RDONLY
, 0700, 0,
11865 remote_hostio_close (self
, fd
, &remote_errno
);
11867 ps
= packet_support (PACKET_vFile_open
);
11870 if (ps
== PACKET_DISABLE
)
11872 static int warning_issued
= 0;
11874 if (!warning_issued
)
11876 warning (_("remote target does not support file"
11877 " transfer, attempting to access files"
11878 " from local filesystem."));
11879 warning_issued
= 1;
11890 remote_fileio_errno_to_host (int errnum
)
11896 case FILEIO_ENOENT
:
11904 case FILEIO_EACCES
:
11906 case FILEIO_EFAULT
:
11910 case FILEIO_EEXIST
:
11912 case FILEIO_ENODEV
:
11914 case FILEIO_ENOTDIR
:
11916 case FILEIO_EISDIR
:
11918 case FILEIO_EINVAL
:
11920 case FILEIO_ENFILE
:
11922 case FILEIO_EMFILE
:
11926 case FILEIO_ENOSPC
:
11928 case FILEIO_ESPIPE
:
11932 case FILEIO_ENOSYS
:
11934 case FILEIO_ENAMETOOLONG
:
11935 return ENAMETOOLONG
;
11941 remote_hostio_error (int errnum
)
11943 int host_error
= remote_fileio_errno_to_host (errnum
);
11945 if (host_error
== -1)
11946 error (_("Unknown remote I/O error %d"), errnum
);
11948 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11952 remote_hostio_close_cleanup (void *opaque
)
11954 int fd
= *(int *) opaque
;
11957 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11961 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11963 struct cleanup
*back_to
, *close_cleanup
;
11964 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11966 int bytes_in_buffer
;
11969 struct remote_state
*rs
= get_remote_state ();
11971 if (!rs
->remote_desc
)
11972 error (_("command can only be used with remote target"));
11974 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
11976 perror_with_name (local_file
);
11978 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11979 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11981 0700, 0, &remote_errno
);
11983 remote_hostio_error (remote_errno
);
11985 /* Send up to this many bytes at once. They won't all fit in the
11986 remote packet limit, so we'll transfer slightly fewer. */
11987 io_size
= get_remote_packet_size ();
11988 buffer
= (gdb_byte
*) xmalloc (io_size
);
11989 back_to
= make_cleanup (xfree
, buffer
);
11991 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11993 bytes_in_buffer
= 0;
11996 while (bytes_in_buffer
|| !saw_eof
)
12000 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
12001 io_size
- bytes_in_buffer
,
12005 if (ferror (file
.get ()))
12006 error (_("Error reading %s."), local_file
);
12009 /* EOF. Unless there is something still in the
12010 buffer from the last iteration, we are done. */
12012 if (bytes_in_buffer
== 0)
12020 bytes
+= bytes_in_buffer
;
12021 bytes_in_buffer
= 0;
12023 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
12025 offset
, &remote_errno
);
12028 remote_hostio_error (remote_errno
);
12029 else if (retcode
== 0)
12030 error (_("Remote write of %d bytes returned 0!"), bytes
);
12031 else if (retcode
< bytes
)
12033 /* Short write. Save the rest of the read data for the next
12035 bytes_in_buffer
= bytes
- retcode
;
12036 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
12042 discard_cleanups (close_cleanup
);
12043 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12044 remote_hostio_error (remote_errno
);
12047 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12048 do_cleanups (back_to
);
12052 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12054 struct cleanup
*back_to
, *close_cleanup
;
12055 int fd
, remote_errno
, bytes
, io_size
;
12058 struct remote_state
*rs
= get_remote_state ();
12060 if (!rs
->remote_desc
)
12061 error (_("command can only be used with remote target"));
12063 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
12064 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12067 remote_hostio_error (remote_errno
);
12069 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12071 perror_with_name (local_file
);
12073 /* Send up to this many bytes at once. They won't all fit in the
12074 remote packet limit, so we'll transfer slightly fewer. */
12075 io_size
= get_remote_packet_size ();
12076 buffer
= (gdb_byte
*) xmalloc (io_size
);
12077 back_to
= make_cleanup (xfree
, buffer
);
12079 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
12084 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
12085 fd
, buffer
, io_size
, offset
, &remote_errno
);
12087 /* Success, but no bytes, means end-of-file. */
12090 remote_hostio_error (remote_errno
);
12094 bytes
= fwrite (buffer
, 1, bytes
, file
.get ());
12096 perror_with_name (local_file
);
12099 discard_cleanups (close_cleanup
);
12100 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12101 remote_hostio_error (remote_errno
);
12104 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12105 do_cleanups (back_to
);
12109 remote_file_delete (const char *remote_file
, int from_tty
)
12111 int retcode
, remote_errno
;
12112 struct remote_state
*rs
= get_remote_state ();
12114 if (!rs
->remote_desc
)
12115 error (_("command can only be used with remote target"));
12117 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12118 NULL
, remote_file
, &remote_errno
);
12120 remote_hostio_error (remote_errno
);
12123 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12127 remote_put_command (const char *args
, int from_tty
)
12130 error_no_arg (_("file to put"));
12132 gdb_argv
argv (args
);
12133 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12134 error (_("Invalid parameters to remote put"));
12136 remote_file_put (argv
[0], argv
[1], from_tty
);
12140 remote_get_command (const char *args
, int from_tty
)
12143 error_no_arg (_("file to get"));
12145 gdb_argv
argv (args
);
12146 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12147 error (_("Invalid parameters to remote get"));
12149 remote_file_get (argv
[0], argv
[1], from_tty
);
12153 remote_delete_command (const char *args
, int from_tty
)
12156 error_no_arg (_("file to delete"));
12158 gdb_argv
argv (args
);
12159 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12160 error (_("Invalid parameters to remote delete"));
12162 remote_file_delete (argv
[0], from_tty
);
12166 remote_command (char *args
, int from_tty
)
12168 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12172 remote_can_execute_reverse (struct target_ops
*self
)
12174 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12175 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12182 remote_supports_non_stop (struct target_ops
*self
)
12188 remote_supports_disable_randomization (struct target_ops
*self
)
12190 /* Only supported in extended mode. */
12195 remote_supports_multi_process (struct target_ops
*self
)
12197 struct remote_state
*rs
= get_remote_state ();
12199 return remote_multi_process_p (rs
);
12203 remote_supports_cond_tracepoints (void)
12205 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12209 remote_supports_cond_breakpoints (struct target_ops
*self
)
12211 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12215 remote_supports_fast_tracepoints (void)
12217 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12221 remote_supports_static_tracepoints (void)
12223 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12227 remote_supports_install_in_trace (void)
12229 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12233 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12235 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12240 remote_supports_string_tracing (struct target_ops
*self
)
12242 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12246 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12248 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12252 remote_trace_init (struct target_ops
*self
)
12254 struct remote_state
*rs
= get_remote_state ();
12257 remote_get_noisy_reply ();
12258 if (strcmp (rs
->buf
, "OK") != 0)
12259 error (_("Target does not support this command."));
12262 static void free_actions_list (char **actions_list
);
12263 static void free_actions_list_cleanup_wrapper (void *);
12265 free_actions_list_cleanup_wrapper (void *al
)
12267 free_actions_list ((char **) al
);
12271 free_actions_list (char **actions_list
)
12275 if (actions_list
== 0)
12278 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12279 xfree (actions_list
[ndx
]);
12281 xfree (actions_list
);
12284 /* Recursive routine to walk through command list including loops, and
12285 download packets for each command. */
12288 remote_download_command_source (int num
, ULONGEST addr
,
12289 struct command_line
*cmds
)
12291 struct remote_state
*rs
= get_remote_state ();
12292 struct command_line
*cmd
;
12294 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12296 QUIT
; /* Allow user to bail out with ^C. */
12297 strcpy (rs
->buf
, "QTDPsrc:");
12298 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12299 rs
->buf
+ strlen (rs
->buf
),
12300 rs
->buf_size
- strlen (rs
->buf
));
12302 remote_get_noisy_reply ();
12303 if (strcmp (rs
->buf
, "OK"))
12304 warning (_("Target does not support source download."));
12306 if (cmd
->control_type
== while_control
12307 || cmd
->control_type
== while_stepping_control
)
12309 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12311 QUIT
; /* Allow user to bail out with ^C. */
12312 strcpy (rs
->buf
, "QTDPsrc:");
12313 encode_source_string (num
, addr
, "cmd", "end",
12314 rs
->buf
+ strlen (rs
->buf
),
12315 rs
->buf_size
- strlen (rs
->buf
));
12317 remote_get_noisy_reply ();
12318 if (strcmp (rs
->buf
, "OK"))
12319 warning (_("Target does not support source download."));
12325 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12327 #define BUF_SIZE 2048
12331 char buf
[BUF_SIZE
];
12332 char **tdp_actions
;
12333 char **stepping_actions
;
12335 struct cleanup
*old_chain
= NULL
;
12337 struct breakpoint
*b
= loc
->owner
;
12338 struct tracepoint
*t
= (struct tracepoint
*) b
;
12339 struct remote_state
*rs
= get_remote_state ();
12341 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12342 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12344 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12347 tpaddr
= loc
->address
;
12348 sprintf_vma (addrbuf
, tpaddr
);
12349 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12350 addrbuf
, /* address */
12351 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12352 t
->step_count
, t
->pass_count
);
12353 /* Fast tracepoints are mostly handled by the target, but we can
12354 tell the target how big of an instruction block should be moved
12356 if (b
->type
== bp_fast_tracepoint
)
12358 /* Only test for support at download time; we may not know
12359 target capabilities at definition time. */
12360 if (remote_supports_fast_tracepoints ())
12362 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12364 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12365 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12367 /* If it passed validation at definition but fails now,
12368 something is very wrong. */
12369 internal_error (__FILE__
, __LINE__
,
12370 _("Fast tracepoint not "
12371 "valid during download"));
12374 /* Fast tracepoints are functionally identical to regular
12375 tracepoints, so don't take lack of support as a reason to
12376 give up on the trace run. */
12377 warning (_("Target does not support fast tracepoints, "
12378 "downloading %d as regular tracepoint"), b
->number
);
12380 else if (b
->type
== bp_static_tracepoint
)
12382 /* Only test for support at download time; we may not know
12383 target capabilities at definition time. */
12384 if (remote_supports_static_tracepoints ())
12386 struct static_tracepoint_marker marker
;
12388 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12389 strcat (buf
, ":S");
12391 error (_("Static tracepoint not valid during download"));
12394 /* Fast tracepoints are functionally identical to regular
12395 tracepoints, so don't take lack of support as a reason
12396 to give up on the trace run. */
12397 error (_("Target does not support static tracepoints"));
12399 /* If the tracepoint has a conditional, make it into an agent
12400 expression and append to the definition. */
12403 /* Only test support at download time, we may not know target
12404 capabilities at definition time. */
12405 if (remote_supports_cond_tracepoints ())
12407 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12408 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12410 pkt
= buf
+ strlen (buf
);
12411 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12412 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12416 warning (_("Target does not support conditional tracepoints, "
12417 "ignoring tp %d cond"), b
->number
);
12420 if (b
->commands
|| *default_collect
)
12423 remote_get_noisy_reply ();
12424 if (strcmp (rs
->buf
, "OK"))
12425 error (_("Target does not support tracepoints."));
12427 /* do_single_steps (t); */
12430 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12432 QUIT
; /* Allow user to bail out with ^C. */
12433 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12434 b
->number
, addrbuf
, /* address */
12436 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12439 remote_get_noisy_reply ();
12440 if (strcmp (rs
->buf
, "OK"))
12441 error (_("Error on target while setting tracepoints."));
12444 if (stepping_actions
)
12446 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12448 QUIT
; /* Allow user to bail out with ^C. */
12449 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12450 b
->number
, addrbuf
, /* address */
12451 ((ndx
== 0) ? "S" : ""),
12452 stepping_actions
[ndx
],
12453 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12455 remote_get_noisy_reply ();
12456 if (strcmp (rs
->buf
, "OK"))
12457 error (_("Error on target while setting tracepoints."));
12461 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12463 if (b
->location
!= NULL
)
12465 strcpy (buf
, "QTDPsrc:");
12466 encode_source_string (b
->number
, loc
->address
, "at",
12467 event_location_to_string (b
->location
.get ()),
12468 buf
+ strlen (buf
), 2048 - strlen (buf
));
12470 remote_get_noisy_reply ();
12471 if (strcmp (rs
->buf
, "OK"))
12472 warning (_("Target does not support source download."));
12474 if (b
->cond_string
)
12476 strcpy (buf
, "QTDPsrc:");
12477 encode_source_string (b
->number
, loc
->address
,
12478 "cond", b
->cond_string
, buf
+ strlen (buf
),
12479 2048 - strlen (buf
));
12481 remote_get_noisy_reply ();
12482 if (strcmp (rs
->buf
, "OK"))
12483 warning (_("Target does not support source download."));
12485 remote_download_command_source (b
->number
, loc
->address
,
12486 breakpoint_commands (b
));
12489 do_cleanups (old_chain
);
12493 remote_can_download_tracepoint (struct target_ops
*self
)
12495 struct remote_state
*rs
= get_remote_state ();
12496 struct trace_status
*ts
;
12499 /* Don't try to install tracepoints until we've relocated our
12500 symbols, and fetched and merged the target's tracepoint list with
12502 if (rs
->starting_up
)
12505 ts
= current_trace_status ();
12506 status
= remote_get_trace_status (self
, ts
);
12508 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12511 /* If we are in a tracing experiment, but remote stub doesn't support
12512 installing tracepoint in trace, we have to return. */
12513 if (!remote_supports_install_in_trace ())
12521 remote_download_trace_state_variable (struct target_ops
*self
,
12522 struct trace_state_variable
*tsv
)
12524 struct remote_state
*rs
= get_remote_state ();
12527 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12528 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12530 p
= rs
->buf
+ strlen (rs
->buf
);
12531 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12532 error (_("Trace state variable name too long for tsv definition packet"));
12533 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12536 remote_get_noisy_reply ();
12537 if (*rs
->buf
== '\0')
12538 error (_("Target does not support this command."));
12539 if (strcmp (rs
->buf
, "OK") != 0)
12540 error (_("Error on target while downloading trace state variable."));
12544 remote_enable_tracepoint (struct target_ops
*self
,
12545 struct bp_location
*location
)
12547 struct remote_state
*rs
= get_remote_state ();
12550 sprintf_vma (addr_buf
, location
->address
);
12551 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12552 location
->owner
->number
, addr_buf
);
12554 remote_get_noisy_reply ();
12555 if (*rs
->buf
== '\0')
12556 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12557 if (strcmp (rs
->buf
, "OK") != 0)
12558 error (_("Error on target while enabling tracepoint."));
12562 remote_disable_tracepoint (struct target_ops
*self
,
12563 struct bp_location
*location
)
12565 struct remote_state
*rs
= get_remote_state ();
12568 sprintf_vma (addr_buf
, location
->address
);
12569 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12570 location
->owner
->number
, addr_buf
);
12572 remote_get_noisy_reply ();
12573 if (*rs
->buf
== '\0')
12574 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12575 if (strcmp (rs
->buf
, "OK") != 0)
12576 error (_("Error on target while disabling tracepoint."));
12580 remote_trace_set_readonly_regions (struct target_ops
*self
)
12584 bfd_size_type size
;
12590 return; /* No information to give. */
12592 struct remote_state
*rs
= get_remote_state ();
12594 strcpy (rs
->buf
, "QTro");
12595 offset
= strlen (rs
->buf
);
12596 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12598 char tmp1
[40], tmp2
[40];
12601 if ((s
->flags
& SEC_LOAD
) == 0 ||
12602 /* (s->flags & SEC_CODE) == 0 || */
12603 (s
->flags
& SEC_READONLY
) == 0)
12607 vma
= bfd_get_section_vma (abfd
, s
);
12608 size
= bfd_get_section_size (s
);
12609 sprintf_vma (tmp1
, vma
);
12610 sprintf_vma (tmp2
, vma
+ size
);
12611 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12612 if (offset
+ sec_length
+ 1 > rs
->buf_size
)
12614 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12616 Too many sections for read-only sections definition packet."));
12619 xsnprintf (rs
->buf
+ offset
, rs
->buf_size
- offset
, ":%s,%s",
12621 offset
+= sec_length
;
12626 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
12631 remote_trace_start (struct target_ops
*self
)
12633 struct remote_state
*rs
= get_remote_state ();
12635 putpkt ("QTStart");
12636 remote_get_noisy_reply ();
12637 if (*rs
->buf
== '\0')
12638 error (_("Target does not support this command."));
12639 if (strcmp (rs
->buf
, "OK") != 0)
12640 error (_("Bogus reply from target: %s"), rs
->buf
);
12644 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12646 /* Initialize it just to avoid a GCC false warning. */
12648 /* FIXME we need to get register block size some other way. */
12649 extern int trace_regblock_size
;
12650 enum packet_result result
;
12651 struct remote_state
*rs
= get_remote_state ();
12653 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12656 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12658 putpkt ("qTStatus");
12662 p
= remote_get_noisy_reply ();
12664 CATCH (ex
, RETURN_MASK_ERROR
)
12666 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12668 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12671 throw_exception (ex
);
12675 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12677 /* If the remote target doesn't do tracing, flag it. */
12678 if (result
== PACKET_UNKNOWN
)
12681 /* We're working with a live target. */
12682 ts
->filename
= NULL
;
12685 error (_("Bogus trace status reply from target: %s"), rs
->buf
);
12687 /* Function 'parse_trace_status' sets default value of each field of
12688 'ts' at first, so we don't have to do it here. */
12689 parse_trace_status (p
, ts
);
12691 return ts
->running
;
12695 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12696 struct uploaded_tp
*utp
)
12698 struct remote_state
*rs
= get_remote_state ();
12700 struct bp_location
*loc
;
12701 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12702 size_t size
= get_remote_packet_size ();
12707 tp
->traceframe_usage
= 0;
12708 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
12710 /* If the tracepoint was never downloaded, don't go asking for
12712 if (tp
->number_on_target
== 0)
12714 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12715 phex_nz (loc
->address
, 0));
12717 reply
= remote_get_noisy_reply ();
12718 if (reply
&& *reply
)
12721 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12727 utp
->hit_count
= 0;
12728 utp
->traceframe_usage
= 0;
12729 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12730 phex_nz (utp
->addr
, 0));
12732 reply
= remote_get_noisy_reply ();
12733 if (reply
&& *reply
)
12736 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12742 remote_trace_stop (struct target_ops
*self
)
12744 struct remote_state
*rs
= get_remote_state ();
12747 remote_get_noisy_reply ();
12748 if (*rs
->buf
== '\0')
12749 error (_("Target does not support this command."));
12750 if (strcmp (rs
->buf
, "OK") != 0)
12751 error (_("Bogus reply from target: %s"), rs
->buf
);
12755 remote_trace_find (struct target_ops
*self
,
12756 enum trace_find_type type
, int num
,
12757 CORE_ADDR addr1
, CORE_ADDR addr2
,
12760 struct remote_state
*rs
= get_remote_state ();
12761 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12763 int target_frameno
= -1, target_tracept
= -1;
12765 /* Lookups other than by absolute frame number depend on the current
12766 trace selected, so make sure it is correct on the remote end
12768 if (type
!= tfind_number
)
12769 set_remote_traceframe ();
12772 strcpy (p
, "QTFrame:");
12773 p
= strchr (p
, '\0');
12777 xsnprintf (p
, endbuf
- p
, "%x", num
);
12780 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12783 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12786 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12787 phex_nz (addr2
, 0));
12789 case tfind_outside
:
12790 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12791 phex_nz (addr2
, 0));
12794 error (_("Unknown trace find type %d"), type
);
12798 reply
= remote_get_noisy_reply ();
12799 if (*reply
== '\0')
12800 error (_("Target does not support this command."));
12802 while (reply
&& *reply
)
12807 target_frameno
= (int) strtol (p
, &reply
, 16);
12809 error (_("Unable to parse trace frame number"));
12810 /* Don't update our remote traceframe number cache on failure
12811 to select a remote traceframe. */
12812 if (target_frameno
== -1)
12817 target_tracept
= (int) strtol (p
, &reply
, 16);
12819 error (_("Unable to parse tracepoint number"));
12821 case 'O': /* "OK"? */
12822 if (reply
[1] == 'K' && reply
[2] == '\0')
12825 error (_("Bogus reply from target: %s"), reply
);
12828 error (_("Bogus reply from target: %s"), reply
);
12831 *tpp
= target_tracept
;
12833 rs
->remote_traceframe_number
= target_frameno
;
12834 return target_frameno
;
12838 remote_get_trace_state_variable_value (struct target_ops
*self
,
12839 int tsvnum
, LONGEST
*val
)
12841 struct remote_state
*rs
= get_remote_state ();
12845 set_remote_traceframe ();
12847 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12849 reply
= remote_get_noisy_reply ();
12850 if (reply
&& *reply
)
12854 unpack_varlen_hex (reply
+ 1, &uval
);
12855 *val
= (LONGEST
) uval
;
12863 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12865 struct remote_state
*rs
= get_remote_state ();
12869 strcpy (p
, "QTSave:");
12871 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12872 error (_("Remote file name too long for trace save packet"));
12873 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12876 reply
= remote_get_noisy_reply ();
12877 if (*reply
== '\0')
12878 error (_("Target does not support this command."));
12879 if (strcmp (reply
, "OK") != 0)
12880 error (_("Bogus reply from target: %s"), reply
);
12884 /* This is basically a memory transfer, but needs to be its own packet
12885 because we don't know how the target actually organizes its trace
12886 memory, plus we want to be able to ask for as much as possible, but
12887 not be unhappy if we don't get as much as we ask for. */
12890 remote_get_raw_trace_data (struct target_ops
*self
,
12891 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12893 struct remote_state
*rs
= get_remote_state ();
12899 strcpy (p
, "qTBuffer:");
12901 p
+= hexnumstr (p
, offset
);
12903 p
+= hexnumstr (p
, len
);
12907 reply
= remote_get_noisy_reply ();
12908 if (reply
&& *reply
)
12910 /* 'l' by itself means we're at the end of the buffer and
12911 there is nothing more to get. */
12915 /* Convert the reply into binary. Limit the number of bytes to
12916 convert according to our passed-in buffer size, rather than
12917 what was returned in the packet; if the target is
12918 unexpectedly generous and gives us a bigger reply than we
12919 asked for, we don't want to crash. */
12920 rslt
= hex2bin (reply
, buf
, len
);
12924 /* Something went wrong, flag as an error. */
12929 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12931 struct remote_state
*rs
= get_remote_state ();
12933 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12937 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12939 reply
= remote_get_noisy_reply ();
12940 if (*reply
== '\0')
12941 error (_("Target does not support this command."));
12942 if (strcmp (reply
, "OK") != 0)
12943 error (_("Bogus reply from target: %s"), reply
);
12946 warning (_("Target does not support disconnected tracing."));
12950 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12952 struct thread_info
*info
= find_thread_ptid (ptid
);
12954 if (info
&& info
->priv
)
12955 return info
->priv
->core
;
12960 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12962 struct remote_state
*rs
= get_remote_state ();
12965 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12967 reply
= remote_get_noisy_reply ();
12968 if (*reply
== '\0')
12969 error (_("Target does not support this command."));
12970 if (strcmp (reply
, "OK") != 0)
12971 error (_("Bogus reply from target: %s"), reply
);
12974 static struct traceframe_info
*
12975 remote_traceframe_info (struct target_ops
*self
)
12979 text
= target_read_stralloc (¤t_target
,
12980 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12983 struct traceframe_info
*info
;
12984 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12986 info
= parse_traceframe_info (text
);
12987 do_cleanups (back_to
);
12994 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12995 instruction on which a fast tracepoint may be placed. Returns -1
12996 if the packet is not supported, and 0 if the minimum instruction
12997 length is unknown. */
13000 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
13002 struct remote_state
*rs
= get_remote_state ();
13005 /* If we're not debugging a process yet, the IPA can't be
13007 if (!target_has_execution
)
13010 /* Make sure the remote is pointing at the right process. */
13011 set_general_process ();
13013 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
13015 reply
= remote_get_noisy_reply ();
13016 if (*reply
== '\0')
13020 ULONGEST min_insn_len
;
13022 unpack_varlen_hex (reply
, &min_insn_len
);
13024 return (int) min_insn_len
;
13029 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
13031 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13033 struct remote_state
*rs
= get_remote_state ();
13034 char *buf
= rs
->buf
;
13035 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13036 enum packet_result result
;
13038 gdb_assert (val
>= 0 || val
== -1);
13039 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13040 /* Send -1 as literal "-1" to avoid host size dependency. */
13044 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13047 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13050 remote_get_noisy_reply ();
13051 result
= packet_ok (rs
->buf
,
13052 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13054 if (result
!= PACKET_OK
)
13055 warning (_("Bogus reply from target: %s"), rs
->buf
);
13060 remote_set_trace_notes (struct target_ops
*self
,
13061 const char *user
, const char *notes
,
13062 const char *stop_notes
)
13064 struct remote_state
*rs
= get_remote_state ();
13066 char *buf
= rs
->buf
;
13067 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13070 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13073 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13074 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13080 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13081 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13087 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13088 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13092 /* Ensure the buffer is terminated. */
13096 reply
= remote_get_noisy_reply ();
13097 if (*reply
== '\0')
13100 if (strcmp (reply
, "OK") != 0)
13101 error (_("Bogus reply from target: %s"), reply
);
13107 remote_use_agent (struct target_ops
*self
, int use
)
13109 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13111 struct remote_state
*rs
= get_remote_state ();
13113 /* If the stub supports QAgent. */
13114 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13116 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13118 if (strcmp (rs
->buf
, "OK") == 0)
13129 remote_can_use_agent (struct target_ops
*self
)
13131 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13134 struct btrace_target_info
13136 /* The ptid of the traced thread. */
13139 /* The obtained branch trace configuration. */
13140 struct btrace_config conf
;
13143 /* Reset our idea of our target's btrace configuration. */
13146 remote_btrace_reset (void)
13148 struct remote_state
*rs
= get_remote_state ();
13150 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13153 /* Check whether the target supports branch tracing. */
13156 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13158 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13160 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13165 case BTRACE_FORMAT_NONE
:
13168 case BTRACE_FORMAT_BTS
:
13169 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13171 case BTRACE_FORMAT_PT
:
13172 /* The trace is decoded on the host. Even if our target supports it,
13173 we still need to have libipt to decode the trace. */
13174 #if defined (HAVE_LIBIPT)
13175 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13176 #else /* !defined (HAVE_LIBIPT) */
13178 #endif /* !defined (HAVE_LIBIPT) */
13181 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13184 /* Synchronize the configuration with the target. */
13187 btrace_sync_conf (const struct btrace_config
*conf
)
13189 struct packet_config
*packet
;
13190 struct remote_state
*rs
;
13191 char *buf
, *pos
, *endbuf
;
13193 rs
= get_remote_state ();
13195 endbuf
= buf
+ get_remote_packet_size ();
13197 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13198 if (packet_config_support (packet
) == PACKET_ENABLE
13199 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13202 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13206 getpkt (&buf
, &rs
->buf_size
, 0);
13208 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13210 if (buf
[0] == 'E' && buf
[1] == '.')
13211 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13213 error (_("Failed to configure the BTS buffer size."));
13216 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13219 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13220 if (packet_config_support (packet
) == PACKET_ENABLE
13221 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13224 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13228 getpkt (&buf
, &rs
->buf_size
, 0);
13230 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13232 if (buf
[0] == 'E' && buf
[1] == '.')
13233 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13235 error (_("Failed to configure the trace buffer size."));
13238 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13242 /* Read the current thread's btrace configuration from the target and
13243 store it into CONF. */
13246 btrace_read_config (struct btrace_config
*conf
)
13250 xml
= target_read_stralloc (¤t_target
,
13251 TARGET_OBJECT_BTRACE_CONF
, "");
13254 struct cleanup
*cleanup
;
13256 cleanup
= make_cleanup (xfree
, xml
);
13257 parse_xml_btrace_conf (conf
, xml
);
13258 do_cleanups (cleanup
);
13262 /* Maybe reopen target btrace. */
13265 remote_btrace_maybe_reopen (void)
13267 struct remote_state
*rs
= get_remote_state ();
13268 struct thread_info
*tp
;
13269 int btrace_target_pushed
= 0;
13272 scoped_restore_current_thread restore_thread
;
13274 ALL_NON_EXITED_THREADS (tp
)
13276 set_general_thread (tp
->ptid
);
13278 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13279 btrace_read_config (&rs
->btrace_config
);
13281 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13284 #if !defined (HAVE_LIBIPT)
13285 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13290 warning (_("GDB does not support Intel Processor Trace. "
13291 "\"record\" will not work in this session."));
13296 #endif /* !defined (HAVE_LIBIPT) */
13298 /* Push target, once, but before anything else happens. This way our
13299 changes to the threads will be cleaned up by unpushing the target
13300 in case btrace_read_config () throws. */
13301 if (!btrace_target_pushed
)
13303 btrace_target_pushed
= 1;
13304 record_btrace_push_target ();
13305 printf_filtered (_("Target is recording using %s.\n"),
13306 btrace_format_string (rs
->btrace_config
.format
));
13309 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13310 tp
->btrace
.target
->ptid
= tp
->ptid
;
13311 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13315 /* Enable branch tracing. */
13317 static struct btrace_target_info
*
13318 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13319 const struct btrace_config
*conf
)
13321 struct btrace_target_info
*tinfo
= NULL
;
13322 struct packet_config
*packet
= NULL
;
13323 struct remote_state
*rs
= get_remote_state ();
13324 char *buf
= rs
->buf
;
13325 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13327 switch (conf
->format
)
13329 case BTRACE_FORMAT_BTS
:
13330 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13333 case BTRACE_FORMAT_PT
:
13334 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13338 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13339 error (_("Target does not support branch tracing."));
13341 btrace_sync_conf (conf
);
13343 set_general_thread (ptid
);
13345 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13347 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13349 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13351 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13352 error (_("Could not enable branch tracing for %s: %s"),
13353 target_pid_to_str (ptid
), rs
->buf
+ 2);
13355 error (_("Could not enable branch tracing for %s."),
13356 target_pid_to_str (ptid
));
13359 tinfo
= XCNEW (struct btrace_target_info
);
13360 tinfo
->ptid
= ptid
;
13362 /* If we fail to read the configuration, we lose some information, but the
13363 tracing itself is not impacted. */
13366 btrace_read_config (&tinfo
->conf
);
13368 CATCH (err
, RETURN_MASK_ERROR
)
13370 if (err
.message
!= NULL
)
13371 warning ("%s", err
.message
);
13378 /* Disable branch tracing. */
13381 remote_disable_btrace (struct target_ops
*self
,
13382 struct btrace_target_info
*tinfo
)
13384 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13385 struct remote_state
*rs
= get_remote_state ();
13386 char *buf
= rs
->buf
;
13387 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13389 if (packet_config_support (packet
) != PACKET_ENABLE
)
13390 error (_("Target does not support branch tracing."));
13392 set_general_thread (tinfo
->ptid
);
13394 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13396 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13398 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13400 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13401 error (_("Could not disable branch tracing for %s: %s"),
13402 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13404 error (_("Could not disable branch tracing for %s."),
13405 target_pid_to_str (tinfo
->ptid
));
13411 /* Teardown branch tracing. */
13414 remote_teardown_btrace (struct target_ops
*self
,
13415 struct btrace_target_info
*tinfo
)
13417 /* We must not talk to the target during teardown. */
13421 /* Read the branch trace. */
13423 static enum btrace_error
13424 remote_read_btrace (struct target_ops
*self
,
13425 struct btrace_data
*btrace
,
13426 struct btrace_target_info
*tinfo
,
13427 enum btrace_read_type type
)
13429 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13430 struct cleanup
*cleanup
;
13434 if (packet_config_support (packet
) != PACKET_ENABLE
)
13435 error (_("Target does not support branch tracing."));
13437 #if !defined(HAVE_LIBEXPAT)
13438 error (_("Cannot process branch tracing result. XML parsing not supported."));
13443 case BTRACE_READ_ALL
:
13446 case BTRACE_READ_NEW
:
13449 case BTRACE_READ_DELTA
:
13453 internal_error (__FILE__
, __LINE__
,
13454 _("Bad branch tracing read type: %u."),
13455 (unsigned int) type
);
13458 xml
= target_read_stralloc (¤t_target
,
13459 TARGET_OBJECT_BTRACE
, annex
);
13461 return BTRACE_ERR_UNKNOWN
;
13463 cleanup
= make_cleanup (xfree
, xml
);
13464 parse_xml_btrace (btrace
, xml
);
13465 do_cleanups (cleanup
);
13467 return BTRACE_ERR_NONE
;
13470 static const struct btrace_config
*
13471 remote_btrace_conf (struct target_ops
*self
,
13472 const struct btrace_target_info
*tinfo
)
13474 return &tinfo
->conf
;
13478 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13480 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13484 /* Implementation of to_load. */
13487 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13489 generic_load (name
, from_tty
);
13492 /* Accepts an integer PID; returns a string representing a file that
13493 can be opened on the remote side to get the symbols for the child
13494 process. Returns NULL if the operation is not supported. */
13497 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13499 static char *filename
= NULL
;
13500 struct inferior
*inf
;
13501 char *annex
= NULL
;
13503 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13506 if (filename
!= NULL
)
13509 inf
= find_inferior_pid (pid
);
13511 internal_error (__FILE__
, __LINE__
,
13512 _("not currently attached to process %d"), pid
);
13514 if (!inf
->fake_pid_p
)
13516 const int annex_size
= 9;
13518 annex
= (char *) alloca (annex_size
);
13519 xsnprintf (annex
, annex_size
, "%x", pid
);
13522 filename
= target_read_stralloc (¤t_target
,
13523 TARGET_OBJECT_EXEC_FILE
, annex
);
13528 /* Implement the to_can_do_single_step target_ops method. */
13531 remote_can_do_single_step (struct target_ops
*ops
)
13533 /* We can only tell whether target supports single step or not by
13534 supported s and S vCont actions if the stub supports vContSupported
13535 feature. If the stub doesn't support vContSupported feature,
13536 we have conservatively to think target doesn't supports single
13538 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13540 struct remote_state
*rs
= get_remote_state ();
13542 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13543 remote_vcont_probe (rs
);
13545 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13551 /* Implementation of the to_execution_direction method for the remote
13554 static enum exec_direction_kind
13555 remote_execution_direction (struct target_ops
*self
)
13557 struct remote_state
*rs
= get_remote_state ();
13559 return rs
->last_resume_exec_dir
;
13562 /* Return pointer to the thread_info struct which corresponds to
13563 THREAD_HANDLE (having length HANDLE_LEN). */
13565 static struct thread_info
*
13566 remote_thread_handle_to_thread_info (struct target_ops
*ops
,
13567 const gdb_byte
*thread_handle
,
13569 struct inferior
*inf
)
13571 struct thread_info
*tp
;
13573 ALL_NON_EXITED_THREADS (tp
)
13575 struct private_thread_info
*priv
= get_private_info_thread (tp
);
13577 if (tp
->inf
== inf
&& priv
!= NULL
)
13579 if (handle_len
!= priv
->thread_handle
->size ())
13580 error (_("Thread handle size mismatch: %d vs %zu (from remote)"),
13581 handle_len
, priv
->thread_handle
->size ());
13582 if (memcmp (thread_handle
, priv
->thread_handle
->data (),
13592 init_remote_ops (void)
13594 remote_ops
.to_shortname
= "remote";
13595 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13596 remote_ops
.to_doc
=
13597 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13598 Specify the serial device it is connected to\n\
13599 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13600 remote_ops
.to_open
= remote_open
;
13601 remote_ops
.to_close
= remote_close
;
13602 remote_ops
.to_detach
= remote_detach
;
13603 remote_ops
.to_disconnect
= remote_disconnect
;
13604 remote_ops
.to_resume
= remote_resume
;
13605 remote_ops
.to_commit_resume
= remote_commit_resume
;
13606 remote_ops
.to_wait
= remote_wait
;
13607 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13608 remote_ops
.to_store_registers
= remote_store_registers
;
13609 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13610 remote_ops
.to_files_info
= remote_files_info
;
13611 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13612 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13613 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13614 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13615 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13616 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13617 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13618 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13619 remote_ops
.to_watchpoint_addr_within_range
=
13620 remote_watchpoint_addr_within_range
;
13621 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13622 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13623 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13624 remote_ops
.to_region_ok_for_hw_watchpoint
13625 = remote_region_ok_for_hw_watchpoint
;
13626 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13627 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13628 remote_ops
.to_kill
= remote_kill
;
13629 remote_ops
.to_load
= remote_load
;
13630 remote_ops
.to_mourn_inferior
= remote_mourn
;
13631 remote_ops
.to_pass_signals
= remote_pass_signals
;
13632 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13633 remote_ops
.to_program_signals
= remote_program_signals
;
13634 remote_ops
.to_thread_alive
= remote_thread_alive
;
13635 remote_ops
.to_thread_name
= remote_thread_name
;
13636 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13637 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13638 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13639 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13640 remote_ops
.to_stop
= remote_stop
;
13641 remote_ops
.to_interrupt
= remote_interrupt
;
13642 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13643 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13644 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13645 remote_ops
.to_rcmd
= remote_rcmd
;
13646 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13647 remote_ops
.to_log_command
= serial_log_command
;
13648 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13649 remote_ops
.to_stratum
= process_stratum
;
13650 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13651 remote_ops
.to_has_memory
= default_child_has_memory
;
13652 remote_ops
.to_has_stack
= default_child_has_stack
;
13653 remote_ops
.to_has_registers
= default_child_has_registers
;
13654 remote_ops
.to_has_execution
= default_child_has_execution
;
13655 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13656 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13657 remote_ops
.to_magic
= OPS_MAGIC
;
13658 remote_ops
.to_memory_map
= remote_memory_map
;
13659 remote_ops
.to_flash_erase
= remote_flash_erase
;
13660 remote_ops
.to_flash_done
= remote_flash_done
;
13661 remote_ops
.to_read_description
= remote_read_description
;
13662 remote_ops
.to_search_memory
= remote_search_memory
;
13663 remote_ops
.to_can_async_p
= remote_can_async_p
;
13664 remote_ops
.to_is_async_p
= remote_is_async_p
;
13665 remote_ops
.to_async
= remote_async
;
13666 remote_ops
.to_thread_events
= remote_thread_events
;
13667 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13668 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13669 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13670 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13671 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13672 remote_ops
.to_supports_disable_randomization
13673 = remote_supports_disable_randomization
;
13674 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13675 remote_ops
.to_fileio_open
= remote_hostio_open
;
13676 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13677 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13678 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13679 remote_ops
.to_fileio_close
= remote_hostio_close
;
13680 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13681 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13682 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13683 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13684 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13685 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13686 remote_ops
.to_trace_init
= remote_trace_init
;
13687 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13688 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13689 remote_ops
.to_download_trace_state_variable
13690 = remote_download_trace_state_variable
;
13691 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13692 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13693 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13694 remote_ops
.to_trace_start
= remote_trace_start
;
13695 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13696 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13697 remote_ops
.to_trace_stop
= remote_trace_stop
;
13698 remote_ops
.to_trace_find
= remote_trace_find
;
13699 remote_ops
.to_get_trace_state_variable_value
13700 = remote_get_trace_state_variable_value
;
13701 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13702 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13703 remote_ops
.to_upload_trace_state_variables
13704 = remote_upload_trace_state_variables
;
13705 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13706 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13707 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13708 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13709 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13710 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13711 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13712 remote_ops
.to_verify_memory
= remote_verify_memory
;
13713 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13714 remote_ops
.to_set_permissions
= remote_set_permissions
;
13715 remote_ops
.to_static_tracepoint_marker_at
13716 = remote_static_tracepoint_marker_at
;
13717 remote_ops
.to_static_tracepoint_markers_by_strid
13718 = remote_static_tracepoint_markers_by_strid
;
13719 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13720 remote_ops
.to_use_agent
= remote_use_agent
;
13721 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13722 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13723 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13724 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13725 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13726 remote_ops
.to_read_btrace
= remote_read_btrace
;
13727 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13728 remote_ops
.to_augmented_libraries_svr4_read
=
13729 remote_augmented_libraries_svr4_read
;
13730 remote_ops
.to_follow_fork
= remote_follow_fork
;
13731 remote_ops
.to_follow_exec
= remote_follow_exec
;
13732 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13733 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13734 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13735 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13736 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13737 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13738 remote_ops
.to_execution_direction
= remote_execution_direction
;
13739 remote_ops
.to_thread_handle_to_thread_info
=
13740 remote_thread_handle_to_thread_info
;
13743 /* Set up the extended remote vector by making a copy of the standard
13744 remote vector and adding to it. */
13747 init_extended_remote_ops (void)
13749 extended_remote_ops
= remote_ops
;
13751 extended_remote_ops
.to_shortname
= "extended-remote";
13752 extended_remote_ops
.to_longname
=
13753 "Extended remote serial target in gdb-specific protocol";
13754 extended_remote_ops
.to_doc
=
13755 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13756 Specify the serial device it is connected to (e.g. /dev/ttya).";
13757 extended_remote_ops
.to_open
= extended_remote_open
;
13758 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13759 extended_remote_ops
.to_detach
= extended_remote_detach
;
13760 extended_remote_ops
.to_attach
= extended_remote_attach
;
13761 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13762 extended_remote_ops
.to_supports_disable_randomization
13763 = extended_remote_supports_disable_randomization
;
13767 remote_can_async_p (struct target_ops
*ops
)
13769 struct remote_state
*rs
= get_remote_state ();
13771 /* We don't go async if the user has explicitly prevented it with the
13772 "maint set target-async" command. */
13773 if (!target_async_permitted
)
13776 /* We're async whenever the serial device is. */
13777 return serial_can_async_p (rs
->remote_desc
);
13781 remote_is_async_p (struct target_ops
*ops
)
13783 struct remote_state
*rs
= get_remote_state ();
13785 if (!target_async_permitted
)
13786 /* We only enable async when the user specifically asks for it. */
13789 /* We're async whenever the serial device is. */
13790 return serial_is_async_p (rs
->remote_desc
);
13793 /* Pass the SERIAL event on and up to the client. One day this code
13794 will be able to delay notifying the client of an event until the
13795 point where an entire packet has been received. */
13797 static serial_event_ftype remote_async_serial_handler
;
13800 remote_async_serial_handler (struct serial
*scb
, void *context
)
13802 /* Don't propogate error information up to the client. Instead let
13803 the client find out about the error by querying the target. */
13804 inferior_event_handler (INF_REG_EVENT
, NULL
);
13808 remote_async_inferior_event_handler (gdb_client_data data
)
13810 inferior_event_handler (INF_REG_EVENT
, NULL
);
13814 remote_async (struct target_ops
*ops
, int enable
)
13816 struct remote_state
*rs
= get_remote_state ();
13820 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13822 /* If there are pending events in the stop reply queue tell the
13823 event loop to process them. */
13824 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13825 mark_async_event_handler (remote_async_inferior_event_token
);
13826 /* For simplicity, below we clear the pending events token
13827 without remembering whether it is marked, so here we always
13828 mark it. If there's actually no pending notification to
13829 process, this ends up being a no-op (other than a spurious
13830 event-loop wakeup). */
13831 if (target_is_non_stop_p ())
13832 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13836 serial_async (rs
->remote_desc
, NULL
, NULL
);
13837 /* If the core is disabling async, it doesn't want to be
13838 disturbed with target events. Clear all async event sources
13840 clear_async_event_handler (remote_async_inferior_event_token
);
13841 if (target_is_non_stop_p ())
13842 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13846 /* Implementation of the to_thread_events method. */
13849 remote_thread_events (struct target_ops
*ops
, int enable
)
13851 struct remote_state
*rs
= get_remote_state ();
13852 size_t size
= get_remote_packet_size ();
13854 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13857 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13859 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13861 switch (packet_ok (rs
->buf
,
13862 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13865 if (strcmp (rs
->buf
, "OK") != 0)
13866 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13869 warning (_("Remote failure reply: %s"), rs
->buf
);
13871 case PACKET_UNKNOWN
:
13877 set_remote_cmd (char *args
, int from_tty
)
13879 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13883 show_remote_cmd (char *args
, int from_tty
)
13885 /* We can't just use cmd_show_list here, because we want to skip
13886 the redundant "show remote Z-packet" and the legacy aliases. */
13887 struct cmd_list_element
*list
= remote_show_cmdlist
;
13888 struct ui_out
*uiout
= current_uiout
;
13890 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
13891 for (; list
!= NULL
; list
= list
->next
)
13892 if (strcmp (list
->name
, "Z-packet") == 0)
13894 else if (list
->type
== not_set_cmd
)
13895 /* Alias commands are exactly like the original, except they
13896 don't have the normal type. */
13900 ui_out_emit_tuple
option_emitter (uiout
, "option");
13902 uiout
->field_string ("name", list
->name
);
13903 uiout
->text (": ");
13904 if (list
->type
== show_cmd
)
13905 do_show_command (NULL
, from_tty
, list
);
13907 cmd_func (list
, NULL
, from_tty
);
13912 /* Function to be called whenever a new objfile (shlib) is detected. */
13914 remote_new_objfile (struct objfile
*objfile
)
13916 struct remote_state
*rs
= get_remote_state ();
13918 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13919 remote_check_symbols ();
13922 /* Pull all the tracepoints defined on the target and create local
13923 data structures representing them. We don't want to create real
13924 tracepoints yet, we don't want to mess up the user's existing
13928 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13930 struct remote_state
*rs
= get_remote_state ();
13933 /* Ask for a first packet of tracepoint definition. */
13935 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13937 while (*p
&& *p
!= 'l')
13939 parse_tracepoint_definition (p
, utpp
);
13940 /* Ask for another packet of tracepoint definition. */
13942 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13949 remote_upload_trace_state_variables (struct target_ops
*self
,
13950 struct uploaded_tsv
**utsvp
)
13952 struct remote_state
*rs
= get_remote_state ();
13955 /* Ask for a first packet of variable definition. */
13957 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13959 while (*p
&& *p
!= 'l')
13961 parse_tsv_definition (p
, utsvp
);
13962 /* Ask for another packet of variable definition. */
13964 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13970 /* The "set/show range-stepping" show hook. */
13973 show_range_stepping (struct ui_file
*file
, int from_tty
,
13974 struct cmd_list_element
*c
,
13977 fprintf_filtered (file
,
13978 _("Debugger's willingness to use range stepping "
13979 "is %s.\n"), value
);
13982 /* The "set/show range-stepping" set hook. */
13985 set_range_stepping (char *ignore_args
, int from_tty
,
13986 struct cmd_list_element
*c
)
13988 struct remote_state
*rs
= get_remote_state ();
13990 /* Whene enabling, check whether range stepping is actually
13991 supported by the target, and warn if not. */
13992 if (use_range_stepping
)
13994 if (rs
->remote_desc
!= NULL
)
13996 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13997 remote_vcont_probe (rs
);
13999 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
14000 && rs
->supports_vCont
.r
)
14004 warning (_("Range stepping is not supported by the current target"));
14009 _initialize_remote (void)
14011 struct cmd_list_element
*cmd
;
14012 const char *cmd_name
;
14014 /* architecture specific data */
14015 remote_gdbarch_data_handle
=
14016 gdbarch_data_register_post_init (init_remote_state
);
14017 remote_g_packet_data_handle
=
14018 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
14021 = register_program_space_data_with_cleanup (NULL
,
14022 remote_pspace_data_cleanup
);
14024 /* Initialize the per-target state. At the moment there is only one
14025 of these, not one per target. Only one target is active at a
14027 remote_state
= new_remote_state ();
14029 init_remote_ops ();
14030 add_target (&remote_ops
);
14032 init_extended_remote_ops ();
14033 add_target (&extended_remote_ops
);
14035 /* Hook into new objfile notification. */
14036 observer_attach_new_objfile (remote_new_objfile
);
14037 /* We're no longer interested in notification events of an inferior
14039 observer_attach_inferior_exit (discard_pending_stop_replies
);
14042 init_remote_threadtests ();
14045 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
14046 /* set/show remote ... */
14048 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
14049 Remote protocol specific variables\n\
14050 Configure various remote-protocol specific variables such as\n\
14051 the packets being used"),
14052 &remote_set_cmdlist
, "set remote ",
14053 0 /* allow-unknown */, &setlist
);
14054 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
14055 Remote protocol specific variables\n\
14056 Configure various remote-protocol specific variables such as\n\
14057 the packets being used"),
14058 &remote_show_cmdlist
, "show remote ",
14059 0 /* allow-unknown */, &showlist
);
14061 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
14062 Compare section data on target to the exec file.\n\
14063 Argument is a single section name (default: all loaded sections).\n\
14064 To compare only read-only loaded sections, specify the -r option."),
14067 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14068 Send an arbitrary packet to a remote target.\n\
14069 maintenance packet TEXT\n\
14070 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14071 this command sends the string TEXT to the inferior, and displays the\n\
14072 response packet. GDB supplies the initial `$' character, and the\n\
14073 terminating `#' character and checksum."),
14076 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14077 Set whether to send break if interrupted."), _("\
14078 Show whether to send break if interrupted."), _("\
14079 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14080 set_remotebreak
, show_remotebreak
,
14081 &setlist
, &showlist
);
14082 cmd_name
= "remotebreak";
14083 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14084 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14085 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14086 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14087 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14089 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14090 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14092 Set interrupt sequence to remote target."), _("\
14093 Show interrupt sequence to remote target."), _("\
14094 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14095 NULL
, show_interrupt_sequence
,
14096 &remote_set_cmdlist
,
14097 &remote_show_cmdlist
);
14099 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14100 &interrupt_on_connect
, _("\
14101 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14102 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14103 If set, interrupt sequence is sent to remote target."),
14105 &remote_set_cmdlist
, &remote_show_cmdlist
);
14107 /* Install commands for configuring memory read/write packets. */
14109 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14110 Set the maximum number of bytes per memory write packet (deprecated)."),
14112 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14113 Show the maximum number of bytes per memory write packet (deprecated)."),
14115 add_cmd ("memory-write-packet-size", no_class
,
14116 set_memory_write_packet_size
, _("\
14117 Set the maximum number of bytes per memory-write packet.\n\
14118 Specify the number of bytes in a packet or 0 (zero) for the\n\
14119 default packet size. The actual limit is further reduced\n\
14120 dependent on the target. Specify ``fixed'' to disable the\n\
14121 further restriction and ``limit'' to enable that restriction."),
14122 &remote_set_cmdlist
);
14123 add_cmd ("memory-read-packet-size", no_class
,
14124 set_memory_read_packet_size
, _("\
14125 Set the maximum number of bytes per memory-read packet.\n\
14126 Specify the number of bytes in a packet or 0 (zero) for the\n\
14127 default packet size. The actual limit is further reduced\n\
14128 dependent on the target. Specify ``fixed'' to disable the\n\
14129 further restriction and ``limit'' to enable that restriction."),
14130 &remote_set_cmdlist
);
14131 add_cmd ("memory-write-packet-size", no_class
,
14132 show_memory_write_packet_size
,
14133 _("Show the maximum number of bytes per memory-write packet."),
14134 &remote_show_cmdlist
);
14135 add_cmd ("memory-read-packet-size", no_class
,
14136 show_memory_read_packet_size
,
14137 _("Show the maximum number of bytes per memory-read packet."),
14138 &remote_show_cmdlist
);
14140 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14141 &remote_hw_watchpoint_limit
, _("\
14142 Set the maximum number of target hardware watchpoints."), _("\
14143 Show the maximum number of target hardware watchpoints."), _("\
14144 Specify a negative limit for unlimited."),
14145 NULL
, NULL
, /* FIXME: i18n: The maximum
14146 number of target hardware
14147 watchpoints is %s. */
14148 &remote_set_cmdlist
, &remote_show_cmdlist
);
14149 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14150 &remote_hw_watchpoint_length_limit
, _("\
14151 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14152 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14153 Specify a negative limit for unlimited."),
14154 NULL
, NULL
, /* FIXME: i18n: The maximum
14155 length (in bytes) of a target
14156 hardware watchpoint is %s. */
14157 &remote_set_cmdlist
, &remote_show_cmdlist
);
14158 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14159 &remote_hw_breakpoint_limit
, _("\
14160 Set the maximum number of target hardware breakpoints."), _("\
14161 Show the maximum number of target hardware breakpoints."), _("\
14162 Specify a negative limit for unlimited."),
14163 NULL
, NULL
, /* FIXME: i18n: The maximum
14164 number of target hardware
14165 breakpoints is %s. */
14166 &remote_set_cmdlist
, &remote_show_cmdlist
);
14168 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14169 &remote_address_size
, _("\
14170 Set the maximum size of the address (in bits) in a memory packet."), _("\
14171 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14173 NULL
, /* FIXME: i18n: */
14174 &setlist
, &showlist
);
14176 init_all_packet_configs ();
14178 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14179 "X", "binary-download", 1);
14181 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14182 "vCont", "verbose-resume", 0);
14184 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14185 "QPassSignals", "pass-signals", 0);
14187 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14188 "QCatchSyscalls", "catch-syscalls", 0);
14190 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14191 "QProgramSignals", "program-signals", 0);
14193 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14194 "QStartupWithShell", "startup-with-shell", 0);
14196 add_packet_config_cmd (&remote_protocol_packets
14197 [PACKET_QEnvironmentHexEncoded
],
14198 "QEnvironmentHexEncoded", "environment-hex-encoded",
14201 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14202 "QEnvironmentReset", "environment-reset",
14205 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14206 "QEnvironmentUnset", "environment-unset",
14209 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14210 "qSymbol", "symbol-lookup", 0);
14212 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14213 "P", "set-register", 1);
14215 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14216 "p", "fetch-register", 1);
14218 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14219 "Z0", "software-breakpoint", 0);
14221 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14222 "Z1", "hardware-breakpoint", 0);
14224 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14225 "Z2", "write-watchpoint", 0);
14227 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14228 "Z3", "read-watchpoint", 0);
14230 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14231 "Z4", "access-watchpoint", 0);
14233 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14234 "qXfer:auxv:read", "read-aux-vector", 0);
14236 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14237 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14239 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14240 "qXfer:features:read", "target-features", 0);
14242 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14243 "qXfer:libraries:read", "library-info", 0);
14245 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14246 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14248 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14249 "qXfer:memory-map:read", "memory-map", 0);
14251 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14252 "qXfer:spu:read", "read-spu-object", 0);
14254 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14255 "qXfer:spu:write", "write-spu-object", 0);
14257 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14258 "qXfer:osdata:read", "osdata", 0);
14260 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14261 "qXfer:threads:read", "threads", 0);
14263 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14264 "qXfer:siginfo:read", "read-siginfo-object", 0);
14266 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14267 "qXfer:siginfo:write", "write-siginfo-object", 0);
14269 add_packet_config_cmd
14270 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14271 "qXfer:traceframe-info:read", "traceframe-info", 0);
14273 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14274 "qXfer:uib:read", "unwind-info-block", 0);
14276 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14277 "qGetTLSAddr", "get-thread-local-storage-address",
14280 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14281 "qGetTIBAddr", "get-thread-information-block-address",
14284 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14285 "bc", "reverse-continue", 0);
14287 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14288 "bs", "reverse-step", 0);
14290 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14291 "qSupported", "supported-packets", 0);
14293 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14294 "qSearch:memory", "search-memory", 0);
14296 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14297 "qTStatus", "trace-status", 0);
14299 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14300 "vFile:setfs", "hostio-setfs", 0);
14302 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14303 "vFile:open", "hostio-open", 0);
14305 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14306 "vFile:pread", "hostio-pread", 0);
14308 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14309 "vFile:pwrite", "hostio-pwrite", 0);
14311 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14312 "vFile:close", "hostio-close", 0);
14314 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14315 "vFile:unlink", "hostio-unlink", 0);
14317 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14318 "vFile:readlink", "hostio-readlink", 0);
14320 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14321 "vFile:fstat", "hostio-fstat", 0);
14323 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14324 "vAttach", "attach", 0);
14326 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14329 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14330 "QStartNoAckMode", "noack", 0);
14332 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14333 "vKill", "kill", 0);
14335 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14336 "qAttached", "query-attached", 0);
14338 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14339 "ConditionalTracepoints",
14340 "conditional-tracepoints", 0);
14342 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14343 "ConditionalBreakpoints",
14344 "conditional-breakpoints", 0);
14346 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14347 "BreakpointCommands",
14348 "breakpoint-commands", 0);
14350 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14351 "FastTracepoints", "fast-tracepoints", 0);
14353 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14354 "TracepointSource", "TracepointSource", 0);
14356 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14357 "QAllow", "allow", 0);
14359 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14360 "StaticTracepoints", "static-tracepoints", 0);
14362 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14363 "InstallInTrace", "install-in-trace", 0);
14365 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14366 "qXfer:statictrace:read", "read-sdata-object", 0);
14368 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14369 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14371 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14372 "QDisableRandomization", "disable-randomization", 0);
14374 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14375 "QAgent", "agent", 0);
14377 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14378 "QTBuffer:size", "trace-buffer-size", 0);
14380 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14381 "Qbtrace:off", "disable-btrace", 0);
14383 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14384 "Qbtrace:bts", "enable-btrace-bts", 0);
14386 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14387 "Qbtrace:pt", "enable-btrace-pt", 0);
14389 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14390 "qXfer:btrace", "read-btrace", 0);
14392 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14393 "qXfer:btrace-conf", "read-btrace-conf", 0);
14395 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14396 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14398 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14399 "multiprocess-feature", "multiprocess-feature", 0);
14401 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14402 "swbreak-feature", "swbreak-feature", 0);
14404 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14405 "hwbreak-feature", "hwbreak-feature", 0);
14407 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14408 "fork-event-feature", "fork-event-feature", 0);
14410 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14411 "vfork-event-feature", "vfork-event-feature", 0);
14413 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14414 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14416 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14417 "vContSupported", "verbose-resume-supported", 0);
14419 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14420 "exec-event-feature", "exec-event-feature", 0);
14422 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14423 "vCtrlC", "ctrl-c", 0);
14425 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14426 "QThreadEvents", "thread-events", 0);
14428 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14429 "N stop reply", "no-resumed-stop-reply", 0);
14431 /* Assert that we've registered "set remote foo-packet" commands
14432 for all packet configs. */
14436 for (i
= 0; i
< PACKET_MAX
; i
++)
14438 /* Ideally all configs would have a command associated. Some
14439 still don't though. */
14444 case PACKET_QNonStop
:
14445 case PACKET_EnableDisableTracepoints_feature
:
14446 case PACKET_tracenz_feature
:
14447 case PACKET_DisconnectedTracing_feature
:
14448 case PACKET_augmented_libraries_svr4_read_feature
:
14450 /* Additions to this list need to be well justified:
14451 pre-existing packets are OK; new packets are not. */
14459 /* This catches both forgetting to add a config command, and
14460 forgetting to remove a packet from the exception list. */
14461 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14465 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14466 Z sub-packet has its own set and show commands, but users may
14467 have sets to this variable in their .gdbinit files (or in their
14469 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14470 &remote_Z_packet_detect
, _("\
14471 Set use of remote protocol `Z' packets"), _("\
14472 Show use of remote protocol `Z' packets "), _("\
14473 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14475 set_remote_protocol_Z_packet_cmd
,
14476 show_remote_protocol_Z_packet_cmd
,
14477 /* FIXME: i18n: Use of remote protocol
14478 `Z' packets is %s. */
14479 &remote_set_cmdlist
, &remote_show_cmdlist
);
14481 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14482 Manipulate files on the remote system\n\
14483 Transfer files to and from the remote target system."),
14484 &remote_cmdlist
, "remote ",
14485 0 /* allow-unknown */, &cmdlist
);
14487 add_cmd ("put", class_files
, remote_put_command
,
14488 _("Copy a local file to the remote system."),
14491 add_cmd ("get", class_files
, remote_get_command
,
14492 _("Copy a remote file to the local system."),
14495 add_cmd ("delete", class_files
, remote_delete_command
,
14496 _("Delete a remote file."),
14499 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14500 &remote_exec_file_var
, _("\
14501 Set the remote pathname for \"run\""), _("\
14502 Show the remote pathname for \"run\""), NULL
,
14503 set_remote_exec_file
,
14504 show_remote_exec_file
,
14505 &remote_set_cmdlist
,
14506 &remote_show_cmdlist
);
14508 add_setshow_boolean_cmd ("range-stepping", class_run
,
14509 &use_range_stepping
, _("\
14510 Enable or disable range stepping."), _("\
14511 Show whether target-assisted range stepping is enabled."), _("\
14512 If on, and the target supports it, when stepping a source line, GDB\n\
14513 tells the target to step the corresponding range of addresses itself instead\n\
14514 of issuing multiple single-steps. This speeds up source level\n\
14515 stepping. If off, GDB always issues single-steps, even if range\n\
14516 stepping is supported by the target. The default is on."),
14517 set_range_stepping
,
14518 show_range_stepping
,
14522 /* Eventually initialize fileio. See fileio.c */
14523 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14525 /* Take advantage of the fact that the TID field is not used, to tag
14526 special ptids with it set to != 0. */
14527 magic_null_ptid
= ptid_build (42000, -1, 1);
14528 not_sent_ptid
= ptid_build (42000, -2, 1);
14529 any_thread_ptid
= ptid_build (42000, 0, 1);