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"
78 /* Temp hacks for tracepoint encoding migration. */
79 static char *target_buf
;
80 static long target_buf_size
;
82 /* Per-program-space data key. */
83 static const struct program_space_data
*remote_pspace_data
;
85 /* The variable registered as the control variable used by the
86 remote exec-file commands. While the remote exec-file setting is
87 per-program-space, the set/show machinery uses this as the
88 location of the remote exec-file value. */
89 static char *remote_exec_file_var
;
91 /* The size to align memory write packets, when practical. The protocol
92 does not guarantee any alignment, and gdb will generate short
93 writes and unaligned writes, but even as a best-effort attempt this
94 can improve bulk transfers. For instance, if a write is misaligned
95 relative to the target's data bus, the stub may need to make an extra
96 round trip fetching data from the target. This doesn't make a
97 huge difference, but it's easy to do, so we try to be helpful.
99 The alignment chosen is arbitrary; usually data bus width is
100 important here, not the possibly larger cache line size. */
101 enum { REMOTE_ALIGN_WRITES
= 16 };
103 /* Prototypes for local functions. */
104 static int getpkt_sane (char **buf
, long *sizeof_buf
, int forever
);
105 static int getpkt_or_notif_sane (char **buf
, long *sizeof_buf
,
106 int forever
, int *is_notif
);
108 static void remote_files_info (struct target_ops
*ignore
);
110 static void remote_prepare_to_store (struct target_ops
*self
,
111 struct regcache
*regcache
);
113 static void remote_open_1 (const char *, int, struct target_ops
*,
116 static void remote_close (struct target_ops
*self
);
120 static int remote_vkill (int pid
, struct remote_state
*rs
);
122 static void remote_kill_k (void);
124 static void remote_mourn (struct target_ops
*ops
);
126 static void extended_remote_restart (void);
128 static void remote_send (char **buf
, long *sizeof_buf_p
);
130 static int readchar (int timeout
);
132 static void remote_serial_write (const char *str
, int len
);
134 static void remote_kill (struct target_ops
*ops
);
136 static int remote_can_async_p (struct target_ops
*);
138 static int remote_is_async_p (struct target_ops
*);
140 static void remote_async (struct target_ops
*ops
, int enable
);
142 static void remote_thread_events (struct target_ops
*ops
, int enable
);
144 static void interrupt_query (void);
146 static void set_general_thread (ptid_t ptid
);
147 static void set_continue_thread (ptid_t ptid
);
149 static void get_offsets (void);
151 static void skip_frame (void);
153 static long read_frame (char **buf_p
, long *sizeof_buf
);
155 static int hexnumlen (ULONGEST num
);
157 static void init_remote_ops (void);
159 static void init_extended_remote_ops (void);
161 static void remote_stop (struct target_ops
*self
, ptid_t
);
163 static int stubhex (int ch
);
165 static int hexnumstr (char *, ULONGEST
);
167 static int hexnumnstr (char *, ULONGEST
, int);
169 static CORE_ADDR
remote_address_masked (CORE_ADDR
);
171 static void print_packet (const char *);
173 static void compare_sections_command (char *, int);
175 static void packet_command (char *, int);
177 static int stub_unpack_int (char *buff
, int fieldlength
);
179 static ptid_t
remote_current_thread (ptid_t oldptid
);
181 static int putpkt_binary (const char *buf
, int cnt
);
183 static void check_binary_download (CORE_ADDR addr
);
185 struct packet_config
;
187 static void show_packet_config_cmd (struct packet_config
*config
);
189 static void show_remote_protocol_packet_cmd (struct ui_file
*file
,
191 struct cmd_list_element
*c
,
194 static char *write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
);
195 static ptid_t
read_ptid (char *buf
, char **obuf
);
197 static void remote_set_permissions (struct target_ops
*self
);
199 static int remote_get_trace_status (struct target_ops
*self
,
200 struct trace_status
*ts
);
202 static int remote_upload_tracepoints (struct target_ops
*self
,
203 struct uploaded_tp
**utpp
);
205 static int remote_upload_trace_state_variables (struct target_ops
*self
,
206 struct uploaded_tsv
**utsvp
);
208 static void remote_query_supported (void);
210 static void remote_check_symbols (void);
212 void _initialize_remote (void);
215 static void stop_reply_xfree (struct stop_reply
*);
216 static void remote_parse_stop_reply (char *, struct stop_reply
*);
217 static void push_stop_reply (struct stop_reply
*);
218 static void discard_pending_stop_replies_in_queue (struct remote_state
*);
219 static int peek_stop_reply (ptid_t ptid
);
221 struct threads_listing_context
;
222 static void remove_new_fork_children (struct threads_listing_context
*);
224 static void remote_async_inferior_event_handler (gdb_client_data
);
226 static void remote_terminal_ours (struct target_ops
*self
);
228 static int remote_read_description_p (struct target_ops
*target
);
230 static void remote_console_output (char *msg
);
232 static int remote_supports_cond_breakpoints (struct target_ops
*self
);
234 static int remote_can_run_breakpoint_commands (struct target_ops
*self
);
236 static void remote_btrace_reset (void);
238 static void remote_btrace_maybe_reopen (void);
240 static int stop_reply_queue_length (void);
242 static void readahead_cache_invalidate (void);
244 static void remote_unpush_and_throw (void);
248 static struct cmd_list_element
*remote_cmdlist
;
250 /* For "set remote" and "show remote". */
252 static struct cmd_list_element
*remote_set_cmdlist
;
253 static struct cmd_list_element
*remote_show_cmdlist
;
255 /* Stub vCont actions support.
257 Each field is a boolean flag indicating whether the stub reports
258 support for the corresponding action. */
260 struct vCont_action_support
275 /* Controls whether GDB is willing to use range stepping. */
277 static int use_range_stepping
= 1;
279 #define OPAQUETHREADBYTES 8
281 /* a 64 bit opaque identifier */
282 typedef unsigned char threadref
[OPAQUETHREADBYTES
];
284 /* About this many threadisds fit in a packet. */
286 #define MAXTHREADLISTRESULTS 32
288 /* The max number of chars in debug output. The rest of chars are
291 #define REMOTE_DEBUG_MAX_CHAR 512
293 /* Data for the vFile:pread readahead cache. */
295 struct readahead_cache
297 /* The file descriptor for the file that is being cached. -1 if the
301 /* The offset into the file that the cache buffer corresponds
305 /* The buffer holding the cache contents. */
307 /* The buffer's size. We try to read as much as fits into a packet
311 /* Cache hit and miss counters. */
316 /* Description of the remote protocol state for the currently
317 connected target. This is per-target state, and independent of the
318 selected architecture. */
322 /* A buffer to use for incoming packets, and its current size. The
323 buffer is grown dynamically for larger incoming packets.
324 Outgoing packets may also be constructed in this buffer.
325 BUF_SIZE is always at least REMOTE_PACKET_SIZE;
326 REMOTE_PACKET_SIZE should be used to limit the length of outgoing
331 /* True if we're going through initial connection setup (finding out
332 about the remote side's threads, relocating symbols, etc.). */
335 /* If we negotiated packet size explicitly (and thus can bypass
336 heuristics for the largest packet size that will not overflow
337 a buffer in the stub), this will be set to that packet size.
338 Otherwise zero, meaning to use the guessed size. */
339 long explicit_packet_size
;
341 /* remote_wait is normally called when the target is running and
342 waits for a stop reply packet. But sometimes we need to call it
343 when the target is already stopped. We can send a "?" packet
344 and have remote_wait read the response. Or, if we already have
345 the response, we can stash it in BUF and tell remote_wait to
346 skip calling getpkt. This flag is set when BUF contains a
347 stop reply packet and the target is not waiting. */
348 int cached_wait_status
;
350 /* True, if in no ack mode. That is, neither GDB nor the stub will
351 expect acks from each other. The connection is assumed to be
355 /* True if we're connected in extended remote mode. */
358 /* True if we resumed the target and we're waiting for the target to
359 stop. In the mean time, we can't start another command/query.
360 The remote server wouldn't be ready to process it, so we'd
361 timeout waiting for a reply that would never come and eventually
362 we'd close the connection. This can happen in asynchronous mode
363 because we allow GDB commands while the target is running. */
364 int waiting_for_stop_reply
;
366 /* The status of the stub support for the various vCont actions. */
367 struct vCont_action_support supports_vCont
;
369 /* Nonzero if the user has pressed Ctrl-C, but the target hasn't
370 responded to that. */
373 /* True if we saw a Ctrl-C while reading or writing from/to the
374 remote descriptor. At that point it is not safe to send a remote
375 interrupt packet, so we instead remember we saw the Ctrl-C and
376 process it once we're done with sending/receiving the current
377 packet, which should be shortly. If however that takes too long,
378 and the user presses Ctrl-C again, we offer to disconnect. */
379 int got_ctrlc_during_io
;
381 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
382 remote_open knows that we don't have a file open when the program
384 struct serial
*remote_desc
;
386 /* These are the threads which we last sent to the remote system. The
387 TID member will be -1 for all or -2 for not sent yet. */
388 ptid_t general_thread
;
389 ptid_t continue_thread
;
391 /* This is the traceframe which we last selected on the remote system.
392 It will be -1 if no traceframe is selected. */
393 int remote_traceframe_number
;
395 char *last_pass_packet
;
397 /* The last QProgramSignals packet sent to the target. We bypass
398 sending a new program signals list down to the target if the new
399 packet is exactly the same as the last we sent. IOW, we only let
400 the target know about program signals list changes. */
401 char *last_program_signals_packet
;
403 enum gdb_signal last_sent_signal
;
407 /* The execution direction of the last resume we got. */
408 enum exec_direction_kind last_resume_exec_dir
;
410 char *finished_object
;
411 char *finished_annex
;
412 ULONGEST finished_offset
;
414 /* Should we try the 'ThreadInfo' query packet?
416 This variable (NOT available to the user: auto-detect only!)
417 determines whether GDB will use the new, simpler "ThreadInfo"
418 query or the older, more complex syntax for thread queries.
419 This is an auto-detect variable (set to true at each connect,
420 and set to false when the target fails to recognize it). */
421 int use_threadinfo_query
;
422 int use_threadextra_query
;
424 threadref echo_nextthread
;
425 threadref nextthread
;
426 threadref resultthreadlist
[MAXTHREADLISTRESULTS
];
428 /* The state of remote notification. */
429 struct remote_notif_state
*notif_state
;
431 /* The branch trace configuration. */
432 struct btrace_config btrace_config
;
434 /* The argument to the last "vFile:setfs:" packet we sent, used
435 to avoid sending repeated unnecessary "vFile:setfs:" packets.
436 Initialized to -1 to indicate that no "vFile:setfs:" packet
437 has yet been sent. */
440 /* A readahead cache for vFile:pread. Often, reading a binary
441 involves a sequence of small reads. E.g., when parsing an ELF
442 file. A readahead cache helps mostly the case of remote
443 debugging on a connection with higher latency, due to the
444 request/reply nature of the RSP. We only cache data for a single
445 file descriptor at a time. */
446 struct readahead_cache readahead_cache
;
449 /* Private data that we'll store in (struct thread_info)->private. */
450 struct private_thread_info
456 /* Whether the target stopped for a breakpoint/watchpoint. */
457 enum target_stop_reason stop_reason
;
459 /* This is set to the data address of the access causing the target
460 to stop for a watchpoint. */
461 CORE_ADDR watch_data_address
;
463 /* Fields used by the vCont action coalescing implemented in
464 remote_resume / remote_commit_resume. remote_resume stores each
465 thread's last resume request in these fields, so that a later
466 remote_commit_resume knows which is the proper action for this
467 thread to include in the vCont packet. */
469 /* True if the last target_resume call for this thread was a step
470 request, false if a continue request. */
471 int last_resume_step
;
473 /* The signal specified in the last target_resume call for this
475 enum gdb_signal last_resume_sig
;
477 /* Whether this thread was already vCont-resumed on the remote
483 free_private_thread_info (struct private_thread_info
*info
)
490 /* This data could be associated with a target, but we do not always
491 have access to the current target when we need it, so for now it is
492 static. This will be fine for as long as only one target is in use
494 static struct remote_state
*remote_state
;
496 static struct remote_state
*
497 get_remote_state_raw (void)
502 /* Allocate a new struct remote_state with xmalloc, initialize it, and
505 static struct remote_state
*
506 new_remote_state (void)
508 struct remote_state
*result
= XCNEW (struct remote_state
);
510 /* The default buffer size is unimportant; it will be expanded
511 whenever a larger buffer is needed. */
512 result
->buf_size
= 400;
513 result
->buf
= (char *) xmalloc (result
->buf_size
);
514 result
->remote_traceframe_number
= -1;
515 result
->last_sent_signal
= GDB_SIGNAL_0
;
516 result
->last_resume_exec_dir
= EXEC_FORWARD
;
522 /* Description of the remote protocol for a given architecture. */
526 long offset
; /* Offset into G packet. */
527 long regnum
; /* GDB's internal register number. */
528 LONGEST pnum
; /* Remote protocol register number. */
529 int in_g_packet
; /* Always part of G packet. */
530 /* long size in bytes; == register_size (target_gdbarch (), regnum);
532 /* char *name; == gdbarch_register_name (target_gdbarch (), regnum);
536 struct remote_arch_state
538 /* Description of the remote protocol registers. */
539 long sizeof_g_packet
;
541 /* Description of the remote protocol registers indexed by REGNUM
542 (making an array gdbarch_num_regs in size). */
543 struct packet_reg
*regs
;
545 /* This is the size (in chars) of the first response to the ``g''
546 packet. It is used as a heuristic when determining the maximum
547 size of memory-read and memory-write packets. A target will
548 typically only reserve a buffer large enough to hold the ``g''
549 packet. The size does not include packet overhead (headers and
551 long actual_register_packet_size
;
553 /* This is the maximum size (in chars) of a non read/write packet.
554 It is also used as a cap on the size of read/write packets. */
555 long remote_packet_size
;
558 /* Utility: generate error from an incoming stub packet. */
560 trace_error (char *buf
)
563 return; /* not an error msg */
566 case '1': /* malformed packet error */
567 if (*++buf
== '0') /* general case: */
568 error (_("remote.c: error in outgoing packet."));
570 error (_("remote.c: error in outgoing packet at field #%ld."),
571 strtol (buf
, NULL
, 16));
573 error (_("Target returns error code '%s'."), buf
);
577 /* Utility: wait for reply from stub, while accepting "O" packets. */
579 remote_get_noisy_reply (char **buf_p
,
582 do /* Loop on reply from remote stub. */
586 QUIT
; /* Allow user to bail out with ^C. */
587 getpkt (buf_p
, sizeof_buf
, 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
, *sizeof_buf
, "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 (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 (char *args
, int from_tty
)
1158 set_memory_packet_size (args
, &memory_write_packet_config
);
1162 show_memory_write_packet_size (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 (char *args
, int from_tty
)
1181 set_memory_packet_size (args
, &memory_read_packet_config
);
1185 show_memory_read_packet_size (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;
1978 return thread
->priv
;
1981 /* Return PTID's private thread data, creating it if necessary. */
1983 static struct private_thread_info
*
1984 get_private_info_ptid (ptid_t ptid
)
1986 struct thread_info
*info
= find_thread_ptid (ptid
);
1988 return get_private_info_thread (info
);
1991 /* Call this function as a result of
1992 1) A halt indication (T packet) containing a thread id
1993 2) A direct query of currthread
1994 3) Successful execution of set thread */
1997 record_currthread (struct remote_state
*rs
, ptid_t currthread
)
1999 rs
->general_thread
= currthread
;
2002 /* If 'QPassSignals' is supported, tell the remote stub what signals
2003 it can simply pass through to the inferior without reporting. */
2006 remote_pass_signals (struct target_ops
*self
,
2007 int numsigs
, unsigned char *pass_signals
)
2009 if (packet_support (PACKET_QPassSignals
) != PACKET_DISABLE
)
2011 char *pass_packet
, *p
;
2013 struct remote_state
*rs
= get_remote_state ();
2015 gdb_assert (numsigs
< 256);
2016 for (i
= 0; i
< numsigs
; i
++)
2018 if (pass_signals
[i
])
2021 pass_packet
= (char *) xmalloc (count
* 3 + strlen ("QPassSignals:") + 1);
2022 strcpy (pass_packet
, "QPassSignals:");
2023 p
= pass_packet
+ strlen (pass_packet
);
2024 for (i
= 0; i
< numsigs
; i
++)
2026 if (pass_signals
[i
])
2029 *p
++ = tohex (i
>> 4);
2030 *p
++ = tohex (i
& 15);
2039 if (!rs
->last_pass_packet
|| strcmp (rs
->last_pass_packet
, pass_packet
))
2041 putpkt (pass_packet
);
2042 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2043 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QPassSignals
]);
2044 if (rs
->last_pass_packet
)
2045 xfree (rs
->last_pass_packet
);
2046 rs
->last_pass_packet
= pass_packet
;
2049 xfree (pass_packet
);
2053 /* If 'QCatchSyscalls' is supported, tell the remote stub
2054 to report syscalls to GDB. */
2057 remote_set_syscall_catchpoint (struct target_ops
*self
,
2058 int pid
, int needed
, int any_count
,
2059 int table_size
, int *table
)
2062 enum packet_result result
;
2065 if (packet_support (PACKET_QCatchSyscalls
) == PACKET_DISABLE
)
2067 /* Not supported. */
2071 if (needed
&& !any_count
)
2075 /* Count how many syscalls are to be caught (table[sysno] != 0). */
2076 for (i
= 0; i
< table_size
; i
++)
2085 fprintf_unfiltered (gdb_stdlog
,
2086 "remote_set_syscall_catchpoint "
2087 "pid %d needed %d any_count %d n_sysno %d\n",
2088 pid
, needed
, any_count
, n_sysno
);
2093 /* Prepare a packet with the sysno list, assuming max 8+1
2094 characters for a sysno. If the resulting packet size is too
2095 big, fallback on the non-selective packet. */
2096 const int maxpktsz
= strlen ("QCatchSyscalls:1") + n_sysno
* 9 + 1;
2098 catch_packet
= (char *) xmalloc (maxpktsz
);
2099 strcpy (catch_packet
, "QCatchSyscalls:1");
2108 /* Add in catch_packet each syscall to be caught (table[i] != 0). */
2109 for (i
= 0; i
< table_size
; i
++)
2112 p
+= xsnprintf (p
, catch_packet
+ maxpktsz
- p
, ";%x", i
);
2115 if (strlen (catch_packet
) > get_remote_packet_size ())
2117 /* catch_packet too big. Fallback to less efficient
2118 non selective mode, with GDB doing the filtering. */
2119 catch_packet
[sizeof ("QCatchSyscalls:1") - 1] = 0;
2123 catch_packet
= xstrdup ("QCatchSyscalls:0");
2126 struct cleanup
*old_chain
= make_cleanup (xfree
, catch_packet
);
2127 struct remote_state
*rs
= get_remote_state ();
2129 putpkt (catch_packet
);
2130 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2131 result
= packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QCatchSyscalls
]);
2132 do_cleanups (old_chain
);
2133 if (result
== PACKET_OK
)
2140 /* If 'QProgramSignals' is supported, tell the remote stub what
2141 signals it should pass through to the inferior when detaching. */
2144 remote_program_signals (struct target_ops
*self
,
2145 int numsigs
, unsigned char *signals
)
2147 if (packet_support (PACKET_QProgramSignals
) != PACKET_DISABLE
)
2151 struct remote_state
*rs
= get_remote_state ();
2153 gdb_assert (numsigs
< 256);
2154 for (i
= 0; i
< numsigs
; i
++)
2159 packet
= (char *) xmalloc (count
* 3 + strlen ("QProgramSignals:") + 1);
2160 strcpy (packet
, "QProgramSignals:");
2161 p
= packet
+ strlen (packet
);
2162 for (i
= 0; i
< numsigs
; i
++)
2164 if (signal_pass_state (i
))
2167 *p
++ = tohex (i
>> 4);
2168 *p
++ = tohex (i
& 15);
2177 if (!rs
->last_program_signals_packet
2178 || strcmp (rs
->last_program_signals_packet
, packet
) != 0)
2181 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2182 packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_QProgramSignals
]);
2183 xfree (rs
->last_program_signals_packet
);
2184 rs
->last_program_signals_packet
= packet
;
2191 /* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is
2192 MINUS_ONE_PTID, set the thread to -1, so the stub returns the
2193 thread. If GEN is set, set the general thread, if not, then set
2194 the step/continue thread. */
2196 set_thread (ptid_t ptid
, int gen
)
2198 struct remote_state
*rs
= get_remote_state ();
2199 ptid_t state
= gen
? rs
->general_thread
: rs
->continue_thread
;
2200 char *buf
= rs
->buf
;
2201 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
2203 if (ptid_equal (state
, ptid
))
2207 *buf
++ = gen
? 'g' : 'c';
2208 if (ptid_equal (ptid
, magic_null_ptid
))
2209 xsnprintf (buf
, endbuf
- buf
, "0");
2210 else if (ptid_equal (ptid
, any_thread_ptid
))
2211 xsnprintf (buf
, endbuf
- buf
, "0");
2212 else if (ptid_equal (ptid
, minus_one_ptid
))
2213 xsnprintf (buf
, endbuf
- buf
, "-1");
2215 write_ptid (buf
, endbuf
, ptid
);
2217 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2219 rs
->general_thread
= ptid
;
2221 rs
->continue_thread
= ptid
;
2225 set_general_thread (ptid_t ptid
)
2227 set_thread (ptid
, 1);
2231 set_continue_thread (ptid_t ptid
)
2233 set_thread (ptid
, 0);
2236 /* Change the remote current process. Which thread within the process
2237 ends up selected isn't important, as long as it is the same process
2238 as what INFERIOR_PTID points to.
2240 This comes from that fact that there is no explicit notion of
2241 "selected process" in the protocol. The selected process for
2242 general operations is the process the selected general thread
2246 set_general_process (void)
2248 struct remote_state
*rs
= get_remote_state ();
2250 /* If the remote can't handle multiple processes, don't bother. */
2251 if (!remote_multi_process_p (rs
))
2254 /* We only need to change the remote current thread if it's pointing
2255 at some other process. */
2256 if (ptid_get_pid (rs
->general_thread
) != ptid_get_pid (inferior_ptid
))
2257 set_general_thread (inferior_ptid
);
2261 /* Return nonzero if this is the main thread that we made up ourselves
2262 to model non-threaded targets as single-threaded. */
2265 remote_thread_always_alive (struct target_ops
*ops
, ptid_t ptid
)
2267 if (ptid_equal (ptid
, magic_null_ptid
))
2268 /* The main thread is always alive. */
2271 if (ptid_get_pid (ptid
) != 0 && ptid_get_lwp (ptid
) == 0)
2272 /* The main thread is always alive. This can happen after a
2273 vAttach, if the remote side doesn't support
2280 /* Return nonzero if the thread PTID is still alive on the remote
2284 remote_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
2286 struct remote_state
*rs
= get_remote_state ();
2289 /* Check if this is a thread that we made up ourselves to model
2290 non-threaded targets as single-threaded. */
2291 if (remote_thread_always_alive (ops
, ptid
))
2295 endp
= rs
->buf
+ get_remote_packet_size ();
2298 write_ptid (p
, endp
, ptid
);
2301 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2302 return (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K');
2305 /* Return a pointer to a thread name if we know it and NULL otherwise.
2306 The thread_info object owns the memory for the name. */
2309 remote_thread_name (struct target_ops
*ops
, struct thread_info
*info
)
2311 if (info
->priv
!= NULL
)
2312 return info
->priv
->name
;
2317 /* About these extended threadlist and threadinfo packets. They are
2318 variable length packets but, the fields within them are often fixed
2319 length. They are redundent enough to send over UDP as is the
2320 remote protocol in general. There is a matching unit test module
2323 /* WARNING: This threadref data structure comes from the remote O.S.,
2324 libstub protocol encoding, and remote.c. It is not particularly
2327 /* Right now, the internal structure is int. We want it to be bigger.
2328 Plan to fix this. */
2330 typedef int gdb_threadref
; /* Internal GDB thread reference. */
2332 /* gdb_ext_thread_info is an internal GDB data structure which is
2333 equivalent to the reply of the remote threadinfo packet. */
2335 struct gdb_ext_thread_info
2337 threadref threadid
; /* External form of thread reference. */
2338 int active
; /* Has state interesting to GDB?
2340 char display
[256]; /* Brief state display, name,
2341 blocked/suspended. */
2342 char shortname
[32]; /* To be used to name threads. */
2343 char more_display
[256]; /* Long info, statistics, queue depth,
2347 /* The volume of remote transfers can be limited by submitting
2348 a mask containing bits specifying the desired information.
2349 Use a union of these values as the 'selection' parameter to
2350 get_thread_info. FIXME: Make these TAG names more thread specific. */
2352 #define TAG_THREADID 1
2353 #define TAG_EXISTS 2
2354 #define TAG_DISPLAY 4
2355 #define TAG_THREADNAME 8
2356 #define TAG_MOREDISPLAY 16
2358 #define BUF_THREAD_ID_SIZE (OPAQUETHREADBYTES * 2)
2360 static char *unpack_nibble (char *buf
, int *val
);
2362 static char *unpack_byte (char *buf
, int *value
);
2364 static char *pack_int (char *buf
, int value
);
2366 static char *unpack_int (char *buf
, int *value
);
2368 static char *unpack_string (char *src
, char *dest
, int length
);
2370 static char *pack_threadid (char *pkt
, threadref
*id
);
2372 static char *unpack_threadid (char *inbuf
, threadref
*id
);
2374 void int_to_threadref (threadref
*id
, int value
);
2376 static int threadref_to_int (threadref
*ref
);
2378 static void copy_threadref (threadref
*dest
, threadref
*src
);
2380 static int threadmatch (threadref
*dest
, threadref
*src
);
2382 static char *pack_threadinfo_request (char *pkt
, int mode
,
2385 static int remote_unpack_thread_info_response (char *pkt
,
2386 threadref
*expectedref
,
2387 struct gdb_ext_thread_info
2391 static int remote_get_threadinfo (threadref
*threadid
,
2392 int fieldset
, /*TAG mask */
2393 struct gdb_ext_thread_info
*info
);
2395 static char *pack_threadlist_request (char *pkt
, int startflag
,
2397 threadref
*nextthread
);
2399 static int parse_threadlist_response (char *pkt
,
2401 threadref
*original_echo
,
2402 threadref
*resultlist
,
2405 static int remote_get_threadlist (int startflag
,
2406 threadref
*nextthread
,
2410 threadref
*threadlist
);
2412 typedef int (*rmt_thread_action
) (threadref
*ref
, void *context
);
2414 static int remote_threadlist_iterator (rmt_thread_action stepfunction
,
2415 void *context
, int looplimit
);
2417 static int remote_newthread_step (threadref
*ref
, void *context
);
2420 /* Write a PTID to BUF. ENDBUF points to one-passed-the-end of the
2421 buffer we're allowed to write to. Returns
2422 BUF+CHARACTERS_WRITTEN. */
2425 write_ptid (char *buf
, const char *endbuf
, ptid_t ptid
)
2428 struct remote_state
*rs
= get_remote_state ();
2430 if (remote_multi_process_p (rs
))
2432 pid
= ptid_get_pid (ptid
);
2434 buf
+= xsnprintf (buf
, endbuf
- buf
, "p-%x.", -pid
);
2436 buf
+= xsnprintf (buf
, endbuf
- buf
, "p%x.", pid
);
2438 tid
= ptid_get_lwp (ptid
);
2440 buf
+= xsnprintf (buf
, endbuf
- buf
, "-%x", -tid
);
2442 buf
+= xsnprintf (buf
, endbuf
- buf
, "%x", tid
);
2447 /* Extract a PTID from BUF. If non-null, OBUF is set to the to one
2448 passed the last parsed char. Returns null_ptid on error. */
2451 read_ptid (char *buf
, char **obuf
)
2455 ULONGEST pid
= 0, tid
= 0;
2459 /* Multi-process ptid. */
2460 pp
= unpack_varlen_hex (p
+ 1, &pid
);
2462 error (_("invalid remote ptid: %s"), p
);
2465 pp
= unpack_varlen_hex (p
+ 1, &tid
);
2468 return ptid_build (pid
, tid
, 0);
2471 /* No multi-process. Just a tid. */
2472 pp
= unpack_varlen_hex (p
, &tid
);
2474 /* Return null_ptid when no thread id is found. */
2482 /* Since the stub is not sending a process id, then default to
2483 what's in inferior_ptid, unless it's null at this point. If so,
2484 then since there's no way to know the pid of the reported
2485 threads, use the magic number. */
2486 if (ptid_equal (inferior_ptid
, null_ptid
))
2487 pid
= ptid_get_pid (magic_null_ptid
);
2489 pid
= ptid_get_pid (inferior_ptid
);
2493 return ptid_build (pid
, tid
, 0);
2499 if (ch
>= 'a' && ch
<= 'f')
2500 return ch
- 'a' + 10;
2501 if (ch
>= '0' && ch
<= '9')
2503 if (ch
>= 'A' && ch
<= 'F')
2504 return ch
- 'A' + 10;
2509 stub_unpack_int (char *buff
, int fieldlength
)
2516 nibble
= stubhex (*buff
++);
2520 retval
= retval
<< 4;
2526 unpack_nibble (char *buf
, int *val
)
2528 *val
= fromhex (*buf
++);
2533 unpack_byte (char *buf
, int *value
)
2535 *value
= stub_unpack_int (buf
, 2);
2540 pack_int (char *buf
, int value
)
2542 buf
= pack_hex_byte (buf
, (value
>> 24) & 0xff);
2543 buf
= pack_hex_byte (buf
, (value
>> 16) & 0xff);
2544 buf
= pack_hex_byte (buf
, (value
>> 8) & 0x0ff);
2545 buf
= pack_hex_byte (buf
, (value
& 0xff));
2550 unpack_int (char *buf
, int *value
)
2552 *value
= stub_unpack_int (buf
, 8);
2556 #if 0 /* Currently unused, uncomment when needed. */
2557 static char *pack_string (char *pkt
, char *string
);
2560 pack_string (char *pkt
, char *string
)
2565 len
= strlen (string
);
2567 len
= 200; /* Bigger than most GDB packets, junk??? */
2568 pkt
= pack_hex_byte (pkt
, len
);
2572 if ((ch
== '\0') || (ch
== '#'))
2573 ch
= '*'; /* Protect encapsulation. */
2578 #endif /* 0 (unused) */
2581 unpack_string (char *src
, char *dest
, int length
)
2590 pack_threadid (char *pkt
, threadref
*id
)
2593 unsigned char *altid
;
2595 altid
= (unsigned char *) id
;
2596 limit
= pkt
+ BUF_THREAD_ID_SIZE
;
2598 pkt
= pack_hex_byte (pkt
, *altid
++);
2604 unpack_threadid (char *inbuf
, threadref
*id
)
2607 char *limit
= inbuf
+ BUF_THREAD_ID_SIZE
;
2610 altref
= (char *) id
;
2612 while (inbuf
< limit
)
2614 x
= stubhex (*inbuf
++);
2615 y
= stubhex (*inbuf
++);
2616 *altref
++ = (x
<< 4) | y
;
2621 /* Externally, threadrefs are 64 bits but internally, they are still
2622 ints. This is due to a mismatch of specifications. We would like
2623 to use 64bit thread references internally. This is an adapter
2627 int_to_threadref (threadref
*id
, int value
)
2629 unsigned char *scan
;
2631 scan
= (unsigned char *) id
;
2637 *scan
++ = (value
>> 24) & 0xff;
2638 *scan
++ = (value
>> 16) & 0xff;
2639 *scan
++ = (value
>> 8) & 0xff;
2640 *scan
++ = (value
& 0xff);
2644 threadref_to_int (threadref
*ref
)
2647 unsigned char *scan
;
2653 value
= (value
<< 8) | ((*scan
++) & 0xff);
2658 copy_threadref (threadref
*dest
, threadref
*src
)
2661 unsigned char *csrc
, *cdest
;
2663 csrc
= (unsigned char *) src
;
2664 cdest
= (unsigned char *) dest
;
2671 threadmatch (threadref
*dest
, threadref
*src
)
2673 /* Things are broken right now, so just assume we got a match. */
2675 unsigned char *srcp
, *destp
;
2677 srcp
= (char *) src
;
2678 destp
= (char *) dest
;
2682 result
&= (*srcp
++ == *destp
++) ? 1 : 0;
2689 threadid:1, # always request threadid
2696 /* Encoding: 'Q':8,'P':8,mask:32,threadid:64 */
2699 pack_threadinfo_request (char *pkt
, int mode
, threadref
*id
)
2701 *pkt
++ = 'q'; /* Info Query */
2702 *pkt
++ = 'P'; /* process or thread info */
2703 pkt
= pack_int (pkt
, mode
); /* mode */
2704 pkt
= pack_threadid (pkt
, id
); /* threadid */
2705 *pkt
= '\0'; /* terminate */
2709 /* These values tag the fields in a thread info response packet. */
2710 /* Tagging the fields allows us to request specific fields and to
2711 add more fields as time goes by. */
2713 #define TAG_THREADID 1 /* Echo the thread identifier. */
2714 #define TAG_EXISTS 2 /* Is this process defined enough to
2715 fetch registers and its stack? */
2716 #define TAG_DISPLAY 4 /* A short thing maybe to put on a window */
2717 #define TAG_THREADNAME 8 /* string, maps 1-to-1 with a thread is. */
2718 #define TAG_MOREDISPLAY 16 /* Whatever the kernel wants to say about
2722 remote_unpack_thread_info_response (char *pkt
, threadref
*expectedref
,
2723 struct gdb_ext_thread_info
*info
)
2725 struct remote_state
*rs
= get_remote_state ();
2729 char *limit
= pkt
+ rs
->buf_size
; /* Plausible parsing limit. */
2732 /* info->threadid = 0; FIXME: implement zero_threadref. */
2734 info
->display
[0] = '\0';
2735 info
->shortname
[0] = '\0';
2736 info
->more_display
[0] = '\0';
2738 /* Assume the characters indicating the packet type have been
2740 pkt
= unpack_int (pkt
, &mask
); /* arg mask */
2741 pkt
= unpack_threadid (pkt
, &ref
);
2744 warning (_("Incomplete response to threadinfo request."));
2745 if (!threadmatch (&ref
, expectedref
))
2746 { /* This is an answer to a different request. */
2747 warning (_("ERROR RMT Thread info mismatch."));
2750 copy_threadref (&info
->threadid
, &ref
);
2752 /* Loop on tagged fields , try to bail if somthing goes wrong. */
2754 /* Packets are terminated with nulls. */
2755 while ((pkt
< limit
) && mask
&& *pkt
)
2757 pkt
= unpack_int (pkt
, &tag
); /* tag */
2758 pkt
= unpack_byte (pkt
, &length
); /* length */
2759 if (!(tag
& mask
)) /* Tags out of synch with mask. */
2761 warning (_("ERROR RMT: threadinfo tag mismatch."));
2765 if (tag
== TAG_THREADID
)
2769 warning (_("ERROR RMT: length of threadid is not 16."));
2773 pkt
= unpack_threadid (pkt
, &ref
);
2774 mask
= mask
& ~TAG_THREADID
;
2777 if (tag
== TAG_EXISTS
)
2779 info
->active
= stub_unpack_int (pkt
, length
);
2781 mask
= mask
& ~(TAG_EXISTS
);
2784 warning (_("ERROR RMT: 'exists' length too long."));
2790 if (tag
== TAG_THREADNAME
)
2792 pkt
= unpack_string (pkt
, &info
->shortname
[0], length
);
2793 mask
= mask
& ~TAG_THREADNAME
;
2796 if (tag
== TAG_DISPLAY
)
2798 pkt
= unpack_string (pkt
, &info
->display
[0], length
);
2799 mask
= mask
& ~TAG_DISPLAY
;
2802 if (tag
== TAG_MOREDISPLAY
)
2804 pkt
= unpack_string (pkt
, &info
->more_display
[0], length
);
2805 mask
= mask
& ~TAG_MOREDISPLAY
;
2808 warning (_("ERROR RMT: unknown thread info tag."));
2809 break; /* Not a tag we know about. */
2815 remote_get_threadinfo (threadref
*threadid
, int fieldset
, /* TAG mask */
2816 struct gdb_ext_thread_info
*info
)
2818 struct remote_state
*rs
= get_remote_state ();
2821 pack_threadinfo_request (rs
->buf
, fieldset
, threadid
);
2823 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2825 if (rs
->buf
[0] == '\0')
2828 result
= remote_unpack_thread_info_response (rs
->buf
+ 2,
2833 /* Format: i'Q':8,i"L":8,initflag:8,batchsize:16,lastthreadid:32 */
2836 pack_threadlist_request (char *pkt
, int startflag
, int threadcount
,
2837 threadref
*nextthread
)
2839 *pkt
++ = 'q'; /* info query packet */
2840 *pkt
++ = 'L'; /* Process LIST or threadLIST request */
2841 pkt
= pack_nibble (pkt
, startflag
); /* initflag 1 bytes */
2842 pkt
= pack_hex_byte (pkt
, threadcount
); /* threadcount 2 bytes */
2843 pkt
= pack_threadid (pkt
, nextthread
); /* 64 bit thread identifier */
2848 /* Encoding: 'q':8,'M':8,count:16,done:8,argthreadid:64,(threadid:64)* */
2851 parse_threadlist_response (char *pkt
, int result_limit
,
2852 threadref
*original_echo
, threadref
*resultlist
,
2855 struct remote_state
*rs
= get_remote_state ();
2857 int count
, resultcount
, done
;
2860 /* Assume the 'q' and 'M chars have been stripped. */
2861 limit
= pkt
+ (rs
->buf_size
- BUF_THREAD_ID_SIZE
);
2862 /* done parse past here */
2863 pkt
= unpack_byte (pkt
, &count
); /* count field */
2864 pkt
= unpack_nibble (pkt
, &done
);
2865 /* The first threadid is the argument threadid. */
2866 pkt
= unpack_threadid (pkt
, original_echo
); /* should match query packet */
2867 while ((count
-- > 0) && (pkt
< limit
))
2869 pkt
= unpack_threadid (pkt
, resultlist
++);
2870 if (resultcount
++ >= result_limit
)
2878 /* Fetch the next batch of threads from the remote. Returns -1 if the
2879 qL packet is not supported, 0 on error and 1 on success. */
2882 remote_get_threadlist (int startflag
, threadref
*nextthread
, int result_limit
,
2883 int *done
, int *result_count
, threadref
*threadlist
)
2885 struct remote_state
*rs
= get_remote_state ();
2888 /* Trancate result limit to be smaller than the packet size. */
2889 if ((((result_limit
+ 1) * BUF_THREAD_ID_SIZE
) + 10)
2890 >= get_remote_packet_size ())
2891 result_limit
= (get_remote_packet_size () / BUF_THREAD_ID_SIZE
) - 2;
2893 pack_threadlist_request (rs
->buf
, startflag
, result_limit
, nextthread
);
2895 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
2896 if (*rs
->buf
== '\0')
2898 /* Packet not supported. */
2903 parse_threadlist_response (rs
->buf
+ 2, result_limit
,
2904 &rs
->echo_nextthread
, threadlist
, done
);
2906 if (!threadmatch (&rs
->echo_nextthread
, nextthread
))
2908 /* FIXME: This is a good reason to drop the packet. */
2909 /* Possably, there is a duplicate response. */
2911 retransmit immediatly - race conditions
2912 retransmit after timeout - yes
2914 wait for packet, then exit
2916 warning (_("HMM: threadlist did not echo arg thread, dropping it."));
2917 return 0; /* I choose simply exiting. */
2919 if (*result_count
<= 0)
2923 warning (_("RMT ERROR : failed to get remote thread list."));
2926 return result
; /* break; */
2928 if (*result_count
> result_limit
)
2931 warning (_("RMT ERROR: threadlist response longer than requested."));
2937 /* Fetch the list of remote threads, with the qL packet, and call
2938 STEPFUNCTION for each thread found. Stops iterating and returns 1
2939 if STEPFUNCTION returns true. Stops iterating and returns 0 if the
2940 STEPFUNCTION returns false. If the packet is not supported,
2944 remote_threadlist_iterator (rmt_thread_action stepfunction
, void *context
,
2947 struct remote_state
*rs
= get_remote_state ();
2948 int done
, i
, result_count
;
2956 if (loopcount
++ > looplimit
)
2959 warning (_("Remote fetch threadlist -infinite loop-."));
2962 result
= remote_get_threadlist (startflag
, &rs
->nextthread
,
2963 MAXTHREADLISTRESULTS
,
2964 &done
, &result_count
,
2965 rs
->resultthreadlist
);
2968 /* Clear for later iterations. */
2970 /* Setup to resume next batch of thread references, set nextthread. */
2971 if (result_count
>= 1)
2972 copy_threadref (&rs
->nextthread
,
2973 &rs
->resultthreadlist
[result_count
- 1]);
2975 while (result_count
--)
2977 if (!(*stepfunction
) (&rs
->resultthreadlist
[i
++], context
))
2987 /* A thread found on the remote target. */
2989 typedef struct thread_item
2991 /* The thread's PTID. */
2994 /* The thread's extra info. May be NULL. */
2997 /* The thread's name. May be NULL. */
3000 /* The core the thread was running on. -1 if not known. */
3003 DEF_VEC_O(thread_item_t
);
3005 /* Context passed around to the various methods listing remote
3006 threads. As new threads are found, they're added to the ITEMS
3009 struct threads_listing_context
3011 /* The threads found on the remote target. */
3012 VEC (thread_item_t
) *items
;
3015 /* Discard the contents of the constructed thread listing context. */
3018 clear_threads_listing_context (void *p
)
3020 struct threads_listing_context
*context
3021 = (struct threads_listing_context
*) p
;
3023 struct thread_item
*item
;
3025 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3027 xfree (item
->extra
);
3031 VEC_free (thread_item_t
, context
->items
);
3034 /* Remove the thread specified as the related_pid field of WS
3035 from the CONTEXT list. */
3038 threads_listing_context_remove (struct target_waitstatus
*ws
,
3039 struct threads_listing_context
*context
)
3041 struct thread_item
*item
;
3043 ptid_t child_ptid
= ws
->value
.related_pid
;
3045 for (i
= 0; VEC_iterate (thread_item_t
, context
->items
, i
, item
); ++i
)
3047 if (ptid_equal (item
->ptid
, child_ptid
))
3049 VEC_ordered_remove (thread_item_t
, context
->items
, i
);
3056 remote_newthread_step (threadref
*ref
, void *data
)
3058 struct threads_listing_context
*context
3059 = (struct threads_listing_context
*) data
;
3060 struct thread_item item
;
3061 int pid
= ptid_get_pid (inferior_ptid
);
3063 item
.ptid
= ptid_build (pid
, threadref_to_int (ref
), 0);
3068 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3070 return 1; /* continue iterator */
3073 #define CRAZY_MAX_THREADS 1000
3076 remote_current_thread (ptid_t oldpid
)
3078 struct remote_state
*rs
= get_remote_state ();
3081 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3082 if (rs
->buf
[0] == 'Q' && rs
->buf
[1] == 'C')
3087 result
= read_ptid (&rs
->buf
[2], &obuf
);
3088 if (*obuf
!= '\0' && remote_debug
)
3089 fprintf_unfiltered (gdb_stdlog
,
3090 "warning: garbage in qC reply\n");
3098 /* List remote threads using the deprecated qL packet. */
3101 remote_get_threads_with_ql (struct target_ops
*ops
,
3102 struct threads_listing_context
*context
)
3104 if (remote_threadlist_iterator (remote_newthread_step
, context
,
3105 CRAZY_MAX_THREADS
) >= 0)
3111 #if defined(HAVE_LIBEXPAT)
3114 start_thread (struct gdb_xml_parser
*parser
,
3115 const struct gdb_xml_element
*element
,
3116 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
3118 struct threads_listing_context
*data
3119 = (struct threads_listing_context
*) user_data
;
3121 struct thread_item item
;
3123 struct gdb_xml_value
*attr
;
3125 id
= (char *) xml_find_attribute (attributes
, "id")->value
;
3126 item
.ptid
= read_ptid (id
, NULL
);
3128 attr
= xml_find_attribute (attributes
, "core");
3130 item
.core
= *(ULONGEST
*) attr
->value
;
3134 attr
= xml_find_attribute (attributes
, "name");
3135 item
.name
= attr
!= NULL
? xstrdup ((const char *) attr
->value
) : NULL
;
3139 VEC_safe_push (thread_item_t
, data
->items
, &item
);
3143 end_thread (struct gdb_xml_parser
*parser
,
3144 const struct gdb_xml_element
*element
,
3145 void *user_data
, const char *body_text
)
3147 struct threads_listing_context
*data
3148 = (struct threads_listing_context
*) user_data
;
3150 if (body_text
&& *body_text
)
3151 VEC_last (thread_item_t
, data
->items
)->extra
= xstrdup (body_text
);
3154 const struct gdb_xml_attribute thread_attributes
[] = {
3155 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
3156 { "core", GDB_XML_AF_OPTIONAL
, gdb_xml_parse_attr_ulongest
, NULL
},
3157 { "name", GDB_XML_AF_OPTIONAL
, NULL
, NULL
},
3158 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
3161 const struct gdb_xml_element thread_children
[] = {
3162 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3165 const struct gdb_xml_element threads_children
[] = {
3166 { "thread", thread_attributes
, thread_children
,
3167 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
3168 start_thread
, end_thread
},
3169 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3172 const struct gdb_xml_element threads_elements
[] = {
3173 { "threads", NULL
, threads_children
,
3174 GDB_XML_EF_NONE
, NULL
, NULL
},
3175 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
3180 /* List remote threads using qXfer:threads:read. */
3183 remote_get_threads_with_qxfer (struct target_ops
*ops
,
3184 struct threads_listing_context
*context
)
3186 #if defined(HAVE_LIBEXPAT)
3187 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3189 char *xml
= target_read_stralloc (ops
, TARGET_OBJECT_THREADS
, NULL
);
3190 struct cleanup
*back_to
= make_cleanup (xfree
, xml
);
3192 if (xml
!= NULL
&& *xml
!= '\0')
3194 gdb_xml_parse_quick (_("threads"), "threads.dtd",
3195 threads_elements
, xml
, context
);
3198 do_cleanups (back_to
);
3206 /* List remote threads using qfThreadInfo/qsThreadInfo. */
3209 remote_get_threads_with_qthreadinfo (struct target_ops
*ops
,
3210 struct threads_listing_context
*context
)
3212 struct remote_state
*rs
= get_remote_state ();
3214 if (rs
->use_threadinfo_query
)
3218 putpkt ("qfThreadInfo");
3219 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3221 if (bufp
[0] != '\0') /* q packet recognized */
3223 while (*bufp
++ == 'm') /* reply contains one or more TID */
3227 struct thread_item item
;
3229 item
.ptid
= read_ptid (bufp
, &bufp
);
3234 VEC_safe_push (thread_item_t
, context
->items
, &item
);
3236 while (*bufp
++ == ','); /* comma-separated list */
3237 putpkt ("qsThreadInfo");
3238 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3245 /* Packet not recognized. */
3246 rs
->use_threadinfo_query
= 0;
3253 /* Implement the to_update_thread_list function for the remote
3257 remote_update_thread_list (struct target_ops
*ops
)
3259 struct threads_listing_context context
;
3260 struct cleanup
*old_chain
;
3263 context
.items
= NULL
;
3264 old_chain
= make_cleanup (clear_threads_listing_context
, &context
);
3266 /* We have a few different mechanisms to fetch the thread list. Try
3267 them all, starting with the most preferred one first, falling
3268 back to older methods. */
3269 if (remote_get_threads_with_qxfer (ops
, &context
)
3270 || remote_get_threads_with_qthreadinfo (ops
, &context
)
3271 || remote_get_threads_with_ql (ops
, &context
))
3274 struct thread_item
*item
;
3275 struct thread_info
*tp
, *tmp
;
3279 if (VEC_empty (thread_item_t
, context
.items
)
3280 && remote_thread_always_alive (ops
, inferior_ptid
))
3282 /* Some targets don't really support threads, but still
3283 reply an (empty) thread list in response to the thread
3284 listing packets, instead of replying "packet not
3285 supported". Exit early so we don't delete the main
3287 do_cleanups (old_chain
);
3291 /* CONTEXT now holds the current thread list on the remote
3292 target end. Delete GDB-side threads no longer found on the
3294 ALL_THREADS_SAFE (tp
, tmp
)
3297 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3300 if (ptid_equal (item
->ptid
, tp
->ptid
))
3304 if (i
== VEC_length (thread_item_t
, context
.items
))
3307 delete_thread (tp
->ptid
);
3311 /* Remove any unreported fork child threads from CONTEXT so
3312 that we don't interfere with follow fork, which is where
3313 creation of such threads is handled. */
3314 remove_new_fork_children (&context
);
3316 /* And now add threads we don't know about yet to our list. */
3318 VEC_iterate (thread_item_t
, context
.items
, i
, item
);
3321 if (!ptid_equal (item
->ptid
, null_ptid
))
3323 struct private_thread_info
*info
;
3324 /* In non-stop mode, we assume new found threads are
3325 executing until proven otherwise with a stop reply.
3326 In all-stop, we can only get here if all threads are
3328 int executing
= target_is_non_stop_p () ? 1 : 0;
3330 remote_notice_new_inferior (item
->ptid
, executing
);
3332 info
= get_private_info_ptid (item
->ptid
);
3333 info
->core
= item
->core
;
3334 info
->extra
= item
->extra
;
3336 info
->name
= item
->name
;
3344 /* If no thread listing method is supported, then query whether
3345 each known thread is alive, one by one, with the T packet.
3346 If the target doesn't support threads at all, then this is a
3347 no-op. See remote_thread_alive. */
3351 do_cleanups (old_chain
);
3355 * Collect a descriptive string about the given thread.
3356 * The target may say anything it wants to about the thread
3357 * (typically info about its blocked / runnable state, name, etc.).
3358 * This string will appear in the info threads display.
3360 * Optional: targets are not required to implement this function.
3364 remote_threads_extra_info (struct target_ops
*self
, struct thread_info
*tp
)
3366 struct remote_state
*rs
= get_remote_state ();
3370 struct gdb_ext_thread_info threadinfo
;
3371 static char display_buf
[100]; /* arbitrary... */
3372 int n
= 0; /* position in display_buf */
3374 if (rs
->remote_desc
== 0) /* paranoia */
3375 internal_error (__FILE__
, __LINE__
,
3376 _("remote_threads_extra_info"));
3378 if (ptid_equal (tp
->ptid
, magic_null_ptid
)
3379 || (ptid_get_pid (tp
->ptid
) != 0 && ptid_get_lwp (tp
->ptid
) == 0))
3380 /* This is the main thread which was added by GDB. The remote
3381 server doesn't know about it. */
3384 if (packet_support (PACKET_qXfer_threads
) == PACKET_ENABLE
)
3386 struct thread_info
*info
= find_thread_ptid (tp
->ptid
);
3388 if (info
&& info
->priv
)
3389 return info
->priv
->extra
;
3394 if (rs
->use_threadextra_query
)
3397 char *endb
= rs
->buf
+ get_remote_packet_size ();
3399 xsnprintf (b
, endb
- b
, "qThreadExtraInfo,");
3401 write_ptid (b
, endb
, tp
->ptid
);
3404 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3405 if (rs
->buf
[0] != 0)
3407 n
= std::min (strlen (rs
->buf
) / 2, sizeof (display_buf
));
3408 result
= hex2bin (rs
->buf
, (gdb_byte
*) display_buf
, n
);
3409 display_buf
[result
] = '\0';
3414 /* If the above query fails, fall back to the old method. */
3415 rs
->use_threadextra_query
= 0;
3416 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
3417 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
3418 int_to_threadref (&id
, ptid_get_lwp (tp
->ptid
));
3419 if (remote_get_threadinfo (&id
, set
, &threadinfo
))
3420 if (threadinfo
.active
)
3422 if (*threadinfo
.shortname
)
3423 n
+= xsnprintf (&display_buf
[0], sizeof (display_buf
) - n
,
3424 " Name: %s,", threadinfo
.shortname
);
3425 if (*threadinfo
.display
)
3426 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3427 " State: %s,", threadinfo
.display
);
3428 if (*threadinfo
.more_display
)
3429 n
+= xsnprintf (&display_buf
[n
], sizeof (display_buf
) - n
,
3430 " Priority: %s", threadinfo
.more_display
);
3434 /* For purely cosmetic reasons, clear up trailing commas. */
3435 if (',' == display_buf
[n
-1])
3436 display_buf
[n
-1] = ' ';
3445 remote_static_tracepoint_marker_at (struct target_ops
*self
, CORE_ADDR addr
,
3446 struct static_tracepoint_marker
*marker
)
3448 struct remote_state
*rs
= get_remote_state ();
3451 xsnprintf (p
, get_remote_packet_size (), "qTSTMat:");
3453 p
+= hexnumstr (p
, addr
);
3455 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3459 error (_("Remote failure reply: %s"), p
);
3463 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3470 static VEC(static_tracepoint_marker_p
) *
3471 remote_static_tracepoint_markers_by_strid (struct target_ops
*self
,
3474 struct remote_state
*rs
= get_remote_state ();
3475 VEC(static_tracepoint_marker_p
) *markers
= NULL
;
3476 struct static_tracepoint_marker
*marker
= NULL
;
3477 struct cleanup
*old_chain
;
3480 /* Ask for a first packet of static tracepoint marker
3483 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3486 error (_("Remote failure reply: %s"), p
);
3488 old_chain
= make_cleanup (free_current_marker
, &marker
);
3493 marker
= XCNEW (struct static_tracepoint_marker
);
3497 parse_static_tracepoint_marker_definition (p
, &p
, marker
);
3499 if (strid
== NULL
|| strcmp (strid
, marker
->str_id
) == 0)
3501 VEC_safe_push (static_tracepoint_marker_p
,
3507 release_static_tracepoint_marker (marker
);
3508 memset (marker
, 0, sizeof (*marker
));
3511 while (*p
++ == ','); /* comma-separated list */
3512 /* Ask for another packet of static tracepoint definition. */
3514 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3518 do_cleanups (old_chain
);
3523 /* Implement the to_get_ada_task_ptid function for the remote targets. */
3526 remote_get_ada_task_ptid (struct target_ops
*self
, long lwp
, long thread
)
3528 return ptid_build (ptid_get_pid (inferior_ptid
), lwp
, 0);
3532 /* Restart the remote side; this is an extended protocol operation. */
3535 extended_remote_restart (void)
3537 struct remote_state
*rs
= get_remote_state ();
3539 /* Send the restart command; for reasons I don't understand the
3540 remote side really expects a number after the "R". */
3541 xsnprintf (rs
->buf
, get_remote_packet_size (), "R%x", 0);
3544 remote_fileio_reset ();
3547 /* Clean up connection to a remote debugger. */
3550 remote_close (struct target_ops
*self
)
3552 struct remote_state
*rs
= get_remote_state ();
3554 if (rs
->remote_desc
== NULL
)
3555 return; /* already closed */
3557 /* Make sure we leave stdin registered in the event loop. */
3558 remote_terminal_ours (self
);
3560 serial_close (rs
->remote_desc
);
3561 rs
->remote_desc
= NULL
;
3563 /* We don't have a connection to the remote stub anymore. Get rid
3564 of all the inferiors and their threads we were controlling.
3565 Reset inferior_ptid to null_ptid first, as otherwise has_stack_frame
3566 will be unable to find the thread corresponding to (pid, 0, 0). */
3567 inferior_ptid
= null_ptid
;
3568 discard_all_inferiors ();
3570 /* We are closing the remote target, so we should discard
3571 everything of this target. */
3572 discard_pending_stop_replies_in_queue (rs
);
3574 if (remote_async_inferior_event_token
)
3575 delete_async_event_handler (&remote_async_inferior_event_token
);
3577 remote_notif_state_xfree (rs
->notif_state
);
3579 trace_reset_local_state ();
3582 /* Query the remote side for the text, data and bss offsets. */
3587 struct remote_state
*rs
= get_remote_state ();
3590 int lose
, num_segments
= 0, do_sections
, do_segments
;
3591 CORE_ADDR text_addr
, data_addr
, bss_addr
, segments
[2];
3592 struct section_offsets
*offs
;
3593 struct symfile_segment_data
*data
;
3595 if (symfile_objfile
== NULL
)
3598 putpkt ("qOffsets");
3599 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
3602 if (buf
[0] == '\000')
3603 return; /* Return silently. Stub doesn't support
3607 warning (_("Remote failure reply: %s"), buf
);
3611 /* Pick up each field in turn. This used to be done with scanf, but
3612 scanf will make trouble if CORE_ADDR size doesn't match
3613 conversion directives correctly. The following code will work
3614 with any size of CORE_ADDR. */
3615 text_addr
= data_addr
= bss_addr
= 0;
3619 if (startswith (ptr
, "Text="))
3622 /* Don't use strtol, could lose on big values. */
3623 while (*ptr
&& *ptr
!= ';')
3624 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3626 if (startswith (ptr
, ";Data="))
3629 while (*ptr
&& *ptr
!= ';')
3630 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3635 if (!lose
&& startswith (ptr
, ";Bss="))
3638 while (*ptr
&& *ptr
!= ';')
3639 bss_addr
= (bss_addr
<< 4) + fromhex (*ptr
++);
3641 if (bss_addr
!= data_addr
)
3642 warning (_("Target reported unsupported offsets: %s"), buf
);
3647 else if (startswith (ptr
, "TextSeg="))
3650 /* Don't use strtol, could lose on big values. */
3651 while (*ptr
&& *ptr
!= ';')
3652 text_addr
= (text_addr
<< 4) + fromhex (*ptr
++);
3655 if (startswith (ptr
, ";DataSeg="))
3658 while (*ptr
&& *ptr
!= ';')
3659 data_addr
= (data_addr
<< 4) + fromhex (*ptr
++);
3667 error (_("Malformed response to offset query, %s"), buf
);
3668 else if (*ptr
!= '\0')
3669 warning (_("Target reported unsupported offsets: %s"), buf
);
3671 offs
= ((struct section_offsets
*)
3672 alloca (SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
)));
3673 memcpy (offs
, symfile_objfile
->section_offsets
,
3674 SIZEOF_N_SECTION_OFFSETS (symfile_objfile
->num_sections
));
3676 data
= get_symfile_segment_data (symfile_objfile
->obfd
);
3677 do_segments
= (data
!= NULL
);
3678 do_sections
= num_segments
== 0;
3680 if (num_segments
> 0)
3682 segments
[0] = text_addr
;
3683 segments
[1] = data_addr
;
3685 /* If we have two segments, we can still try to relocate everything
3686 by assuming that the .text and .data offsets apply to the whole
3687 text and data segments. Convert the offsets given in the packet
3688 to base addresses for symfile_map_offsets_to_segments. */
3689 else if (data
&& data
->num_segments
== 2)
3691 segments
[0] = data
->segment_bases
[0] + text_addr
;
3692 segments
[1] = data
->segment_bases
[1] + data_addr
;
3695 /* If the object file has only one segment, assume that it is text
3696 rather than data; main programs with no writable data are rare,
3697 but programs with no code are useless. Of course the code might
3698 have ended up in the data segment... to detect that we would need
3699 the permissions here. */
3700 else if (data
&& data
->num_segments
== 1)
3702 segments
[0] = data
->segment_bases
[0] + text_addr
;
3705 /* There's no way to relocate by segment. */
3711 int ret
= symfile_map_offsets_to_segments (symfile_objfile
->obfd
, data
,
3712 offs
, num_segments
, segments
);
3714 if (ret
== 0 && !do_sections
)
3715 error (_("Can not handle qOffsets TextSeg "
3716 "response with this symbol file"));
3723 free_symfile_segment_data (data
);
3727 offs
->offsets
[SECT_OFF_TEXT (symfile_objfile
)] = text_addr
;
3729 /* This is a temporary kludge to force data and bss to use the
3730 same offsets because that's what nlmconv does now. The real
3731 solution requires changes to the stub and remote.c that I
3732 don't have time to do right now. */
3734 offs
->offsets
[SECT_OFF_DATA (symfile_objfile
)] = data_addr
;
3735 offs
->offsets
[SECT_OFF_BSS (symfile_objfile
)] = data_addr
;
3738 objfile_relocate (symfile_objfile
, offs
);
3741 /* Send interrupt_sequence to remote target. */
3743 send_interrupt_sequence (void)
3745 struct remote_state
*rs
= get_remote_state ();
3747 if (interrupt_sequence_mode
== interrupt_sequence_control_c
)
3748 remote_serial_write ("\x03", 1);
3749 else if (interrupt_sequence_mode
== interrupt_sequence_break
)
3750 serial_send_break (rs
->remote_desc
);
3751 else if (interrupt_sequence_mode
== interrupt_sequence_break_g
)
3753 serial_send_break (rs
->remote_desc
);
3754 remote_serial_write ("g", 1);
3757 internal_error (__FILE__
, __LINE__
,
3758 _("Invalid value for interrupt_sequence_mode: %s."),
3759 interrupt_sequence_mode
);
3763 /* If STOP_REPLY is a T stop reply, look for the "thread" register,
3764 and extract the PTID. Returns NULL_PTID if not found. */
3767 stop_reply_extract_thread (char *stop_reply
)
3769 if (stop_reply
[0] == 'T' && strlen (stop_reply
) > 3)
3773 /* Txx r:val ; r:val (...) */
3776 /* Look for "register" named "thread". */
3781 p1
= strchr (p
, ':');
3785 if (strncmp (p
, "thread", p1
- p
) == 0)
3786 return read_ptid (++p1
, &p
);
3788 p1
= strchr (p
, ';');
3800 /* Determine the remote side's current thread. If we have a stop
3801 reply handy (in WAIT_STATUS), maybe it's a T stop reply with a
3802 "thread" register we can extract the current thread from. If not,
3803 ask the remote which is the current thread with qC. The former
3804 method avoids a roundtrip. */
3807 get_current_thread (char *wait_status
)
3809 ptid_t ptid
= null_ptid
;
3811 /* Note we don't use remote_parse_stop_reply as that makes use of
3812 the target architecture, which we haven't yet fully determined at
3814 if (wait_status
!= NULL
)
3815 ptid
= stop_reply_extract_thread (wait_status
);
3816 if (ptid_equal (ptid
, null_ptid
))
3817 ptid
= remote_current_thread (inferior_ptid
);
3822 /* Query the remote target for which is the current thread/process,
3823 add it to our tables, and update INFERIOR_PTID. The caller is
3824 responsible for setting the state such that the remote end is ready
3825 to return the current thread.
3827 This function is called after handling the '?' or 'vRun' packets,
3828 whose response is a stop reply from which we can also try
3829 extracting the thread. If the target doesn't support the explicit
3830 qC query, we infer the current thread from that stop reply, passed
3831 in in WAIT_STATUS, which may be NULL. */
3834 add_current_inferior_and_thread (char *wait_status
)
3836 struct remote_state
*rs
= get_remote_state ();
3839 inferior_ptid
= null_ptid
;
3841 /* Now, if we have thread information, update inferior_ptid. */
3842 ptid_t curr_ptid
= get_current_thread (wait_status
);
3844 if (curr_ptid
!= null_ptid
)
3846 if (!remote_multi_process_p (rs
))
3851 /* Without this, some commands which require an active target
3852 (such as kill) won't work. This variable serves (at least)
3853 double duty as both the pid of the target process (if it has
3854 such), and as a flag indicating that a target is active. */
3855 curr_ptid
= magic_null_ptid
;
3859 remote_add_inferior (fake_pid_p
, ptid_get_pid (curr_ptid
), -1, 1);
3861 /* Add the main thread and switch to it. Don't try reading
3862 registers yet, since we haven't fetched the target description
3864 thread_info
*tp
= add_thread_silent (curr_ptid
);
3865 switch_to_thread_no_regs (tp
);
3868 /* Print info about a thread that was found already stopped on
3872 print_one_stopped_thread (struct thread_info
*thread
)
3874 struct target_waitstatus
*ws
= &thread
->suspend
.waitstatus
;
3876 switch_to_thread (thread
->ptid
);
3877 stop_pc
= get_frame_pc (get_current_frame ());
3878 set_current_sal_from_frame (get_current_frame ());
3880 thread
->suspend
.waitstatus_pending_p
= 0;
3882 if (ws
->kind
== TARGET_WAITKIND_STOPPED
)
3884 enum gdb_signal sig
= ws
->value
.sig
;
3886 if (signal_print_state (sig
))
3887 observer_notify_signal_received (sig
);
3889 observer_notify_normal_stop (NULL
, 1);
3892 /* Process all initial stop replies the remote side sent in response
3893 to the ? packet. These indicate threads that were already stopped
3894 on initial connection. We mark these threads as stopped and print
3895 their current frame before giving the user the prompt. */
3898 process_initial_stop_replies (int from_tty
)
3900 int pending_stop_replies
= stop_reply_queue_length ();
3901 struct inferior
*inf
;
3902 struct thread_info
*thread
;
3903 struct thread_info
*selected
= NULL
;
3904 struct thread_info
*lowest_stopped
= NULL
;
3905 struct thread_info
*first
= NULL
;
3907 /* Consume the initial pending events. */
3908 while (pending_stop_replies
-- > 0)
3910 ptid_t waiton_ptid
= minus_one_ptid
;
3912 struct target_waitstatus ws
;
3913 int ignore_event
= 0;
3914 struct thread_info
*thread
;
3916 memset (&ws
, 0, sizeof (ws
));
3917 event_ptid
= target_wait (waiton_ptid
, &ws
, TARGET_WNOHANG
);
3919 print_target_wait_results (waiton_ptid
, event_ptid
, &ws
);
3923 case TARGET_WAITKIND_IGNORE
:
3924 case TARGET_WAITKIND_NO_RESUMED
:
3925 case TARGET_WAITKIND_SIGNALLED
:
3926 case TARGET_WAITKIND_EXITED
:
3927 /* We shouldn't see these, but if we do, just ignore. */
3929 fprintf_unfiltered (gdb_stdlog
, "remote: event ignored\n");
3933 case TARGET_WAITKIND_EXECD
:
3934 xfree (ws
.value
.execd_pathname
);
3943 thread
= find_thread_ptid (event_ptid
);
3945 if (ws
.kind
== TARGET_WAITKIND_STOPPED
)
3947 enum gdb_signal sig
= ws
.value
.sig
;
3949 /* Stubs traditionally report SIGTRAP as initial signal,
3950 instead of signal 0. Suppress it. */
3951 if (sig
== GDB_SIGNAL_TRAP
)
3953 thread
->suspend
.stop_signal
= sig
;
3957 thread
->suspend
.waitstatus
= ws
;
3959 if (ws
.kind
!= TARGET_WAITKIND_STOPPED
3960 || ws
.value
.sig
!= GDB_SIGNAL_0
)
3961 thread
->suspend
.waitstatus_pending_p
= 1;
3963 set_executing (event_ptid
, 0);
3964 set_running (event_ptid
, 0);
3965 thread
->priv
->vcont_resumed
= 0;
3968 /* "Notice" the new inferiors before anything related to
3969 registers/memory. */
3975 inf
->needs_setup
= 1;
3979 thread
= any_live_thread_of_process (inf
->pid
);
3980 notice_new_inferior (thread
->ptid
,
3981 thread
->state
== THREAD_RUNNING
,
3986 /* If all-stop on top of non-stop, pause all threads. Note this
3987 records the threads' stop pc, so must be done after "noticing"
3991 stop_all_threads ();
3993 /* If all threads of an inferior were already stopped, we
3994 haven't setup the inferior yet. */
4000 if (inf
->needs_setup
)
4002 thread
= any_live_thread_of_process (inf
->pid
);
4003 switch_to_thread_no_regs (thread
);
4009 /* Now go over all threads that are stopped, and print their current
4010 frame. If all-stop, then if there's a signalled thread, pick
4012 ALL_NON_EXITED_THREADS (thread
)
4018 set_running (thread
->ptid
, 0);
4019 else if (thread
->state
!= THREAD_STOPPED
)
4022 if (selected
== NULL
4023 && thread
->suspend
.waitstatus_pending_p
)
4026 if (lowest_stopped
== NULL
4027 || thread
->inf
->num
< lowest_stopped
->inf
->num
4028 || thread
->per_inf_num
< lowest_stopped
->per_inf_num
)
4029 lowest_stopped
= thread
;
4032 print_one_stopped_thread (thread
);
4035 /* In all-stop, we only print the status of one thread, and leave
4036 others with their status pending. */
4041 thread
= lowest_stopped
;
4045 print_one_stopped_thread (thread
);
4048 /* For "info program". */
4049 thread
= inferior_thread ();
4050 if (thread
->state
== THREAD_STOPPED
)
4051 set_last_target_status (inferior_ptid
, thread
->suspend
.waitstatus
);
4054 /* Start the remote connection and sync state. */
4057 remote_start_remote (int from_tty
, struct target_ops
*target
, int extended_p
)
4059 struct remote_state
*rs
= get_remote_state ();
4060 struct packet_config
*noack_config
;
4061 char *wait_status
= NULL
;
4063 /* Signal other parts that we're going through the initial setup,
4064 and so things may not be stable yet. E.g., we don't try to
4065 install tracepoints until we've relocated symbols. Also, a
4066 Ctrl-C before we're connected and synced up can't interrupt the
4067 target. Instead, it offers to drop the (potentially wedged)
4069 rs
->starting_up
= 1;
4073 if (interrupt_on_connect
)
4074 send_interrupt_sequence ();
4076 /* Ack any packet which the remote side has already sent. */
4077 remote_serial_write ("+", 1);
4079 /* The first packet we send to the target is the optional "supported
4080 packets" request. If the target can answer this, it will tell us
4081 which later probes to skip. */
4082 remote_query_supported ();
4084 /* If the stub wants to get a QAllow, compose one and send it. */
4085 if (packet_support (PACKET_QAllow
) != PACKET_DISABLE
)
4086 remote_set_permissions (target
);
4088 /* gdbserver < 7.7 (before its fix from 2013-12-11) did reply to any
4089 unknown 'v' packet with string "OK". "OK" gets interpreted by GDB
4090 as a reply to known packet. For packet "vFile:setfs:" it is an
4091 invalid reply and GDB would return error in
4092 remote_hostio_set_filesystem, making remote files access impossible.
4093 Disable "vFile:setfs:" in such case. Do not disable other 'v' packets as
4094 other "vFile" packets get correctly detected even on gdbserver < 7.7. */
4096 const char v_mustreplyempty
[] = "vMustReplyEmpty";
4098 putpkt (v_mustreplyempty
);
4099 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4100 if (strcmp (rs
->buf
, "OK") == 0)
4101 remote_protocol_packets
[PACKET_vFile_setfs
].support
= PACKET_DISABLE
;
4102 else if (strcmp (rs
->buf
, "") != 0)
4103 error (_("Remote replied unexpectedly to '%s': %s"), v_mustreplyempty
,
4107 /* Next, we possibly activate noack mode.
4109 If the QStartNoAckMode packet configuration is set to AUTO,
4110 enable noack mode if the stub reported a wish for it with
4113 If set to TRUE, then enable noack mode even if the stub didn't
4114 report it in qSupported. If the stub doesn't reply OK, the
4115 session ends with an error.
4117 If FALSE, then don't activate noack mode, regardless of what the
4118 stub claimed should be the default with qSupported. */
4120 noack_config
= &remote_protocol_packets
[PACKET_QStartNoAckMode
];
4121 if (packet_config_support (noack_config
) != PACKET_DISABLE
)
4123 putpkt ("QStartNoAckMode");
4124 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4125 if (packet_ok (rs
->buf
, noack_config
) == PACKET_OK
)
4131 /* Tell the remote that we are using the extended protocol. */
4133 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4136 /* Let the target know which signals it is allowed to pass down to
4138 update_signals_program_target ();
4140 /* Next, if the target can specify a description, read it. We do
4141 this before anything involving memory or registers. */
4142 target_find_description ();
4144 /* Next, now that we know something about the target, update the
4145 address spaces in the program spaces. */
4146 update_address_spaces ();
4148 /* On OSs where the list of libraries is global to all
4149 processes, we fetch them early. */
4150 if (gdbarch_has_global_solist (target_gdbarch ()))
4151 solib_add (NULL
, from_tty
, auto_solib_add
);
4153 if (target_is_non_stop_p ())
4155 if (packet_support (PACKET_QNonStop
) != PACKET_ENABLE
)
4156 error (_("Non-stop mode requested, but remote "
4157 "does not support non-stop"));
4159 putpkt ("QNonStop:1");
4160 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4162 if (strcmp (rs
->buf
, "OK") != 0)
4163 error (_("Remote refused setting non-stop mode with: %s"), rs
->buf
);
4165 /* Find about threads and processes the stub is already
4166 controlling. We default to adding them in the running state.
4167 The '?' query below will then tell us about which threads are
4169 remote_update_thread_list (target
);
4171 else if (packet_support (PACKET_QNonStop
) == PACKET_ENABLE
)
4173 /* Don't assume that the stub can operate in all-stop mode.
4174 Request it explicitly. */
4175 putpkt ("QNonStop:0");
4176 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4178 if (strcmp (rs
->buf
, "OK") != 0)
4179 error (_("Remote refused setting all-stop mode with: %s"), rs
->buf
);
4182 /* Upload TSVs regardless of whether the target is running or not. The
4183 remote stub, such as GDBserver, may have some predefined or builtin
4184 TSVs, even if the target is not running. */
4185 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4187 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4189 remote_upload_trace_state_variables (target
, &uploaded_tsvs
);
4190 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4193 /* Check whether the target is running now. */
4195 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4197 if (!target_is_non_stop_p ())
4199 if (rs
->buf
[0] == 'W' || rs
->buf
[0] == 'X')
4202 error (_("The target is not running (try extended-remote?)"));
4204 /* We're connected, but not running. Drop out before we
4205 call start_remote. */
4206 rs
->starting_up
= 0;
4211 /* Save the reply for later. */
4212 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
4213 strcpy (wait_status
, rs
->buf
);
4216 /* Fetch thread list. */
4217 target_update_thread_list ();
4219 /* Let the stub know that we want it to return the thread. */
4220 set_continue_thread (minus_one_ptid
);
4222 if (thread_count () == 0)
4224 /* Target has no concept of threads at all. GDB treats
4225 non-threaded target as single-threaded; add a main
4227 add_current_inferior_and_thread (wait_status
);
4231 /* We have thread information; select the thread the target
4232 says should be current. If we're reconnecting to a
4233 multi-threaded program, this will ideally be the thread
4234 that last reported an event before GDB disconnected. */
4235 inferior_ptid
= get_current_thread (wait_status
);
4236 if (ptid_equal (inferior_ptid
, null_ptid
))
4238 /* Odd... The target was able to list threads, but not
4239 tell us which thread was current (no "thread"
4240 register in T stop reply?). Just pick the first
4241 thread in the thread list then. */
4244 fprintf_unfiltered (gdb_stdlog
,
4245 "warning: couldn't determine remote "
4246 "current thread; picking first in list.\n");
4248 inferior_ptid
= thread_list
->ptid
;
4252 /* init_wait_for_inferior should be called before get_offsets in order
4253 to manage `inserted' flag in bp loc in a correct state.
4254 breakpoint_init_inferior, called from init_wait_for_inferior, set
4255 `inserted' flag to 0, while before breakpoint_re_set, called from
4256 start_remote, set `inserted' flag to 1. In the initialization of
4257 inferior, breakpoint_init_inferior should be called first, and then
4258 breakpoint_re_set can be called. If this order is broken, state of
4259 `inserted' flag is wrong, and cause some problems on breakpoint
4261 init_wait_for_inferior ();
4263 get_offsets (); /* Get text, data & bss offsets. */
4265 /* If we could not find a description using qXfer, and we know
4266 how to do it some other way, try again. This is not
4267 supported for non-stop; it could be, but it is tricky if
4268 there are no stopped threads when we connect. */
4269 if (remote_read_description_p (target
)
4270 && gdbarch_target_desc (target_gdbarch ()) == NULL
)
4272 target_clear_description ();
4273 target_find_description ();
4276 /* Use the previously fetched status. */
4277 gdb_assert (wait_status
!= NULL
);
4278 strcpy (rs
->buf
, wait_status
);
4279 rs
->cached_wait_status
= 1;
4281 start_remote (from_tty
); /* Initialize gdb process mechanisms. */
4285 /* Clear WFI global state. Do this before finding about new
4286 threads and inferiors, and setting the current inferior.
4287 Otherwise we would clear the proceed status of the current
4288 inferior when we want its stop_soon state to be preserved
4289 (see notice_new_inferior). */
4290 init_wait_for_inferior ();
4292 /* In non-stop, we will either get an "OK", meaning that there
4293 are no stopped threads at this time; or, a regular stop
4294 reply. In the latter case, there may be more than one thread
4295 stopped --- we pull them all out using the vStopped
4297 if (strcmp (rs
->buf
, "OK") != 0)
4299 struct notif_client
*notif
= ¬if_client_stop
;
4301 /* remote_notif_get_pending_replies acks this one, and gets
4303 rs
->notif_state
->pending_event
[notif_client_stop
.id
]
4304 = remote_notif_parse (notif
, rs
->buf
);
4305 remote_notif_get_pending_events (notif
);
4308 if (thread_count () == 0)
4311 error (_("The target is not running (try extended-remote?)"));
4313 /* We're connected, but not running. Drop out before we
4314 call start_remote. */
4315 rs
->starting_up
= 0;
4319 /* In non-stop mode, any cached wait status will be stored in
4320 the stop reply queue. */
4321 gdb_assert (wait_status
== NULL
);
4323 /* Report all signals during attach/startup. */
4324 remote_pass_signals (target
, 0, NULL
);
4326 /* If there are already stopped threads, mark them stopped and
4327 report their stops before giving the prompt to the user. */
4328 process_initial_stop_replies (from_tty
);
4330 if (target_can_async_p ())
4334 /* If we connected to a live target, do some additional setup. */
4335 if (target_has_execution
)
4337 if (symfile_objfile
) /* No use without a symbol-file. */
4338 remote_check_symbols ();
4341 /* Possibly the target has been engaged in a trace run started
4342 previously; find out where things are at. */
4343 if (remote_get_trace_status (target
, current_trace_status ()) != -1)
4345 struct uploaded_tp
*uploaded_tps
= NULL
;
4347 if (current_trace_status ()->running
)
4348 printf_filtered (_("Trace is already running on the target.\n"));
4350 remote_upload_tracepoints (target
, &uploaded_tps
);
4352 merge_uploaded_tracepoints (&uploaded_tps
);
4355 /* Possibly the target has been engaged in a btrace record started
4356 previously; find out where things are at. */
4357 remote_btrace_maybe_reopen ();
4359 /* The thread and inferior lists are now synchronized with the
4360 target, our symbols have been relocated, and we're merged the
4361 target's tracepoints with ours. We're done with basic start
4363 rs
->starting_up
= 0;
4365 /* Maybe breakpoints are global and need to be inserted now. */
4366 if (breakpoints_should_be_inserted_now ())
4367 insert_breakpoints ();
4370 /* Open a connection to a remote debugger.
4371 NAME is the filename used for communication. */
4374 remote_open (const char *name
, int from_tty
)
4376 remote_open_1 (name
, from_tty
, &remote_ops
, 0);
4379 /* Open a connection to a remote debugger using the extended
4380 remote gdb protocol. NAME is the filename used for communication. */
4383 extended_remote_open (const char *name
, int from_tty
)
4385 remote_open_1 (name
, from_tty
, &extended_remote_ops
, 1 /*extended_p */);
4388 /* Reset all packets back to "unknown support". Called when opening a
4389 new connection to a remote target. */
4392 reset_all_packet_configs_support (void)
4396 for (i
= 0; i
< PACKET_MAX
; i
++)
4397 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4400 /* Initialize all packet configs. */
4403 init_all_packet_configs (void)
4407 for (i
= 0; i
< PACKET_MAX
; i
++)
4409 remote_protocol_packets
[i
].detect
= AUTO_BOOLEAN_AUTO
;
4410 remote_protocol_packets
[i
].support
= PACKET_SUPPORT_UNKNOWN
;
4414 /* Symbol look-up. */
4417 remote_check_symbols (void)
4419 struct remote_state
*rs
= get_remote_state ();
4420 char *msg
, *reply
, *tmp
;
4423 struct cleanup
*old_chain
;
4425 /* The remote side has no concept of inferiors that aren't running
4426 yet, it only knows about running processes. If we're connected
4427 but our current inferior is not running, we should not invite the
4428 remote target to request symbol lookups related to its
4429 (unrelated) current process. */
4430 if (!target_has_execution
)
4433 if (packet_support (PACKET_qSymbol
) == PACKET_DISABLE
)
4436 /* Make sure the remote is pointing at the right process. Note
4437 there's no way to select "no process". */
4438 set_general_process ();
4440 /* Allocate a message buffer. We can't reuse the input buffer in RS,
4441 because we need both at the same time. */
4442 msg
= (char *) xmalloc (get_remote_packet_size ());
4443 old_chain
= make_cleanup (xfree
, msg
);
4444 reply
= (char *) xmalloc (get_remote_packet_size ());
4445 make_cleanup (free_current_contents
, &reply
);
4446 reply_size
= get_remote_packet_size ();
4448 /* Invite target to request symbol lookups. */
4450 putpkt ("qSymbol::");
4451 getpkt (&reply
, &reply_size
, 0);
4452 packet_ok (reply
, &remote_protocol_packets
[PACKET_qSymbol
]);
4454 while (startswith (reply
, "qSymbol:"))
4456 struct bound_minimal_symbol sym
;
4459 end
= hex2bin (tmp
, (gdb_byte
*) msg
, strlen (tmp
) / 2);
4461 sym
= lookup_minimal_symbol (msg
, NULL
, NULL
);
4462 if (sym
.minsym
== NULL
)
4463 xsnprintf (msg
, get_remote_packet_size (), "qSymbol::%s", &reply
[8]);
4466 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
4467 CORE_ADDR sym_addr
= BMSYMBOL_VALUE_ADDRESS (sym
);
4469 /* If this is a function address, return the start of code
4470 instead of any data function descriptor. */
4471 sym_addr
= gdbarch_convert_from_func_ptr_addr (target_gdbarch (),
4475 xsnprintf (msg
, get_remote_packet_size (), "qSymbol:%s:%s",
4476 phex_nz (sym_addr
, addr_size
), &reply
[8]);
4480 getpkt (&reply
, &reply_size
, 0);
4483 do_cleanups (old_chain
);
4486 static struct serial
*
4487 remote_serial_open (const char *name
)
4489 static int udp_warning
= 0;
4491 /* FIXME: Parsing NAME here is a hack. But we want to warn here instead
4492 of in ser-tcp.c, because it is the remote protocol assuming that the
4493 serial connection is reliable and not the serial connection promising
4495 if (!udp_warning
&& startswith (name
, "udp:"))
4497 warning (_("The remote protocol may be unreliable over UDP.\n"
4498 "Some events may be lost, rendering further debugging "
4503 return serial_open (name
);
4506 /* Inform the target of our permission settings. The permission flags
4507 work without this, but if the target knows the settings, it can do
4508 a couple things. First, it can add its own check, to catch cases
4509 that somehow manage to get by the permissions checks in target
4510 methods. Second, if the target is wired to disallow particular
4511 settings (for instance, a system in the field that is not set up to
4512 be able to stop at a breakpoint), it can object to any unavailable
4516 remote_set_permissions (struct target_ops
*self
)
4518 struct remote_state
*rs
= get_remote_state ();
4520 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAllow:"
4521 "WriteReg:%x;WriteMem:%x;"
4522 "InsertBreak:%x;InsertTrace:%x;"
4523 "InsertFastTrace:%x;Stop:%x",
4524 may_write_registers
, may_write_memory
,
4525 may_insert_breakpoints
, may_insert_tracepoints
,
4526 may_insert_fast_tracepoints
, may_stop
);
4528 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4530 /* If the target didn't like the packet, warn the user. Do not try
4531 to undo the user's settings, that would just be maddening. */
4532 if (strcmp (rs
->buf
, "OK") != 0)
4533 warning (_("Remote refused setting permissions with: %s"), rs
->buf
);
4536 /* This type describes each known response to the qSupported
4538 struct protocol_feature
4540 /* The name of this protocol feature. */
4543 /* The default for this protocol feature. */
4544 enum packet_support default_support
;
4546 /* The function to call when this feature is reported, or after
4547 qSupported processing if the feature is not supported.
4548 The first argument points to this structure. The second
4549 argument indicates whether the packet requested support be
4550 enabled, disabled, or probed (or the default, if this function
4551 is being called at the end of processing and this feature was
4552 not reported). The third argument may be NULL; if not NULL, it
4553 is a NUL-terminated string taken from the packet following
4554 this feature's name and an equals sign. */
4555 void (*func
) (const struct protocol_feature
*, enum packet_support
,
4558 /* The corresponding packet for this feature. Only used if
4559 FUNC is remote_supported_packet. */
4564 remote_supported_packet (const struct protocol_feature
*feature
,
4565 enum packet_support support
,
4566 const char *argument
)
4570 warning (_("Remote qSupported response supplied an unexpected value for"
4571 " \"%s\"."), feature
->name
);
4575 remote_protocol_packets
[feature
->packet
].support
= support
;
4579 remote_packet_size (const struct protocol_feature
*feature
,
4580 enum packet_support support
, const char *value
)
4582 struct remote_state
*rs
= get_remote_state ();
4587 if (support
!= PACKET_ENABLE
)
4590 if (value
== NULL
|| *value
== '\0')
4592 warning (_("Remote target reported \"%s\" without a size."),
4598 packet_size
= strtol (value
, &value_end
, 16);
4599 if (errno
!= 0 || *value_end
!= '\0' || packet_size
< 0)
4601 warning (_("Remote target reported \"%s\" with a bad size: \"%s\"."),
4602 feature
->name
, value
);
4606 /* Record the new maximum packet size. */
4607 rs
->explicit_packet_size
= packet_size
;
4610 static const struct protocol_feature remote_protocol_features
[] = {
4611 { "PacketSize", PACKET_DISABLE
, remote_packet_size
, -1 },
4612 { "qXfer:auxv:read", PACKET_DISABLE
, remote_supported_packet
,
4613 PACKET_qXfer_auxv
},
4614 { "qXfer:exec-file:read", PACKET_DISABLE
, remote_supported_packet
,
4615 PACKET_qXfer_exec_file
},
4616 { "qXfer:features:read", PACKET_DISABLE
, remote_supported_packet
,
4617 PACKET_qXfer_features
},
4618 { "qXfer:libraries:read", PACKET_DISABLE
, remote_supported_packet
,
4619 PACKET_qXfer_libraries
},
4620 { "qXfer:libraries-svr4:read", PACKET_DISABLE
, remote_supported_packet
,
4621 PACKET_qXfer_libraries_svr4
},
4622 { "augmented-libraries-svr4-read", PACKET_DISABLE
,
4623 remote_supported_packet
, PACKET_augmented_libraries_svr4_read_feature
},
4624 { "qXfer:memory-map:read", PACKET_DISABLE
, remote_supported_packet
,
4625 PACKET_qXfer_memory_map
},
4626 { "qXfer:spu:read", PACKET_DISABLE
, remote_supported_packet
,
4627 PACKET_qXfer_spu_read
},
4628 { "qXfer:spu:write", PACKET_DISABLE
, remote_supported_packet
,
4629 PACKET_qXfer_spu_write
},
4630 { "qXfer:osdata:read", PACKET_DISABLE
, remote_supported_packet
,
4631 PACKET_qXfer_osdata
},
4632 { "qXfer:threads:read", PACKET_DISABLE
, remote_supported_packet
,
4633 PACKET_qXfer_threads
},
4634 { "qXfer:traceframe-info:read", PACKET_DISABLE
, remote_supported_packet
,
4635 PACKET_qXfer_traceframe_info
},
4636 { "QPassSignals", PACKET_DISABLE
, remote_supported_packet
,
4637 PACKET_QPassSignals
},
4638 { "QCatchSyscalls", PACKET_DISABLE
, remote_supported_packet
,
4639 PACKET_QCatchSyscalls
},
4640 { "QProgramSignals", PACKET_DISABLE
, remote_supported_packet
,
4641 PACKET_QProgramSignals
},
4642 { "QStartupWithShell", PACKET_DISABLE
, remote_supported_packet
,
4643 PACKET_QStartupWithShell
},
4644 { "QEnvironmentHexEncoded", PACKET_DISABLE
, remote_supported_packet
,
4645 PACKET_QEnvironmentHexEncoded
},
4646 { "QEnvironmentReset", PACKET_DISABLE
, remote_supported_packet
,
4647 PACKET_QEnvironmentReset
},
4648 { "QEnvironmentUnset", PACKET_DISABLE
, remote_supported_packet
,
4649 PACKET_QEnvironmentUnset
},
4650 { "QStartNoAckMode", PACKET_DISABLE
, remote_supported_packet
,
4651 PACKET_QStartNoAckMode
},
4652 { "multiprocess", PACKET_DISABLE
, remote_supported_packet
,
4653 PACKET_multiprocess_feature
},
4654 { "QNonStop", PACKET_DISABLE
, remote_supported_packet
, PACKET_QNonStop
},
4655 { "qXfer:siginfo:read", PACKET_DISABLE
, remote_supported_packet
,
4656 PACKET_qXfer_siginfo_read
},
4657 { "qXfer:siginfo:write", PACKET_DISABLE
, remote_supported_packet
,
4658 PACKET_qXfer_siginfo_write
},
4659 { "ConditionalTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4660 PACKET_ConditionalTracepoints
},
4661 { "ConditionalBreakpoints", PACKET_DISABLE
, remote_supported_packet
,
4662 PACKET_ConditionalBreakpoints
},
4663 { "BreakpointCommands", PACKET_DISABLE
, remote_supported_packet
,
4664 PACKET_BreakpointCommands
},
4665 { "FastTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4666 PACKET_FastTracepoints
},
4667 { "StaticTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4668 PACKET_StaticTracepoints
},
4669 {"InstallInTrace", PACKET_DISABLE
, remote_supported_packet
,
4670 PACKET_InstallInTrace
},
4671 { "DisconnectedTracing", PACKET_DISABLE
, remote_supported_packet
,
4672 PACKET_DisconnectedTracing_feature
},
4673 { "ReverseContinue", PACKET_DISABLE
, remote_supported_packet
,
4675 { "ReverseStep", PACKET_DISABLE
, remote_supported_packet
,
4677 { "TracepointSource", PACKET_DISABLE
, remote_supported_packet
,
4678 PACKET_TracepointSource
},
4679 { "QAllow", PACKET_DISABLE
, remote_supported_packet
,
4681 { "EnableDisableTracepoints", PACKET_DISABLE
, remote_supported_packet
,
4682 PACKET_EnableDisableTracepoints_feature
},
4683 { "qXfer:fdpic:read", PACKET_DISABLE
, remote_supported_packet
,
4684 PACKET_qXfer_fdpic
},
4685 { "qXfer:uib:read", PACKET_DISABLE
, remote_supported_packet
,
4687 { "QDisableRandomization", PACKET_DISABLE
, remote_supported_packet
,
4688 PACKET_QDisableRandomization
},
4689 { "QAgent", PACKET_DISABLE
, remote_supported_packet
, PACKET_QAgent
},
4690 { "QTBuffer:size", PACKET_DISABLE
,
4691 remote_supported_packet
, PACKET_QTBuffer_size
},
4692 { "tracenz", PACKET_DISABLE
, remote_supported_packet
, PACKET_tracenz_feature
},
4693 { "Qbtrace:off", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_off
},
4694 { "Qbtrace:bts", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_bts
},
4695 { "Qbtrace:pt", PACKET_DISABLE
, remote_supported_packet
, PACKET_Qbtrace_pt
},
4696 { "qXfer:btrace:read", PACKET_DISABLE
, remote_supported_packet
,
4697 PACKET_qXfer_btrace
},
4698 { "qXfer:btrace-conf:read", PACKET_DISABLE
, remote_supported_packet
,
4699 PACKET_qXfer_btrace_conf
},
4700 { "Qbtrace-conf:bts:size", PACKET_DISABLE
, remote_supported_packet
,
4701 PACKET_Qbtrace_conf_bts_size
},
4702 { "swbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_swbreak_feature
},
4703 { "hwbreak", PACKET_DISABLE
, remote_supported_packet
, PACKET_hwbreak_feature
},
4704 { "fork-events", PACKET_DISABLE
, remote_supported_packet
,
4705 PACKET_fork_event_feature
},
4706 { "vfork-events", PACKET_DISABLE
, remote_supported_packet
,
4707 PACKET_vfork_event_feature
},
4708 { "exec-events", PACKET_DISABLE
, remote_supported_packet
,
4709 PACKET_exec_event_feature
},
4710 { "Qbtrace-conf:pt:size", PACKET_DISABLE
, remote_supported_packet
,
4711 PACKET_Qbtrace_conf_pt_size
},
4712 { "vContSupported", PACKET_DISABLE
, remote_supported_packet
, PACKET_vContSupported
},
4713 { "QThreadEvents", PACKET_DISABLE
, remote_supported_packet
, PACKET_QThreadEvents
},
4714 { "no-resumed", PACKET_DISABLE
, remote_supported_packet
, PACKET_no_resumed
},
4717 static char *remote_support_xml
;
4719 /* Register string appended to "xmlRegisters=" in qSupported query. */
4722 register_remote_support_xml (const char *xml
)
4724 #if defined(HAVE_LIBEXPAT)
4725 if (remote_support_xml
== NULL
)
4726 remote_support_xml
= concat ("xmlRegisters=", xml
, (char *) NULL
);
4729 char *copy
= xstrdup (remote_support_xml
+ 13);
4730 char *p
= strtok (copy
, ",");
4734 if (strcmp (p
, xml
) == 0)
4741 while ((p
= strtok (NULL
, ",")) != NULL
);
4744 remote_support_xml
= reconcat (remote_support_xml
,
4745 remote_support_xml
, ",", xml
,
4752 remote_query_supported_append (char *msg
, const char *append
)
4755 return reconcat (msg
, msg
, ";", append
, (char *) NULL
);
4757 return xstrdup (append
);
4761 remote_query_supported (void)
4763 struct remote_state
*rs
= get_remote_state ();
4766 unsigned char seen
[ARRAY_SIZE (remote_protocol_features
)];
4768 /* The packet support flags are handled differently for this packet
4769 than for most others. We treat an error, a disabled packet, and
4770 an empty response identically: any features which must be reported
4771 to be used will be automatically disabled. An empty buffer
4772 accomplishes this, since that is also the representation for a list
4773 containing no features. */
4776 if (packet_support (PACKET_qSupported
) != PACKET_DISABLE
)
4779 struct cleanup
*old_chain
= make_cleanup (free_current_contents
, &q
);
4781 if (packet_set_cmd_state (PACKET_multiprocess_feature
) != AUTO_BOOLEAN_FALSE
)
4782 q
= remote_query_supported_append (q
, "multiprocess+");
4784 if (packet_set_cmd_state (PACKET_swbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4785 q
= remote_query_supported_append (q
, "swbreak+");
4786 if (packet_set_cmd_state (PACKET_hwbreak_feature
) != AUTO_BOOLEAN_FALSE
)
4787 q
= remote_query_supported_append (q
, "hwbreak+");
4789 q
= remote_query_supported_append (q
, "qRelocInsn+");
4791 if (packet_set_cmd_state (PACKET_fork_event_feature
)
4792 != AUTO_BOOLEAN_FALSE
)
4793 q
= remote_query_supported_append (q
, "fork-events+");
4794 if (packet_set_cmd_state (PACKET_vfork_event_feature
)
4795 != AUTO_BOOLEAN_FALSE
)
4796 q
= remote_query_supported_append (q
, "vfork-events+");
4797 if (packet_set_cmd_state (PACKET_exec_event_feature
)
4798 != AUTO_BOOLEAN_FALSE
)
4799 q
= remote_query_supported_append (q
, "exec-events+");
4801 if (packet_set_cmd_state (PACKET_vContSupported
) != AUTO_BOOLEAN_FALSE
)
4802 q
= remote_query_supported_append (q
, "vContSupported+");
4804 if (packet_set_cmd_state (PACKET_QThreadEvents
) != AUTO_BOOLEAN_FALSE
)
4805 q
= remote_query_supported_append (q
, "QThreadEvents+");
4807 if (packet_set_cmd_state (PACKET_no_resumed
) != AUTO_BOOLEAN_FALSE
)
4808 q
= remote_query_supported_append (q
, "no-resumed+");
4810 /* Keep this one last to work around a gdbserver <= 7.10 bug in
4811 the qSupported:xmlRegisters=i386 handling. */
4812 if (remote_support_xml
!= NULL
)
4813 q
= remote_query_supported_append (q
, remote_support_xml
);
4815 q
= reconcat (q
, "qSupported:", q
, (char *) NULL
);
4818 do_cleanups (old_chain
);
4820 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
4822 /* If an error occured, warn, but do not return - just reset the
4823 buffer to empty and go on to disable features. */
4824 if (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_qSupported
])
4827 warning (_("Remote failure reply: %s"), rs
->buf
);
4832 memset (seen
, 0, sizeof (seen
));
4837 enum packet_support is_supported
;
4838 char *p
, *end
, *name_end
, *value
;
4840 /* First separate out this item from the rest of the packet. If
4841 there's another item after this, we overwrite the separator
4842 (terminated strings are much easier to work with). */
4844 end
= strchr (p
, ';');
4847 end
= p
+ strlen (p
);
4857 warning (_("empty item in \"qSupported\" response"));
4862 name_end
= strchr (p
, '=');
4865 /* This is a name=value entry. */
4866 is_supported
= PACKET_ENABLE
;
4867 value
= name_end
+ 1;
4876 is_supported
= PACKET_ENABLE
;
4880 is_supported
= PACKET_DISABLE
;
4884 is_supported
= PACKET_SUPPORT_UNKNOWN
;
4888 warning (_("unrecognized item \"%s\" "
4889 "in \"qSupported\" response"), p
);
4895 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4896 if (strcmp (remote_protocol_features
[i
].name
, p
) == 0)
4898 const struct protocol_feature
*feature
;
4901 feature
= &remote_protocol_features
[i
];
4902 feature
->func (feature
, is_supported
, value
);
4907 /* If we increased the packet size, make sure to increase the global
4908 buffer size also. We delay this until after parsing the entire
4909 qSupported packet, because this is the same buffer we were
4911 if (rs
->buf_size
< rs
->explicit_packet_size
)
4913 rs
->buf_size
= rs
->explicit_packet_size
;
4914 rs
->buf
= (char *) xrealloc (rs
->buf
, rs
->buf_size
);
4917 /* Handle the defaults for unmentioned features. */
4918 for (i
= 0; i
< ARRAY_SIZE (remote_protocol_features
); i
++)
4921 const struct protocol_feature
*feature
;
4923 feature
= &remote_protocol_features
[i
];
4924 feature
->func (feature
, feature
->default_support
, NULL
);
4928 /* Serial QUIT handler for the remote serial descriptor.
4930 Defers handling a Ctrl-C until we're done with the current
4931 command/response packet sequence, unless:
4933 - We're setting up the connection. Don't send a remote interrupt
4934 request, as we're not fully synced yet. Quit immediately
4937 - The target has been resumed in the foreground
4938 (target_terminal_is_ours is false) with a synchronous resume
4939 packet, and we're blocked waiting for the stop reply, thus a
4940 Ctrl-C should be immediately sent to the target.
4942 - We get a second Ctrl-C while still within the same serial read or
4943 write. In that case the serial is seemingly wedged --- offer to
4946 - We see a second Ctrl-C without target response, after having
4947 previously interrupted the target. In that case the target/stub
4948 is probably wedged --- offer to quit/disconnect.
4952 remote_serial_quit_handler (void)
4954 struct remote_state
*rs
= get_remote_state ();
4956 if (check_quit_flag ())
4958 /* If we're starting up, we're not fully synced yet. Quit
4960 if (rs
->starting_up
)
4962 else if (rs
->got_ctrlc_during_io
)
4964 if (query (_("The target is not responding to GDB commands.\n"
4965 "Stop debugging it? ")))
4966 remote_unpush_and_throw ();
4968 /* If ^C has already been sent once, offer to disconnect. */
4969 else if (!target_terminal_is_ours () && rs
->ctrlc_pending_p
)
4971 /* All-stop protocol, and blocked waiting for stop reply. Send
4972 an interrupt request. */
4973 else if (!target_terminal_is_ours () && rs
->waiting_for_stop_reply
)
4974 target_interrupt (inferior_ptid
);
4976 rs
->got_ctrlc_during_io
= 1;
4980 /* Remove any of the remote.c targets from target stack. Upper targets depend
4981 on it so remove them first. */
4984 remote_unpush_target (void)
4986 pop_all_targets_at_and_above (process_stratum
);
4990 remote_unpush_and_throw (void)
4992 remote_unpush_target ();
4993 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
4997 remote_open_1 (const char *name
, int from_tty
,
4998 struct target_ops
*target
, int extended_p
)
5000 struct remote_state
*rs
= get_remote_state ();
5003 error (_("To open a remote debug connection, you need to specify what\n"
5004 "serial device is attached to the remote system\n"
5005 "(e.g. /dev/ttyS0, /dev/ttya, COM1, etc.)."));
5007 /* See FIXME above. */
5008 if (!target_async_permitted
)
5009 wait_forever_enabled_p
= 1;
5011 /* If we're connected to a running target, target_preopen will kill it.
5012 Ask this question first, before target_preopen has a chance to kill
5014 if (rs
->remote_desc
!= NULL
&& !have_inferiors ())
5017 && !query (_("Already connected to a remote target. Disconnect? ")))
5018 error (_("Still connected."));
5021 /* Here the possibly existing remote target gets unpushed. */
5022 target_preopen (from_tty
);
5024 /* Make sure we send the passed signals list the next time we resume. */
5025 xfree (rs
->last_pass_packet
);
5026 rs
->last_pass_packet
= NULL
;
5028 /* Make sure we send the program signals list the next time we
5030 xfree (rs
->last_program_signals_packet
);
5031 rs
->last_program_signals_packet
= NULL
;
5033 remote_fileio_reset ();
5034 reopen_exec_file ();
5037 rs
->remote_desc
= remote_serial_open (name
);
5038 if (!rs
->remote_desc
)
5039 perror_with_name (name
);
5041 if (baud_rate
!= -1)
5043 if (serial_setbaudrate (rs
->remote_desc
, baud_rate
))
5045 /* The requested speed could not be set. Error out to
5046 top level after closing remote_desc. Take care to
5047 set remote_desc to NULL to avoid closing remote_desc
5049 serial_close (rs
->remote_desc
);
5050 rs
->remote_desc
= NULL
;
5051 perror_with_name (name
);
5055 serial_setparity (rs
->remote_desc
, serial_parity
);
5056 serial_raw (rs
->remote_desc
);
5058 /* If there is something sitting in the buffer we might take it as a
5059 response to a command, which would be bad. */
5060 serial_flush_input (rs
->remote_desc
);
5064 puts_filtered ("Remote debugging using ");
5065 puts_filtered (name
);
5066 puts_filtered ("\n");
5068 push_target (target
); /* Switch to using remote target now. */
5070 /* Register extra event sources in the event loop. */
5071 remote_async_inferior_event_token
5072 = create_async_event_handler (remote_async_inferior_event_handler
,
5074 rs
->notif_state
= remote_notif_state_allocate ();
5076 /* Reset the target state; these things will be queried either by
5077 remote_query_supported or as they are needed. */
5078 reset_all_packet_configs_support ();
5079 rs
->cached_wait_status
= 0;
5080 rs
->explicit_packet_size
= 0;
5082 rs
->extended
= extended_p
;
5083 rs
->waiting_for_stop_reply
= 0;
5084 rs
->ctrlc_pending_p
= 0;
5085 rs
->got_ctrlc_during_io
= 0;
5087 rs
->general_thread
= not_sent_ptid
;
5088 rs
->continue_thread
= not_sent_ptid
;
5089 rs
->remote_traceframe_number
= -1;
5091 rs
->last_resume_exec_dir
= EXEC_FORWARD
;
5093 /* Probe for ability to use "ThreadInfo" query, as required. */
5094 rs
->use_threadinfo_query
= 1;
5095 rs
->use_threadextra_query
= 1;
5097 readahead_cache_invalidate ();
5099 /* Start out by owning the terminal. */
5100 remote_async_terminal_ours_p
= 1;
5102 if (target_async_permitted
)
5104 /* FIXME: cagney/1999-09-23: During the initial connection it is
5105 assumed that the target is already ready and able to respond to
5106 requests. Unfortunately remote_start_remote() eventually calls
5107 wait_for_inferior() with no timeout. wait_forever_enabled_p gets
5108 around this. Eventually a mechanism that allows
5109 wait_for_inferior() to expect/get timeouts will be
5111 wait_forever_enabled_p
= 0;
5114 /* First delete any symbols previously loaded from shared libraries. */
5115 no_shared_libraries (NULL
, 0);
5118 init_thread_list ();
5120 /* Start the remote connection. If error() or QUIT, discard this
5121 target (we'd otherwise be in an inconsistent state) and then
5122 propogate the error on up the exception chain. This ensures that
5123 the caller doesn't stumble along blindly assuming that the
5124 function succeeded. The CLI doesn't have this problem but other
5125 UI's, such as MI do.
5127 FIXME: cagney/2002-05-19: Instead of re-throwing the exception,
5128 this function should return an error indication letting the
5129 caller restore the previous state. Unfortunately the command
5130 ``target remote'' is directly wired to this function making that
5131 impossible. On a positive note, the CLI side of this problem has
5132 been fixed - the function set_cmd_context() makes it possible for
5133 all the ``target ....'' commands to share a common callback
5134 function. See cli-dump.c. */
5139 remote_start_remote (from_tty
, target
, extended_p
);
5141 CATCH (ex
, RETURN_MASK_ALL
)
5143 /* Pop the partially set up target - unless something else did
5144 already before throwing the exception. */
5145 if (rs
->remote_desc
!= NULL
)
5146 remote_unpush_target ();
5147 if (target_async_permitted
)
5148 wait_forever_enabled_p
= 1;
5149 throw_exception (ex
);
5154 remote_btrace_reset ();
5156 if (target_async_permitted
)
5157 wait_forever_enabled_p
= 1;
5160 /* Detach the specified process. */
5163 remote_detach_pid (int pid
)
5165 struct remote_state
*rs
= get_remote_state ();
5167 if (remote_multi_process_p (rs
))
5168 xsnprintf (rs
->buf
, get_remote_packet_size (), "D;%x", pid
);
5170 strcpy (rs
->buf
, "D");
5173 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5175 if (rs
->buf
[0] == 'O' && rs
->buf
[1] == 'K')
5177 else if (rs
->buf
[0] == '\0')
5178 error (_("Remote doesn't know how to detach"));
5180 error (_("Can't detach process."));
5183 /* This detaches a program to which we previously attached, using
5184 inferior_ptid to identify the process. After this is done, GDB
5185 can be used to debug some other program. We better not have left
5186 any breakpoints in the target program or it'll die when it hits
5190 remote_detach_1 (const char *args
, int from_tty
)
5192 int pid
= ptid_get_pid (inferior_ptid
);
5193 struct remote_state
*rs
= get_remote_state ();
5194 struct thread_info
*tp
= find_thread_ptid (inferior_ptid
);
5198 error (_("Argument given to \"detach\" when remotely debugging."));
5200 if (!target_has_execution
)
5201 error (_("No process to detach from."));
5203 target_announce_detach (from_tty
);
5205 /* Tell the remote target to detach. */
5206 remote_detach_pid (pid
);
5208 /* Exit only if this is the only active inferior. */
5209 if (from_tty
&& !rs
->extended
&& number_of_live_inferiors () == 1)
5210 puts_filtered (_("Ending remote debugging.\n"));
5212 /* Check to see if we are detaching a fork parent. Note that if we
5213 are detaching a fork child, tp == NULL. */
5214 is_fork_parent
= (tp
!= NULL
5215 && tp
->pending_follow
.kind
== TARGET_WAITKIND_FORKED
);
5217 /* If doing detach-on-fork, we don't mourn, because that will delete
5218 breakpoints that should be available for the followed inferior. */
5219 if (!is_fork_parent
)
5220 target_mourn_inferior (inferior_ptid
);
5223 inferior_ptid
= null_ptid
;
5224 detach_inferior (pid
);
5229 remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5231 remote_detach_1 (args
, from_tty
);
5235 extended_remote_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
5237 remote_detach_1 (args
, from_tty
);
5240 /* Target follow-fork function for remote targets. On entry, and
5241 at return, the current inferior is the fork parent.
5243 Note that although this is currently only used for extended-remote,
5244 it is named remote_follow_fork in anticipation of using it for the
5245 remote target as well. */
5248 remote_follow_fork (struct target_ops
*ops
, int follow_child
,
5251 struct remote_state
*rs
= get_remote_state ();
5252 enum target_waitkind kind
= inferior_thread ()->pending_follow
.kind
;
5254 if ((kind
== TARGET_WAITKIND_FORKED
&& remote_fork_event_p (rs
))
5255 || (kind
== TARGET_WAITKIND_VFORKED
&& remote_vfork_event_p (rs
)))
5257 /* When following the parent and detaching the child, we detach
5258 the child here. For the case of following the child and
5259 detaching the parent, the detach is done in the target-
5260 independent follow fork code in infrun.c. We can't use
5261 target_detach when detaching an unfollowed child because
5262 the client side doesn't know anything about the child. */
5263 if (detach_fork
&& !follow_child
)
5265 /* Detach the fork child. */
5269 child_ptid
= inferior_thread ()->pending_follow
.value
.related_pid
;
5270 child_pid
= ptid_get_pid (child_ptid
);
5272 remote_detach_pid (child_pid
);
5273 detach_inferior (child_pid
);
5279 /* Target follow-exec function for remote targets. Save EXECD_PATHNAME
5280 in the program space of the new inferior. On entry and at return the
5281 current inferior is the exec'ing inferior. INF is the new exec'd
5282 inferior, which may be the same as the exec'ing inferior unless
5283 follow-exec-mode is "new". */
5286 remote_follow_exec (struct target_ops
*ops
,
5287 struct inferior
*inf
, char *execd_pathname
)
5289 /* We know that this is a target file name, so if it has the "target:"
5290 prefix we strip it off before saving it in the program space. */
5291 if (is_target_filename (execd_pathname
))
5292 execd_pathname
+= strlen (TARGET_SYSROOT_PREFIX
);
5294 set_pspace_remote_exec_file (inf
->pspace
, execd_pathname
);
5297 /* Same as remote_detach, but don't send the "D" packet; just disconnect. */
5300 remote_disconnect (struct target_ops
*target
, const char *args
, int from_tty
)
5303 error (_("Argument given to \"disconnect\" when remotely debugging."));
5305 /* Make sure we unpush even the extended remote targets. Calling
5306 target_mourn_inferior won't unpush, and remote_mourn won't
5307 unpush if there is more than one inferior left. */
5308 unpush_target (target
);
5309 generic_mourn_inferior ();
5312 puts_filtered ("Ending remote debugging.\n");
5315 /* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
5316 be chatty about it. */
5319 extended_remote_attach (struct target_ops
*target
, const char *args
,
5322 struct remote_state
*rs
= get_remote_state ();
5324 char *wait_status
= NULL
;
5326 pid
= parse_pid_to_attach (args
);
5328 /* Remote PID can be freely equal to getpid, do not check it here the same
5329 way as in other targets. */
5331 if (packet_support (PACKET_vAttach
) == PACKET_DISABLE
)
5332 error (_("This target does not support attaching to a process"));
5336 char *exec_file
= get_exec_file (0);
5339 printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file
,
5340 target_pid_to_str (pid_to_ptid (pid
)));
5342 printf_unfiltered (_("Attaching to %s\n"),
5343 target_pid_to_str (pid_to_ptid (pid
)));
5345 gdb_flush (gdb_stdout
);
5348 xsnprintf (rs
->buf
, get_remote_packet_size (), "vAttach;%x", pid
);
5350 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5352 switch (packet_ok (rs
->buf
,
5353 &remote_protocol_packets
[PACKET_vAttach
]))
5356 if (!target_is_non_stop_p ())
5358 /* Save the reply for later. */
5359 wait_status
= (char *) alloca (strlen (rs
->buf
) + 1);
5360 strcpy (wait_status
, rs
->buf
);
5362 else if (strcmp (rs
->buf
, "OK") != 0)
5363 error (_("Attaching to %s failed with: %s"),
5364 target_pid_to_str (pid_to_ptid (pid
)),
5367 case PACKET_UNKNOWN
:
5368 error (_("This target does not support attaching to a process"));
5370 error (_("Attaching to %s failed"),
5371 target_pid_to_str (pid_to_ptid (pid
)));
5374 set_current_inferior (remote_add_inferior (0, pid
, 1, 0));
5376 inferior_ptid
= pid_to_ptid (pid
);
5378 if (target_is_non_stop_p ())
5380 struct thread_info
*thread
;
5382 /* Get list of threads. */
5383 remote_update_thread_list (target
);
5385 thread
= first_thread_of_process (pid
);
5387 inferior_ptid
= thread
->ptid
;
5389 inferior_ptid
= pid_to_ptid (pid
);
5391 /* Invalidate our notion of the remote current thread. */
5392 record_currthread (rs
, minus_one_ptid
);
5396 /* Now, if we have thread information, update inferior_ptid. */
5397 inferior_ptid
= remote_current_thread (inferior_ptid
);
5399 /* Add the main thread to the thread list. */
5400 add_thread_silent (inferior_ptid
);
5403 /* Next, if the target can specify a description, read it. We do
5404 this before anything involving memory or registers. */
5405 target_find_description ();
5407 if (!target_is_non_stop_p ())
5409 /* Use the previously fetched status. */
5410 gdb_assert (wait_status
!= NULL
);
5412 if (target_can_async_p ())
5414 struct notif_event
*reply
5415 = remote_notif_parse (¬if_client_stop
, wait_status
);
5417 push_stop_reply ((struct stop_reply
*) reply
);
5423 gdb_assert (wait_status
!= NULL
);
5424 strcpy (rs
->buf
, wait_status
);
5425 rs
->cached_wait_status
= 1;
5429 gdb_assert (wait_status
== NULL
);
5432 /* Implementation of the to_post_attach method. */
5435 extended_remote_post_attach (struct target_ops
*ops
, int pid
)
5437 /* Get text, data & bss offsets. */
5440 /* In certain cases GDB might not have had the chance to start
5441 symbol lookup up until now. This could happen if the debugged
5442 binary is not using shared libraries, the vsyscall page is not
5443 present (on Linux) and the binary itself hadn't changed since the
5444 debugging process was started. */
5445 if (symfile_objfile
!= NULL
)
5446 remote_check_symbols();
5450 /* Check for the availability of vCont. This function should also check
5454 remote_vcont_probe (struct remote_state
*rs
)
5458 strcpy (rs
->buf
, "vCont?");
5460 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5463 /* Make sure that the features we assume are supported. */
5464 if (startswith (buf
, "vCont"))
5467 int support_c
, support_C
;
5469 rs
->supports_vCont
.s
= 0;
5470 rs
->supports_vCont
.S
= 0;
5473 rs
->supports_vCont
.t
= 0;
5474 rs
->supports_vCont
.r
= 0;
5475 while (p
&& *p
== ';')
5478 if (*p
== 's' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5479 rs
->supports_vCont
.s
= 1;
5480 else if (*p
== 'S' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5481 rs
->supports_vCont
.S
= 1;
5482 else if (*p
== 'c' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5484 else if (*p
== 'C' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5486 else if (*p
== 't' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5487 rs
->supports_vCont
.t
= 1;
5488 else if (*p
== 'r' && (*(p
+ 1) == ';' || *(p
+ 1) == 0))
5489 rs
->supports_vCont
.r
= 1;
5491 p
= strchr (p
, ';');
5494 /* If c, and C are not all supported, we can't use vCont. Clearing
5495 BUF will make packet_ok disable the packet. */
5496 if (!support_c
|| !support_C
)
5500 packet_ok (buf
, &remote_protocol_packets
[PACKET_vCont
]);
5503 /* Helper function for building "vCont" resumptions. Write a
5504 resumption to P. ENDP points to one-passed-the-end of the buffer
5505 we're allowed to write to. Returns BUF+CHARACTERS_WRITTEN. The
5506 thread to be resumed is PTID; STEP and SIGGNAL indicate whether the
5507 resumed thread should be single-stepped and/or signalled. If PTID
5508 equals minus_one_ptid, then all threads are resumed; if PTID
5509 represents a process, then all threads of the process are resumed;
5510 the thread to be stepped and/or signalled is given in the global
5514 append_resumption (char *p
, char *endp
,
5515 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5517 struct remote_state
*rs
= get_remote_state ();
5519 if (step
&& siggnal
!= GDB_SIGNAL_0
)
5520 p
+= xsnprintf (p
, endp
- p
, ";S%02x", siggnal
);
5522 /* GDB is willing to range step. */
5523 && use_range_stepping
5524 /* Target supports range stepping. */
5525 && rs
->supports_vCont
.r
5526 /* We don't currently support range stepping multiple
5527 threads with a wildcard (though the protocol allows it,
5528 so stubs shouldn't make an active effort to forbid
5530 && !(remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
5532 struct thread_info
*tp
;
5534 if (ptid_equal (ptid
, minus_one_ptid
))
5536 /* If we don't know about the target thread's tid, then
5537 we're resuming magic_null_ptid (see caller). */
5538 tp
= find_thread_ptid (magic_null_ptid
);
5541 tp
= find_thread_ptid (ptid
);
5542 gdb_assert (tp
!= NULL
);
5544 if (tp
->control
.may_range_step
)
5546 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
5548 p
+= xsnprintf (p
, endp
- p
, ";r%s,%s",
5549 phex_nz (tp
->control
.step_range_start
,
5551 phex_nz (tp
->control
.step_range_end
,
5555 p
+= xsnprintf (p
, endp
- p
, ";s");
5558 p
+= xsnprintf (p
, endp
- p
, ";s");
5559 else if (siggnal
!= GDB_SIGNAL_0
)
5560 p
+= xsnprintf (p
, endp
- p
, ";C%02x", siggnal
);
5562 p
+= xsnprintf (p
, endp
- p
, ";c");
5564 if (remote_multi_process_p (rs
) && ptid_is_pid (ptid
))
5568 /* All (-1) threads of process. */
5569 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
5571 p
+= xsnprintf (p
, endp
- p
, ":");
5572 p
= write_ptid (p
, endp
, nptid
);
5574 else if (!ptid_equal (ptid
, minus_one_ptid
))
5576 p
+= xsnprintf (p
, endp
- p
, ":");
5577 p
= write_ptid (p
, endp
, ptid
);
5583 /* Clear the thread's private info on resume. */
5586 resume_clear_thread_private_info (struct thread_info
*thread
)
5588 if (thread
->priv
!= NULL
)
5590 thread
->priv
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
5591 thread
->priv
->watch_data_address
= 0;
5595 /* Append a vCont continue-with-signal action for threads that have a
5596 non-zero stop signal. */
5599 append_pending_thread_resumptions (char *p
, char *endp
, ptid_t ptid
)
5601 struct thread_info
*thread
;
5603 ALL_NON_EXITED_THREADS (thread
)
5604 if (ptid_match (thread
->ptid
, ptid
)
5605 && !ptid_equal (inferior_ptid
, thread
->ptid
)
5606 && thread
->suspend
.stop_signal
!= GDB_SIGNAL_0
)
5608 p
= append_resumption (p
, endp
, thread
->ptid
,
5609 0, thread
->suspend
.stop_signal
);
5610 thread
->suspend
.stop_signal
= GDB_SIGNAL_0
;
5611 resume_clear_thread_private_info (thread
);
5617 /* Set the target running, using the packets that use Hc
5621 remote_resume_with_hc (struct target_ops
*ops
,
5622 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5624 struct remote_state
*rs
= get_remote_state ();
5625 struct thread_info
*thread
;
5628 rs
->last_sent_signal
= siggnal
;
5629 rs
->last_sent_step
= step
;
5631 /* The c/s/C/S resume packets use Hc, so set the continue
5633 if (ptid_equal (ptid
, minus_one_ptid
))
5634 set_continue_thread (any_thread_ptid
);
5636 set_continue_thread (ptid
);
5638 ALL_NON_EXITED_THREADS (thread
)
5639 resume_clear_thread_private_info (thread
);
5642 if (execution_direction
== EXEC_REVERSE
)
5644 /* We don't pass signals to the target in reverse exec mode. */
5645 if (info_verbose
&& siggnal
!= GDB_SIGNAL_0
)
5646 warning (_(" - Can't pass signal %d to target in reverse: ignored."),
5649 if (step
&& packet_support (PACKET_bs
) == PACKET_DISABLE
)
5650 error (_("Remote reverse-step not supported."));
5651 if (!step
&& packet_support (PACKET_bc
) == PACKET_DISABLE
)
5652 error (_("Remote reverse-continue not supported."));
5654 strcpy (buf
, step
? "bs" : "bc");
5656 else if (siggnal
!= GDB_SIGNAL_0
)
5658 buf
[0] = step
? 'S' : 'C';
5659 buf
[1] = tohex (((int) siggnal
>> 4) & 0xf);
5660 buf
[2] = tohex (((int) siggnal
) & 0xf);
5664 strcpy (buf
, step
? "s" : "c");
5669 /* Resume the remote inferior by using a "vCont" packet. The thread
5670 to be resumed is PTID; STEP and SIGGNAL indicate whether the
5671 resumed thread should be single-stepped and/or signalled. If PTID
5672 equals minus_one_ptid, then all threads are resumed; the thread to
5673 be stepped and/or signalled is given in the global INFERIOR_PTID.
5674 This function returns non-zero iff it resumes the inferior.
5676 This function issues a strict subset of all possible vCont commands
5680 remote_resume_with_vcont (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5682 struct remote_state
*rs
= get_remote_state ();
5686 /* No reverse execution actions defined for vCont. */
5687 if (execution_direction
== EXEC_REVERSE
)
5690 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
5691 remote_vcont_probe (rs
);
5693 if (packet_support (PACKET_vCont
) == PACKET_DISABLE
)
5697 endp
= rs
->buf
+ get_remote_packet_size ();
5699 /* If we could generate a wider range of packets, we'd have to worry
5700 about overflowing BUF. Should there be a generic
5701 "multi-part-packet" packet? */
5703 p
+= xsnprintf (p
, endp
- p
, "vCont");
5705 if (ptid_equal (ptid
, magic_null_ptid
))
5707 /* MAGIC_NULL_PTID means that we don't have any active threads,
5708 so we don't have any TID numbers the inferior will
5709 understand. Make sure to only send forms that do not specify
5711 append_resumption (p
, endp
, minus_one_ptid
, step
, siggnal
);
5713 else if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
5715 /* Resume all threads (of all processes, or of a single
5716 process), with preference for INFERIOR_PTID. This assumes
5717 inferior_ptid belongs to the set of all threads we are about
5719 if (step
|| siggnal
!= GDB_SIGNAL_0
)
5721 /* Step inferior_ptid, with or without signal. */
5722 p
= append_resumption (p
, endp
, inferior_ptid
, step
, siggnal
);
5725 /* Also pass down any pending signaled resumption for other
5726 threads not the current. */
5727 p
= append_pending_thread_resumptions (p
, endp
, ptid
);
5729 /* And continue others without a signal. */
5730 append_resumption (p
, endp
, ptid
, /*step=*/ 0, GDB_SIGNAL_0
);
5734 /* Scheduler locking; resume only PTID. */
5735 append_resumption (p
, endp
, ptid
, step
, siggnal
);
5738 gdb_assert (strlen (rs
->buf
) < get_remote_packet_size ());
5741 if (target_is_non_stop_p ())
5743 /* In non-stop, the stub replies to vCont with "OK". The stop
5744 reply will be reported asynchronously by means of a `%Stop'
5746 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5747 if (strcmp (rs
->buf
, "OK") != 0)
5748 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5754 /* Tell the remote machine to resume. */
5757 remote_resume (struct target_ops
*ops
,
5758 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5760 struct remote_state
*rs
= get_remote_state ();
5762 /* When connected in non-stop mode, the core resumes threads
5763 individually. Resuming remote threads directly in target_resume
5764 would thus result in sending one packet per thread. Instead, to
5765 minimize roundtrip latency, here we just store the resume
5766 request; the actual remote resumption will be done in
5767 target_commit_resume / remote_commit_resume, where we'll be able
5768 to do vCont action coalescing. */
5769 if (target_is_non_stop_p () && execution_direction
!= EXEC_REVERSE
)
5771 struct private_thread_info
*remote_thr
;
5773 if (ptid_equal (minus_one_ptid
, ptid
) || ptid_is_pid (ptid
))
5774 remote_thr
= get_private_info_ptid (inferior_ptid
);
5776 remote_thr
= get_private_info_ptid (ptid
);
5777 remote_thr
->last_resume_step
= step
;
5778 remote_thr
->last_resume_sig
= siggnal
;
5782 /* In all-stop, we can't mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
5783 (explained in remote-notif.c:handle_notification) so
5784 remote_notif_process is not called. We need find a place where
5785 it is safe to start a 'vNotif' sequence. It is good to do it
5786 before resuming inferior, because inferior was stopped and no RSP
5787 traffic at that moment. */
5788 if (!target_is_non_stop_p ())
5789 remote_notif_process (rs
->notif_state
, ¬if_client_stop
);
5791 rs
->last_resume_exec_dir
= execution_direction
;
5793 /* Prefer vCont, and fallback to s/c/S/C, which use Hc. */
5794 if (!remote_resume_with_vcont (ptid
, step
, siggnal
))
5795 remote_resume_with_hc (ops
, ptid
, step
, siggnal
);
5797 /* We are about to start executing the inferior, let's register it
5798 with the event loop. NOTE: this is the one place where all the
5799 execution commands end up. We could alternatively do this in each
5800 of the execution commands in infcmd.c. */
5801 /* FIXME: ezannoni 1999-09-28: We may need to move this out of here
5802 into infcmd.c in order to allow inferior function calls to work
5803 NOT asynchronously. */
5804 if (target_can_async_p ())
5807 /* We've just told the target to resume. The remote server will
5808 wait for the inferior to stop, and then send a stop reply. In
5809 the mean time, we can't start another command/query ourselves
5810 because the stub wouldn't be ready to process it. This applies
5811 only to the base all-stop protocol, however. In non-stop (which
5812 only supports vCont), the stub replies with an "OK", and is
5813 immediate able to process further serial input. */
5814 if (!target_is_non_stop_p ())
5815 rs
->waiting_for_stop_reply
= 1;
5818 static void check_pending_events_prevent_wildcard_vcont
5819 (int *may_global_wildcard_vcont
);
5820 static int is_pending_fork_parent_thread (struct thread_info
*thread
);
5822 /* Private per-inferior info for target remote processes. */
5824 struct private_inferior
5826 /* Whether we can send a wildcard vCont for this process. */
5827 int may_wildcard_vcont
;
5830 /* Structure used to track the construction of a vCont packet in the
5831 outgoing packet buffer. This is used to send multiple vCont
5832 packets if we have more actions than would fit a single packet. */
5834 struct vcont_builder
5836 /* Pointer to the first action. P points here if no action has been
5840 /* Where the next action will be appended. */
5843 /* The end of the buffer. Must never write past this. */
5847 /* Prepare the outgoing buffer for a new vCont packet. */
5850 vcont_builder_restart (struct vcont_builder
*builder
)
5852 struct remote_state
*rs
= get_remote_state ();
5854 builder
->p
= rs
->buf
;
5855 builder
->endp
= rs
->buf
+ get_remote_packet_size ();
5856 builder
->p
+= xsnprintf (builder
->p
, builder
->endp
- builder
->p
, "vCont");
5857 builder
->first_action
= builder
->p
;
5860 /* If the vCont packet being built has any action, send it to the
5864 vcont_builder_flush (struct vcont_builder
*builder
)
5866 struct remote_state
*rs
;
5868 if (builder
->p
== builder
->first_action
)
5871 rs
= get_remote_state ();
5873 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
5874 if (strcmp (rs
->buf
, "OK") != 0)
5875 error (_("Unexpected vCont reply in non-stop mode: %s"), rs
->buf
);
5878 /* The largest action is range-stepping, with its two addresses. This
5879 is more than sufficient. If a new, bigger action is created, it'll
5880 quickly trigger a failed assertion in append_resumption (and we'll
5882 #define MAX_ACTION_SIZE 200
5884 /* Append a new vCont action in the outgoing packet being built. If
5885 the action doesn't fit the packet along with previous actions, push
5886 what we've got so far to the remote end and start over a new vCont
5887 packet (with the new action). */
5890 vcont_builder_push_action (struct vcont_builder
*builder
,
5891 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
5893 char buf
[MAX_ACTION_SIZE
+ 1];
5897 endp
= append_resumption (buf
, buf
+ sizeof (buf
),
5898 ptid
, step
, siggnal
);
5900 /* Check whether this new action would fit in the vCont packet along
5901 with previous actions. If not, send what we've got so far and
5902 start a new vCont packet. */
5904 if (rsize
> builder
->endp
- builder
->p
)
5906 vcont_builder_flush (builder
);
5907 vcont_builder_restart (builder
);
5909 /* Should now fit. */
5910 gdb_assert (rsize
<= builder
->endp
- builder
->p
);
5913 memcpy (builder
->p
, buf
, rsize
);
5914 builder
->p
+= rsize
;
5918 /* to_commit_resume implementation. */
5921 remote_commit_resume (struct target_ops
*ops
)
5923 struct remote_state
*rs
= get_remote_state ();
5924 struct inferior
*inf
;
5925 struct thread_info
*tp
;
5926 int any_process_wildcard
;
5927 int may_global_wildcard_vcont
;
5928 struct vcont_builder vcont_builder
;
5930 /* If connected in all-stop mode, we'd send the remote resume
5931 request directly from remote_resume. Likewise if
5932 reverse-debugging, as there are no defined vCont actions for
5933 reverse execution. */
5934 if (!target_is_non_stop_p () || execution_direction
== EXEC_REVERSE
)
5937 /* Try to send wildcard actions ("vCont;c" or "vCont;c:pPID.-1")
5938 instead of resuming all threads of each process individually.
5939 However, if any thread of a process must remain halted, we can't
5940 send wildcard resumes and must send one action per thread.
5942 Care must be taken to not resume threads/processes the server
5943 side already told us are stopped, but the core doesn't know about
5944 yet, because the events are still in the vStopped notification
5947 #1 => vCont s:p1.1;c
5949 #3 <= %Stopped T05 p1.1
5954 #8 (infrun handles the stop for p1.1 and continues stepping)
5955 #9 => vCont s:p1.1;c
5957 The last vCont above would resume thread p1.2 by mistake, because
5958 the server has no idea that the event for p1.2 had not been
5961 The server side must similarly ignore resume actions for the
5962 thread that has a pending %Stopped notification (and any other
5963 threads with events pending), until GDB acks the notification
5964 with vStopped. Otherwise, e.g., the following case is
5967 #1 => g (or any other packet)
5969 #3 <= %Stopped T05 p1.2
5970 #4 => vCont s:p1.1;c
5973 Above, the server must not resume thread p1.2. GDB can't know
5974 that p1.2 stopped until it acks the %Stopped notification, and
5975 since from GDB's perspective all threads should be running, it
5978 Finally, special care must also be given to handling fork/vfork
5979 events. A (v)fork event actually tells us that two processes
5980 stopped -- the parent and the child. Until we follow the fork,
5981 we must not resume the child. Therefore, if we have a pending
5982 fork follow, we must not send a global wildcard resume action
5983 (vCont;c). We can still send process-wide wildcards though. */
5985 /* Start by assuming a global wildcard (vCont;c) is possible. */
5986 may_global_wildcard_vcont
= 1;
5988 /* And assume every process is individually wildcard-able too. */
5989 ALL_NON_EXITED_INFERIORS (inf
)
5991 if (inf
->priv
== NULL
)
5992 inf
->priv
= XNEW (struct private_inferior
);
5993 inf
->priv
->may_wildcard_vcont
= 1;
5996 /* Check for any pending events (not reported or processed yet) and
5997 disable process and global wildcard resumes appropriately. */
5998 check_pending_events_prevent_wildcard_vcont (&may_global_wildcard_vcont
);
6000 ALL_NON_EXITED_THREADS (tp
)
6002 /* If a thread of a process is not meant to be resumed, then we
6003 can't wildcard that process. */
6006 tp
->inf
->priv
->may_wildcard_vcont
= 0;
6008 /* And if we can't wildcard a process, we can't wildcard
6009 everything either. */
6010 may_global_wildcard_vcont
= 0;
6014 /* If a thread is the parent of an unfollowed fork, then we
6015 can't do a global wildcard, as that would resume the fork
6017 if (is_pending_fork_parent_thread (tp
))
6018 may_global_wildcard_vcont
= 0;
6021 /* Now let's build the vCont packet(s). Actions must be appended
6022 from narrower to wider scopes (thread -> process -> global). If
6023 we end up with too many actions for a single packet vcont_builder
6024 flushes the current vCont packet to the remote side and starts a
6026 vcont_builder_restart (&vcont_builder
);
6028 /* Threads first. */
6029 ALL_NON_EXITED_THREADS (tp
)
6031 struct private_thread_info
*remote_thr
= tp
->priv
;
6033 if (!tp
->executing
|| remote_thr
->vcont_resumed
)
6036 gdb_assert (!thread_is_in_step_over_chain (tp
));
6038 if (!remote_thr
->last_resume_step
6039 && remote_thr
->last_resume_sig
== GDB_SIGNAL_0
6040 && tp
->inf
->priv
->may_wildcard_vcont
)
6042 /* We'll send a wildcard resume instead. */
6043 remote_thr
->vcont_resumed
= 1;
6047 vcont_builder_push_action (&vcont_builder
, tp
->ptid
,
6048 remote_thr
->last_resume_step
,
6049 remote_thr
->last_resume_sig
);
6050 remote_thr
->vcont_resumed
= 1;
6053 /* Now check whether we can send any process-wide wildcard. This is
6054 to avoid sending a global wildcard in the case nothing is
6055 supposed to be resumed. */
6056 any_process_wildcard
= 0;
6058 ALL_NON_EXITED_INFERIORS (inf
)
6060 if (inf
->priv
->may_wildcard_vcont
)
6062 any_process_wildcard
= 1;
6067 if (any_process_wildcard
)
6069 /* If all processes are wildcard-able, then send a single "c"
6070 action, otherwise, send an "all (-1) threads of process"
6071 continue action for each running process, if any. */
6072 if (may_global_wildcard_vcont
)
6074 vcont_builder_push_action (&vcont_builder
, minus_one_ptid
,
6079 ALL_NON_EXITED_INFERIORS (inf
)
6081 if (inf
->priv
->may_wildcard_vcont
)
6083 vcont_builder_push_action (&vcont_builder
,
6084 pid_to_ptid (inf
->pid
),
6091 vcont_builder_flush (&vcont_builder
);
6096 /* Non-stop version of target_stop. Uses `vCont;t' to stop a remote
6097 thread, all threads of a remote process, or all threads of all
6101 remote_stop_ns (ptid_t ptid
)
6103 struct remote_state
*rs
= get_remote_state ();
6105 char *endp
= rs
->buf
+ get_remote_packet_size ();
6107 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
6108 remote_vcont_probe (rs
);
6110 if (!rs
->supports_vCont
.t
)
6111 error (_("Remote server does not support stopping threads"));
6113 if (ptid_equal (ptid
, minus_one_ptid
)
6114 || (!remote_multi_process_p (rs
) && ptid_is_pid (ptid
)))
6115 p
+= xsnprintf (p
, endp
- p
, "vCont;t");
6120 p
+= xsnprintf (p
, endp
- p
, "vCont;t:");
6122 if (ptid_is_pid (ptid
))
6123 /* All (-1) threads of process. */
6124 nptid
= ptid_build (ptid_get_pid (ptid
), -1, 0);
6127 /* Small optimization: if we already have a stop reply for
6128 this thread, no use in telling the stub we want this
6130 if (peek_stop_reply (ptid
))
6136 write_ptid (p
, endp
, nptid
);
6139 /* In non-stop, we get an immediate OK reply. The stop reply will
6140 come in asynchronously by notification. */
6142 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6143 if (strcmp (rs
->buf
, "OK") != 0)
6144 error (_("Stopping %s failed: %s"), target_pid_to_str (ptid
), rs
->buf
);
6147 /* All-stop version of target_interrupt. Sends a break or a ^C to
6148 interrupt the remote target. It is undefined which thread of which
6149 process reports the interrupt. */
6152 remote_interrupt_as (void)
6154 struct remote_state
*rs
= get_remote_state ();
6156 rs
->ctrlc_pending_p
= 1;
6158 /* If the inferior is stopped already, but the core didn't know
6159 about it yet, just ignore the request. The cached wait status
6160 will be collected in remote_wait. */
6161 if (rs
->cached_wait_status
)
6164 /* Send interrupt_sequence to remote target. */
6165 send_interrupt_sequence ();
6168 /* Non-stop version of target_interrupt. Uses `vCtrlC' to interrupt
6169 the remote target. It is undefined which thread of which process
6170 reports the interrupt. Throws an error if the packet is not
6171 supported by the server. */
6174 remote_interrupt_ns (void)
6176 struct remote_state
*rs
= get_remote_state ();
6178 char *endp
= rs
->buf
+ get_remote_packet_size ();
6180 xsnprintf (p
, endp
- p
, "vCtrlC");
6182 /* In non-stop, we get an immediate OK reply. The stop reply will
6183 come in asynchronously by notification. */
6185 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
6187 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vCtrlC
]))
6191 case PACKET_UNKNOWN
:
6192 error (_("No support for interrupting the remote target."));
6194 error (_("Interrupting target failed: %s"), rs
->buf
);
6198 /* Implement the to_stop function for the remote targets. */
6201 remote_stop (struct target_ops
*self
, ptid_t ptid
)
6204 fprintf_unfiltered (gdb_stdlog
, "remote_stop called\n");
6206 if (target_is_non_stop_p ())
6207 remote_stop_ns (ptid
);
6210 /* We don't currently have a way to transparently pause the
6211 remote target in all-stop mode. Interrupt it instead. */
6212 remote_interrupt_as ();
6216 /* Implement the to_interrupt function for the remote targets. */
6219 remote_interrupt (struct target_ops
*self
, ptid_t ptid
)
6221 struct remote_state
*rs
= get_remote_state ();
6224 fprintf_unfiltered (gdb_stdlog
, "remote_interrupt called\n");
6226 if (target_is_non_stop_p ())
6227 remote_interrupt_ns ();
6229 remote_interrupt_as ();
6232 /* Implement the to_pass_ctrlc function for the remote targets. */
6235 remote_pass_ctrlc (struct target_ops
*self
)
6237 struct remote_state
*rs
= get_remote_state ();
6240 fprintf_unfiltered (gdb_stdlog
, "remote_pass_ctrlc called\n");
6242 /* If we're starting up, we're not fully synced yet. Quit
6244 if (rs
->starting_up
)
6246 /* If ^C has already been sent once, offer to disconnect. */
6247 else if (rs
->ctrlc_pending_p
)
6250 target_interrupt (inferior_ptid
);
6253 /* Ask the user what to do when an interrupt is received. */
6256 interrupt_query (void)
6258 struct remote_state
*rs
= get_remote_state ();
6260 if (rs
->waiting_for_stop_reply
&& rs
->ctrlc_pending_p
)
6262 if (query (_("The target is not responding to interrupt requests.\n"
6263 "Stop debugging it? ")))
6265 remote_unpush_target ();
6266 throw_error (TARGET_CLOSE_ERROR
, _("Disconnected from target."));
6271 if (query (_("Interrupted while waiting for the program.\n"
6272 "Give up waiting? ")))
6277 /* Enable/disable target terminal ownership. Most targets can use
6278 terminal groups to control terminal ownership. Remote targets are
6279 different in that explicit transfer of ownership to/from GDB/target
6283 remote_terminal_inferior (struct target_ops
*self
)
6285 /* FIXME: cagney/1999-09-27: Make calls to target_terminal_*()
6286 idempotent. The event-loop GDB talking to an asynchronous target
6287 with a synchronous command calls this function from both
6288 event-top.c and infrun.c/infcmd.c. Once GDB stops trying to
6289 transfer the terminal to the target when it shouldn't this guard
6291 if (!remote_async_terminal_ours_p
)
6293 remote_async_terminal_ours_p
= 0;
6294 /* NOTE: At this point we could also register our selves as the
6295 recipient of all input. Any characters typed could then be
6296 passed on down to the target. */
6300 remote_terminal_ours (struct target_ops
*self
)
6302 /* See FIXME in remote_terminal_inferior. */
6303 if (remote_async_terminal_ours_p
)
6305 remote_async_terminal_ours_p
= 1;
6309 remote_console_output (char *msg
)
6313 for (p
= msg
; p
[0] && p
[1]; p
+= 2)
6316 char c
= fromhex (p
[0]) * 16 + fromhex (p
[1]);
6320 fputs_unfiltered (tb
, gdb_stdtarg
);
6322 gdb_flush (gdb_stdtarg
);
6325 DEF_VEC_O(cached_reg_t
);
6327 typedef struct stop_reply
6329 struct notif_event base
;
6331 /* The identifier of the thread about this event */
6334 /* The remote state this event is associated with. When the remote
6335 connection, represented by a remote_state object, is closed,
6336 all the associated stop_reply events should be released. */
6337 struct remote_state
*rs
;
6339 struct target_waitstatus ws
;
6341 /* Expedited registers. This makes remote debugging a bit more
6342 efficient for those targets that provide critical registers as
6343 part of their normal status mechanism (as another roundtrip to
6344 fetch them is avoided). */
6345 VEC(cached_reg_t
) *regcache
;
6347 enum target_stop_reason stop_reason
;
6349 CORE_ADDR watch_data_address
;
6354 DECLARE_QUEUE_P (stop_reply_p
);
6355 DEFINE_QUEUE_P (stop_reply_p
);
6356 /* The list of already fetched and acknowledged stop events. This
6357 queue is used for notification Stop, and other notifications
6358 don't need queue for their events, because the notification events
6359 of Stop can't be consumed immediately, so that events should be
6360 queued first, and be consumed by remote_wait_{ns,as} one per
6361 time. Other notifications can consume their events immediately,
6362 so queue is not needed for them. */
6363 static QUEUE (stop_reply_p
) *stop_reply_queue
;
6366 stop_reply_xfree (struct stop_reply
*r
)
6368 notif_event_xfree ((struct notif_event
*) r
);
6371 /* Return the length of the stop reply queue. */
6374 stop_reply_queue_length (void)
6376 return QUEUE_length (stop_reply_p
, stop_reply_queue
);
6380 remote_notif_stop_parse (struct notif_client
*self
, char *buf
,
6381 struct notif_event
*event
)
6383 remote_parse_stop_reply (buf
, (struct stop_reply
*) event
);
6387 remote_notif_stop_ack (struct notif_client
*self
, char *buf
,
6388 struct notif_event
*event
)
6390 struct stop_reply
*stop_reply
= (struct stop_reply
*) event
;
6393 putpkt (self
->ack_command
);
6395 if (stop_reply
->ws
.kind
== TARGET_WAITKIND_IGNORE
)
6396 /* We got an unknown stop reply. */
6397 error (_("Unknown stop reply"));
6399 push_stop_reply (stop_reply
);
6403 remote_notif_stop_can_get_pending_events (struct notif_client
*self
)
6405 /* We can't get pending events in remote_notif_process for
6406 notification stop, and we have to do this in remote_wait_ns
6407 instead. If we fetch all queued events from stub, remote stub
6408 may exit and we have no chance to process them back in
6410 mark_async_event_handler (remote_async_inferior_event_token
);
6415 stop_reply_dtr (struct notif_event
*event
)
6417 struct stop_reply
*r
= (struct stop_reply
*) event
;
6422 VEC_iterate (cached_reg_t
, r
->regcache
, ix
, reg
);
6426 VEC_free (cached_reg_t
, r
->regcache
);
6429 static struct notif_event
*
6430 remote_notif_stop_alloc_reply (void)
6432 /* We cast to a pointer to the "base class". */
6433 struct notif_event
*r
= (struct notif_event
*) XNEW (struct stop_reply
);
6435 r
->dtr
= stop_reply_dtr
;
6440 /* A client of notification Stop. */
6442 struct notif_client notif_client_stop
=
6446 remote_notif_stop_parse
,
6447 remote_notif_stop_ack
,
6448 remote_notif_stop_can_get_pending_events
,
6449 remote_notif_stop_alloc_reply
,
6453 /* A parameter to pass data in and out. */
6455 struct queue_iter_param
6458 struct stop_reply
*output
;
6461 /* Determine if THREAD_PTID is a pending fork parent thread. ARG contains
6462 the pid of the process that owns the threads we want to check, or
6463 -1 if we want to check all threads. */
6466 is_pending_fork_parent (struct target_waitstatus
*ws
, int event_pid
,
6469 if (ws
->kind
== TARGET_WAITKIND_FORKED
6470 || ws
->kind
== TARGET_WAITKIND_VFORKED
)
6472 if (event_pid
== -1 || event_pid
== ptid_get_pid (thread_ptid
))
6479 /* Return the thread's pending status used to determine whether the
6480 thread is a fork parent stopped at a fork event. */
6482 static struct target_waitstatus
*
6483 thread_pending_fork_status (struct thread_info
*thread
)
6485 if (thread
->suspend
.waitstatus_pending_p
)
6486 return &thread
->suspend
.waitstatus
;
6488 return &thread
->pending_follow
;
6491 /* Determine if THREAD is a pending fork parent thread. */
6494 is_pending_fork_parent_thread (struct thread_info
*thread
)
6496 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6499 return is_pending_fork_parent (ws
, pid
, thread
->ptid
);
6502 /* Check whether EVENT is a fork event, and if it is, remove the
6503 fork child from the context list passed in DATA. */
6506 remove_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
6507 QUEUE_ITER (stop_reply_p
) *iter
,
6511 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6512 struct threads_listing_context
*context
6513 = (struct threads_listing_context
*) param
->input
;
6515 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6516 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
6517 || event
->ws
.kind
== TARGET_WAITKIND_THREAD_EXITED
)
6518 threads_listing_context_remove (&event
->ws
, context
);
6523 /* If CONTEXT contains any fork child threads that have not been
6524 reported yet, remove them from the CONTEXT list. If such a
6525 thread exists it is because we are stopped at a fork catchpoint
6526 and have not yet called follow_fork, which will set up the
6527 host-side data structures for the new process. */
6530 remove_new_fork_children (struct threads_listing_context
*context
)
6532 struct thread_info
* thread
;
6534 struct notif_client
*notif
= ¬if_client_stop
;
6535 struct queue_iter_param param
;
6537 /* For any threads stopped at a fork event, remove the corresponding
6538 fork child threads from the CONTEXT list. */
6539 ALL_NON_EXITED_THREADS (thread
)
6541 struct target_waitstatus
*ws
= thread_pending_fork_status (thread
);
6543 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
6545 threads_listing_context_remove (ws
, context
);
6549 /* Check for any pending fork events (not reported or processed yet)
6550 in process PID and remove those fork child threads from the
6551 CONTEXT list as well. */
6552 remote_notif_get_pending_events (notif
);
6553 param
.input
= context
;
6554 param
.output
= NULL
;
6555 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6556 remove_child_of_pending_fork
, ¶m
);
6559 /* Check whether EVENT would prevent a global or process wildcard
6563 check_pending_event_prevents_wildcard_vcont_callback
6564 (QUEUE (stop_reply_p
) *q
,
6565 QUEUE_ITER (stop_reply_p
) *iter
,
6569 struct inferior
*inf
;
6570 int *may_global_wildcard_vcont
= (int *) data
;
6572 if (event
->ws
.kind
== TARGET_WAITKIND_NO_RESUMED
6573 || event
->ws
.kind
== TARGET_WAITKIND_NO_HISTORY
)
6576 if (event
->ws
.kind
== TARGET_WAITKIND_FORKED
6577 || event
->ws
.kind
== TARGET_WAITKIND_VFORKED
)
6578 *may_global_wildcard_vcont
= 0;
6580 inf
= find_inferior_ptid (event
->ptid
);
6582 /* This may be the first time we heard about this process.
6583 Regardless, we must not do a global wildcard resume, otherwise
6584 we'd resume this process too. */
6585 *may_global_wildcard_vcont
= 0;
6587 inf
->priv
->may_wildcard_vcont
= 0;
6592 /* Check whether any event pending in the vStopped queue would prevent
6593 a global or process wildcard vCont action. Clear
6594 *may_global_wildcard if we can't do a global wildcard (vCont;c),
6595 and clear the event inferior's may_wildcard_vcont flag if we can't
6596 do a process-wide wildcard resume (vCont;c:pPID.-1). */
6599 check_pending_events_prevent_wildcard_vcont (int *may_global_wildcard
)
6601 struct notif_client
*notif
= ¬if_client_stop
;
6603 remote_notif_get_pending_events (notif
);
6604 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6605 check_pending_event_prevents_wildcard_vcont_callback
,
6606 may_global_wildcard
);
6609 /* Remove stop replies in the queue if its pid is equal to the given
6613 remove_stop_reply_for_inferior (QUEUE (stop_reply_p
) *q
,
6614 QUEUE_ITER (stop_reply_p
) *iter
,
6618 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6619 struct inferior
*inf
= (struct inferior
*) param
->input
;
6621 if (ptid_get_pid (event
->ptid
) == inf
->pid
)
6623 stop_reply_xfree (event
);
6624 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6630 /* Discard all pending stop replies of inferior INF. */
6633 discard_pending_stop_replies (struct inferior
*inf
)
6635 struct queue_iter_param param
;
6636 struct stop_reply
*reply
;
6637 struct remote_state
*rs
= get_remote_state ();
6638 struct remote_notif_state
*rns
= rs
->notif_state
;
6640 /* This function can be notified when an inferior exists. When the
6641 target is not remote, the notification state is NULL. */
6642 if (rs
->remote_desc
== NULL
)
6645 reply
= (struct stop_reply
*) rns
->pending_event
[notif_client_stop
.id
];
6647 /* Discard the in-flight notification. */
6648 if (reply
!= NULL
&& ptid_get_pid (reply
->ptid
) == inf
->pid
)
6650 stop_reply_xfree (reply
);
6651 rns
->pending_event
[notif_client_stop
.id
] = NULL
;
6655 param
.output
= NULL
;
6656 /* Discard the stop replies we have already pulled with
6658 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6659 remove_stop_reply_for_inferior
, ¶m
);
6662 /* If its remote state is equal to the given remote state,
6663 remove EVENT from the stop reply queue. */
6666 remove_stop_reply_of_remote_state (QUEUE (stop_reply_p
) *q
,
6667 QUEUE_ITER (stop_reply_p
) *iter
,
6671 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6672 struct remote_state
*rs
= (struct remote_state
*) param
->input
;
6674 if (event
->rs
== rs
)
6676 stop_reply_xfree (event
);
6677 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6683 /* Discard the stop replies for RS in stop_reply_queue. */
6686 discard_pending_stop_replies_in_queue (struct remote_state
*rs
)
6688 struct queue_iter_param param
;
6691 param
.output
= NULL
;
6692 /* Discard the stop replies we have already pulled with
6694 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6695 remove_stop_reply_of_remote_state
, ¶m
);
6698 /* A parameter to pass data in and out. */
6701 remote_notif_remove_once_on_match (QUEUE (stop_reply_p
) *q
,
6702 QUEUE_ITER (stop_reply_p
) *iter
,
6706 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
6707 ptid_t
*ptid
= (ptid_t
*) param
->input
;
6709 if (ptid_match (event
->ptid
, *ptid
))
6711 param
->output
= event
;
6712 QUEUE_remove_elem (stop_reply_p
, q
, iter
);
6719 /* Remove the first reply in 'stop_reply_queue' which matches
6722 static struct stop_reply
*
6723 remote_notif_remove_queued_reply (ptid_t ptid
)
6725 struct queue_iter_param param
;
6727 param
.input
= &ptid
;
6728 param
.output
= NULL
;
6730 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6731 remote_notif_remove_once_on_match
, ¶m
);
6733 fprintf_unfiltered (gdb_stdlog
,
6734 "notif: discard queued event: 'Stop' in %s\n",
6735 target_pid_to_str (ptid
));
6737 return param
.output
;
6740 /* Look for a queued stop reply belonging to PTID. If one is found,
6741 remove it from the queue, and return it. Returns NULL if none is
6742 found. If there are still queued events left to process, tell the
6743 event loop to get back to target_wait soon. */
6745 static struct stop_reply
*
6746 queued_stop_reply (ptid_t ptid
)
6748 struct stop_reply
*r
= remote_notif_remove_queued_reply (ptid
);
6750 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
6751 /* There's still at least an event left. */
6752 mark_async_event_handler (remote_async_inferior_event_token
);
6757 /* Push a fully parsed stop reply in the stop reply queue. Since we
6758 know that we now have at least one queued event left to pass to the
6759 core side, tell the event loop to get back to target_wait soon. */
6762 push_stop_reply (struct stop_reply
*new_event
)
6764 QUEUE_enque (stop_reply_p
, stop_reply_queue
, new_event
);
6767 fprintf_unfiltered (gdb_stdlog
,
6768 "notif: push 'Stop' %s to queue %d\n",
6769 target_pid_to_str (new_event
->ptid
),
6770 QUEUE_length (stop_reply_p
,
6773 mark_async_event_handler (remote_async_inferior_event_token
);
6777 stop_reply_match_ptid_and_ws (QUEUE (stop_reply_p
) *q
,
6778 QUEUE_ITER (stop_reply_p
) *iter
,
6779 struct stop_reply
*event
,
6782 ptid_t
*ptid
= (ptid_t
*) data
;
6784 return !(ptid_equal (*ptid
, event
->ptid
)
6785 && event
->ws
.kind
== TARGET_WAITKIND_STOPPED
);
6788 /* Returns true if we have a stop reply for PTID. */
6791 peek_stop_reply (ptid_t ptid
)
6793 return !QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
6794 stop_reply_match_ptid_and_ws
, &ptid
);
6797 /* Helper for remote_parse_stop_reply. Return nonzero if the substring
6798 starting with P and ending with PEND matches PREFIX. */
6801 strprefix (const char *p
, const char *pend
, const char *prefix
)
6803 for ( ; p
< pend
; p
++, prefix
++)
6806 return *prefix
== '\0';
6809 /* Parse the stop reply in BUF. Either the function succeeds, and the
6810 result is stored in EVENT, or throws an error. */
6813 remote_parse_stop_reply (char *buf
, struct stop_reply
*event
)
6815 struct remote_arch_state
*rsa
= get_remote_arch_state ();
6820 event
->ptid
= null_ptid
;
6821 event
->rs
= get_remote_state ();
6822 event
->ws
.kind
= TARGET_WAITKIND_IGNORE
;
6823 event
->ws
.value
.integer
= 0;
6824 event
->stop_reason
= TARGET_STOPPED_BY_NO_REASON
;
6825 event
->regcache
= NULL
;
6830 case 'T': /* Status with PC, SP, FP, ... */
6831 /* Expedited reply, containing Signal, {regno, reg} repeat. */
6832 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
6834 n... = register number
6835 r... = register contents
6838 p
= &buf
[3]; /* after Txx */
6844 p1
= strchr (p
, ':');
6846 error (_("Malformed packet(a) (missing colon): %s\n\
6850 error (_("Malformed packet(a) (missing register number): %s\n\
6854 /* Some "registers" are actually extended stop information.
6855 Note if you're adding a new entry here: GDB 7.9 and
6856 earlier assume that all register "numbers" that start
6857 with an hex digit are real register numbers. Make sure
6858 the server only sends such a packet if it knows the
6859 client understands it. */
6861 if (strprefix (p
, p1
, "thread"))
6862 event
->ptid
= read_ptid (++p1
, &p
);
6863 else if (strprefix (p
, p1
, "syscall_entry"))
6867 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_ENTRY
;
6868 p
= unpack_varlen_hex (++p1
, &sysno
);
6869 event
->ws
.value
.syscall_number
= (int) sysno
;
6871 else if (strprefix (p
, p1
, "syscall_return"))
6875 event
->ws
.kind
= TARGET_WAITKIND_SYSCALL_RETURN
;
6876 p
= unpack_varlen_hex (++p1
, &sysno
);
6877 event
->ws
.value
.syscall_number
= (int) sysno
;
6879 else if (strprefix (p
, p1
, "watch")
6880 || strprefix (p
, p1
, "rwatch")
6881 || strprefix (p
, p1
, "awatch"))
6883 event
->stop_reason
= TARGET_STOPPED_BY_WATCHPOINT
;
6884 p
= unpack_varlen_hex (++p1
, &addr
);
6885 event
->watch_data_address
= (CORE_ADDR
) addr
;
6887 else if (strprefix (p
, p1
, "swbreak"))
6889 event
->stop_reason
= TARGET_STOPPED_BY_SW_BREAKPOINT
;
6891 /* Make sure the stub doesn't forget to indicate support
6893 if (packet_support (PACKET_swbreak_feature
) != PACKET_ENABLE
)
6894 error (_("Unexpected swbreak stop reason"));
6896 /* The value part is documented as "must be empty",
6897 though we ignore it, in case we ever decide to make
6898 use of it in a backward compatible way. */
6899 p
= strchrnul (p1
+ 1, ';');
6901 else if (strprefix (p
, p1
, "hwbreak"))
6903 event
->stop_reason
= TARGET_STOPPED_BY_HW_BREAKPOINT
;
6905 /* Make sure the stub doesn't forget to indicate support
6907 if (packet_support (PACKET_hwbreak_feature
) != PACKET_ENABLE
)
6908 error (_("Unexpected hwbreak stop reason"));
6911 p
= strchrnul (p1
+ 1, ';');
6913 else if (strprefix (p
, p1
, "library"))
6915 event
->ws
.kind
= TARGET_WAITKIND_LOADED
;
6916 p
= strchrnul (p1
+ 1, ';');
6918 else if (strprefix (p
, p1
, "replaylog"))
6920 event
->ws
.kind
= TARGET_WAITKIND_NO_HISTORY
;
6921 /* p1 will indicate "begin" or "end", but it makes
6922 no difference for now, so ignore it. */
6923 p
= strchrnul (p1
+ 1, ';');
6925 else if (strprefix (p
, p1
, "core"))
6929 p
= unpack_varlen_hex (++p1
, &c
);
6932 else if (strprefix (p
, p1
, "fork"))
6934 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6935 event
->ws
.kind
= TARGET_WAITKIND_FORKED
;
6937 else if (strprefix (p
, p1
, "vfork"))
6939 event
->ws
.value
.related_pid
= read_ptid (++p1
, &p
);
6940 event
->ws
.kind
= TARGET_WAITKIND_VFORKED
;
6942 else if (strprefix (p
, p1
, "vforkdone"))
6944 event
->ws
.kind
= TARGET_WAITKIND_VFORK_DONE
;
6945 p
= strchrnul (p1
+ 1, ';');
6947 else if (strprefix (p
, p1
, "exec"))
6950 char pathname
[PATH_MAX
];
6953 /* Determine the length of the execd pathname. */
6954 p
= unpack_varlen_hex (++p1
, &ignored
);
6955 pathlen
= (p
- p1
) / 2;
6957 /* Save the pathname for event reporting and for
6958 the next run command. */
6959 hex2bin (p1
, (gdb_byte
*) pathname
, pathlen
);
6960 pathname
[pathlen
] = '\0';
6962 /* This is freed during event handling. */
6963 event
->ws
.value
.execd_pathname
= xstrdup (pathname
);
6964 event
->ws
.kind
= TARGET_WAITKIND_EXECD
;
6966 /* Skip the registers included in this packet, since
6967 they may be for an architecture different from the
6968 one used by the original program. */
6971 else if (strprefix (p
, p1
, "create"))
6973 event
->ws
.kind
= TARGET_WAITKIND_THREAD_CREATED
;
6974 p
= strchrnul (p1
+ 1, ';');
6983 p
= strchrnul (p1
+ 1, ';');
6988 /* Maybe a real ``P'' register number. */
6989 p_temp
= unpack_varlen_hex (p
, &pnum
);
6990 /* If the first invalid character is the colon, we got a
6991 register number. Otherwise, it's an unknown stop
6995 struct packet_reg
*reg
= packet_reg_from_pnum (rsa
, pnum
);
6996 cached_reg_t cached_reg
;
6997 struct gdbarch
*gdbarch
= target_gdbarch ();
7000 error (_("Remote sent bad register number %s: %s\n\
7002 hex_string (pnum
), p
, buf
);
7004 cached_reg
.num
= reg
->regnum
;
7005 cached_reg
.data
= (gdb_byte
*)
7006 xmalloc (register_size (gdbarch
, reg
->regnum
));
7009 fieldsize
= hex2bin (p
, cached_reg
.data
,
7010 register_size (gdbarch
, reg
->regnum
));
7012 if (fieldsize
< register_size (gdbarch
, reg
->regnum
))
7013 warning (_("Remote reply is too short: %s"), buf
);
7015 VEC_safe_push (cached_reg_t
, event
->regcache
, &cached_reg
);
7019 /* Not a number. Silently skip unknown optional
7021 p
= strchrnul (p1
+ 1, ';');
7026 error (_("Remote register badly formatted: %s\nhere: %s"),
7031 if (event
->ws
.kind
!= TARGET_WAITKIND_IGNORE
)
7035 case 'S': /* Old style status, just signal only. */
7039 event
->ws
.kind
= TARGET_WAITKIND_STOPPED
;
7040 sig
= (fromhex (buf
[1]) << 4) + fromhex (buf
[2]);
7041 if (GDB_SIGNAL_FIRST
<= sig
&& sig
< GDB_SIGNAL_LAST
)
7042 event
->ws
.value
.sig
= (enum gdb_signal
) sig
;
7044 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7047 case 'w': /* Thread exited. */
7052 event
->ws
.kind
= TARGET_WAITKIND_THREAD_EXITED
;
7053 p
= unpack_varlen_hex (&buf
[1], &value
);
7054 event
->ws
.value
.integer
= value
;
7056 error (_("stop reply packet badly formatted: %s"), buf
);
7057 event
->ptid
= read_ptid (++p
, NULL
);
7060 case 'W': /* Target exited. */
7067 /* GDB used to accept only 2 hex chars here. Stubs should
7068 only send more if they detect GDB supports multi-process
7070 p
= unpack_varlen_hex (&buf
[1], &value
);
7074 /* The remote process exited. */
7075 event
->ws
.kind
= TARGET_WAITKIND_EXITED
;
7076 event
->ws
.value
.integer
= value
;
7080 /* The remote process exited with a signal. */
7081 event
->ws
.kind
= TARGET_WAITKIND_SIGNALLED
;
7082 if (GDB_SIGNAL_FIRST
<= value
&& value
< GDB_SIGNAL_LAST
)
7083 event
->ws
.value
.sig
= (enum gdb_signal
) value
;
7085 event
->ws
.value
.sig
= GDB_SIGNAL_UNKNOWN
;
7088 /* If no process is specified, assume inferior_ptid. */
7089 pid
= ptid_get_pid (inferior_ptid
);
7098 else if (startswith (p
, "process:"))
7102 p
+= sizeof ("process:") - 1;
7103 unpack_varlen_hex (p
, &upid
);
7107 error (_("unknown stop reply packet: %s"), buf
);
7110 error (_("unknown stop reply packet: %s"), buf
);
7111 event
->ptid
= pid_to_ptid (pid
);
7115 event
->ws
.kind
= TARGET_WAITKIND_NO_RESUMED
;
7116 event
->ptid
= minus_one_ptid
;
7120 if (target_is_non_stop_p () && ptid_equal (event
->ptid
, null_ptid
))
7121 error (_("No process or thread specified in stop reply: %s"), buf
);
7124 /* When the stub wants to tell GDB about a new notification reply, it
7125 sends a notification (%Stop, for example). Those can come it at
7126 any time, hence, we have to make sure that any pending
7127 putpkt/getpkt sequence we're making is finished, before querying
7128 the stub for more events with the corresponding ack command
7129 (vStopped, for example). E.g., if we started a vStopped sequence
7130 immediately upon receiving the notification, something like this
7138 1.6) <-- (registers reply to step #1.3)
7140 Obviously, the reply in step #1.6 would be unexpected to a vStopped
7143 To solve this, whenever we parse a %Stop notification successfully,
7144 we mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN, and carry on
7145 doing whatever we were doing:
7151 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
7152 2.5) <-- (registers reply to step #2.3)
7154 Eventualy after step #2.5, we return to the event loop, which
7155 notices there's an event on the
7156 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN event and calls the
7157 associated callback --- the function below. At this point, we're
7158 always safe to start a vStopped sequence. :
7161 2.7) <-- T05 thread:2
7167 remote_notif_get_pending_events (struct notif_client
*nc
)
7169 struct remote_state
*rs
= get_remote_state ();
7171 if (rs
->notif_state
->pending_event
[nc
->id
] != NULL
)
7174 fprintf_unfiltered (gdb_stdlog
,
7175 "notif: process: '%s' ack pending event\n",
7179 nc
->ack (nc
, rs
->buf
, rs
->notif_state
->pending_event
[nc
->id
]);
7180 rs
->notif_state
->pending_event
[nc
->id
] = NULL
;
7184 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7185 if (strcmp (rs
->buf
, "OK") == 0)
7188 remote_notif_ack (nc
, rs
->buf
);
7194 fprintf_unfiltered (gdb_stdlog
,
7195 "notif: process: '%s' no pending reply\n",
7200 /* Called when it is decided that STOP_REPLY holds the info of the
7201 event that is to be returned to the core. This function always
7202 destroys STOP_REPLY. */
7205 process_stop_reply (struct stop_reply
*stop_reply
,
7206 struct target_waitstatus
*status
)
7210 *status
= stop_reply
->ws
;
7211 ptid
= stop_reply
->ptid
;
7213 /* If no thread/process was reported by the stub, assume the current
7215 if (ptid_equal (ptid
, null_ptid
))
7216 ptid
= inferior_ptid
;
7218 if (status
->kind
!= TARGET_WAITKIND_EXITED
7219 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
7220 && status
->kind
!= TARGET_WAITKIND_NO_RESUMED
)
7222 struct private_thread_info
*remote_thr
;
7224 /* Expedited registers. */
7225 if (stop_reply
->regcache
)
7227 struct regcache
*regcache
7228 = get_thread_arch_regcache (ptid
, target_gdbarch ());
7233 VEC_iterate (cached_reg_t
, stop_reply
->regcache
, ix
, reg
);
7236 regcache_raw_supply (regcache
, reg
->num
, reg
->data
);
7240 VEC_free (cached_reg_t
, stop_reply
->regcache
);
7243 remote_notice_new_inferior (ptid
, 0);
7244 remote_thr
= get_private_info_ptid (ptid
);
7245 remote_thr
->core
= stop_reply
->core
;
7246 remote_thr
->stop_reason
= stop_reply
->stop_reason
;
7247 remote_thr
->watch_data_address
= stop_reply
->watch_data_address
;
7248 remote_thr
->vcont_resumed
= 0;
7251 stop_reply_xfree (stop_reply
);
7255 /* The non-stop mode version of target_wait. */
7258 remote_wait_ns (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7260 struct remote_state
*rs
= get_remote_state ();
7261 struct stop_reply
*stop_reply
;
7265 /* If in non-stop mode, get out of getpkt even if a
7266 notification is received. */
7268 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7269 0 /* forever */, &is_notif
);
7272 if (ret
!= -1 && !is_notif
)
7275 case 'E': /* Error of some sort. */
7276 /* We're out of sync with the target now. Did it continue
7277 or not? We can't tell which thread it was in non-stop,
7278 so just ignore this. */
7279 warning (_("Remote failure reply: %s"), rs
->buf
);
7281 case 'O': /* Console output. */
7282 remote_console_output (rs
->buf
+ 1);
7285 warning (_("Invalid remote reply: %s"), rs
->buf
);
7289 /* Acknowledge a pending stop reply that may have arrived in the
7291 if (rs
->notif_state
->pending_event
[notif_client_stop
.id
] != NULL
)
7292 remote_notif_get_pending_events (¬if_client_stop
);
7294 /* If indeed we noticed a stop reply, we're done. */
7295 stop_reply
= queued_stop_reply (ptid
);
7296 if (stop_reply
!= NULL
)
7297 return process_stop_reply (stop_reply
, status
);
7299 /* Still no event. If we're just polling for an event, then
7300 return to the event loop. */
7301 if (options
& TARGET_WNOHANG
)
7303 status
->kind
= TARGET_WAITKIND_IGNORE
;
7304 return minus_one_ptid
;
7307 /* Otherwise do a blocking wait. */
7308 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7309 1 /* forever */, &is_notif
);
7313 /* Wait until the remote machine stops, then return, storing status in
7314 STATUS just as `wait' would. */
7317 remote_wait_as (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7319 struct remote_state
*rs
= get_remote_state ();
7320 ptid_t event_ptid
= null_ptid
;
7322 struct stop_reply
*stop_reply
;
7326 status
->kind
= TARGET_WAITKIND_IGNORE
;
7327 status
->value
.integer
= 0;
7329 stop_reply
= queued_stop_reply (ptid
);
7330 if (stop_reply
!= NULL
)
7331 return process_stop_reply (stop_reply
, status
);
7333 if (rs
->cached_wait_status
)
7334 /* Use the cached wait status, but only once. */
7335 rs
->cached_wait_status
= 0;
7340 int forever
= ((options
& TARGET_WNOHANG
) == 0
7341 && wait_forever_enabled_p
);
7343 if (!rs
->waiting_for_stop_reply
)
7345 status
->kind
= TARGET_WAITKIND_NO_RESUMED
;
7346 return minus_one_ptid
;
7349 /* FIXME: cagney/1999-09-27: If we're in async mode we should
7350 _never_ wait for ever -> test on target_is_async_p().
7351 However, before we do that we need to ensure that the caller
7352 knows how to take the target into/out of async mode. */
7353 ret
= getpkt_or_notif_sane (&rs
->buf
, &rs
->buf_size
,
7354 forever
, &is_notif
);
7356 /* GDB gets a notification. Return to core as this event is
7358 if (ret
!= -1 && is_notif
)
7359 return minus_one_ptid
;
7361 if (ret
== -1 && (options
& TARGET_WNOHANG
) != 0)
7362 return minus_one_ptid
;
7367 /* Assume that the target has acknowledged Ctrl-C unless we receive
7368 an 'F' or 'O' packet. */
7369 if (buf
[0] != 'F' && buf
[0] != 'O')
7370 rs
->ctrlc_pending_p
= 0;
7374 case 'E': /* Error of some sort. */
7375 /* We're out of sync with the target now. Did it continue or
7376 not? Not is more likely, so report a stop. */
7377 rs
->waiting_for_stop_reply
= 0;
7379 warning (_("Remote failure reply: %s"), buf
);
7380 status
->kind
= TARGET_WAITKIND_STOPPED
;
7381 status
->value
.sig
= GDB_SIGNAL_0
;
7383 case 'F': /* File-I/O request. */
7384 /* GDB may access the inferior memory while handling the File-I/O
7385 request, but we don't want GDB accessing memory while waiting
7386 for a stop reply. See the comments in putpkt_binary. Set
7387 waiting_for_stop_reply to 0 temporarily. */
7388 rs
->waiting_for_stop_reply
= 0;
7389 remote_fileio_request (buf
, rs
->ctrlc_pending_p
);
7390 rs
->ctrlc_pending_p
= 0;
7391 /* GDB handled the File-I/O request, and the target is running
7392 again. Keep waiting for events. */
7393 rs
->waiting_for_stop_reply
= 1;
7395 case 'N': case 'T': case 'S': case 'X': case 'W':
7397 struct stop_reply
*stop_reply
;
7399 /* There is a stop reply to handle. */
7400 rs
->waiting_for_stop_reply
= 0;
7403 = (struct stop_reply
*) remote_notif_parse (¬if_client_stop
,
7406 event_ptid
= process_stop_reply (stop_reply
, status
);
7409 case 'O': /* Console output. */
7410 remote_console_output (buf
+ 1);
7413 if (rs
->last_sent_signal
!= GDB_SIGNAL_0
)
7415 /* Zero length reply means that we tried 'S' or 'C' and the
7416 remote system doesn't support it. */
7417 target_terminal_ours_for_output ();
7419 ("Can't send signals to this remote system. %s not sent.\n",
7420 gdb_signal_to_name (rs
->last_sent_signal
));
7421 rs
->last_sent_signal
= GDB_SIGNAL_0
;
7422 target_terminal_inferior ();
7424 strcpy (buf
, rs
->last_sent_step
? "s" : "c");
7428 /* else fallthrough */
7430 warning (_("Invalid remote reply: %s"), buf
);
7434 if (status
->kind
== TARGET_WAITKIND_NO_RESUMED
)
7435 return minus_one_ptid
;
7436 else if (status
->kind
== TARGET_WAITKIND_IGNORE
)
7438 /* Nothing interesting happened. If we're doing a non-blocking
7439 poll, we're done. Otherwise, go back to waiting. */
7440 if (options
& TARGET_WNOHANG
)
7441 return minus_one_ptid
;
7445 else if (status
->kind
!= TARGET_WAITKIND_EXITED
7446 && status
->kind
!= TARGET_WAITKIND_SIGNALLED
)
7448 if (!ptid_equal (event_ptid
, null_ptid
))
7449 record_currthread (rs
, event_ptid
);
7451 event_ptid
= inferior_ptid
;
7454 /* A process exit. Invalidate our notion of current thread. */
7455 record_currthread (rs
, minus_one_ptid
);
7460 /* Wait until the remote machine stops, then return, storing status in
7461 STATUS just as `wait' would. */
7464 remote_wait (struct target_ops
*ops
,
7465 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
7469 if (target_is_non_stop_p ())
7470 event_ptid
= remote_wait_ns (ptid
, status
, options
);
7472 event_ptid
= remote_wait_as (ptid
, status
, options
);
7474 if (target_is_async_p ())
7476 /* If there are are events left in the queue tell the event loop
7478 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
7479 mark_async_event_handler (remote_async_inferior_event_token
);
7485 /* Fetch a single register using a 'p' packet. */
7488 fetch_register_using_p (struct regcache
*regcache
, struct packet_reg
*reg
)
7490 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7491 struct remote_state
*rs
= get_remote_state ();
7493 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7496 if (packet_support (PACKET_p
) == PACKET_DISABLE
)
7499 if (reg
->pnum
== -1)
7504 p
+= hexnumstr (p
, reg
->pnum
);
7507 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7511 switch (packet_ok (buf
, &remote_protocol_packets
[PACKET_p
]))
7515 case PACKET_UNKNOWN
:
7518 error (_("Could not fetch register \"%s\"; remote failure reply '%s'"),
7519 gdbarch_register_name (get_regcache_arch (regcache
),
7524 /* If this register is unfetchable, tell the regcache. */
7527 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7531 /* Otherwise, parse and supply the value. */
7537 error (_("fetch_register_using_p: early buf termination"));
7539 regp
[i
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7542 regcache_raw_supply (regcache
, reg
->regnum
, regp
);
7546 /* Fetch the registers included in the target's 'g' packet. */
7549 send_g_packet (void)
7551 struct remote_state
*rs
= get_remote_state ();
7554 xsnprintf (rs
->buf
, get_remote_packet_size (), "g");
7555 remote_send (&rs
->buf
, &rs
->buf_size
);
7557 /* We can get out of synch in various cases. If the first character
7558 in the buffer is not a hex character, assume that has happened
7559 and try to fetch another packet to read. */
7560 while ((rs
->buf
[0] < '0' || rs
->buf
[0] > '9')
7561 && (rs
->buf
[0] < 'A' || rs
->buf
[0] > 'F')
7562 && (rs
->buf
[0] < 'a' || rs
->buf
[0] > 'f')
7563 && rs
->buf
[0] != 'x') /* New: unavailable register value. */
7566 fprintf_unfiltered (gdb_stdlog
,
7567 "Bad register packet; fetching a new packet\n");
7568 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7571 buf_len
= strlen (rs
->buf
);
7573 /* Sanity check the received packet. */
7574 if (buf_len
% 2 != 0)
7575 error (_("Remote 'g' packet reply is of odd length: %s"), rs
->buf
);
7581 process_g_packet (struct regcache
*regcache
)
7583 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7584 struct remote_state
*rs
= get_remote_state ();
7585 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7590 buf_len
= strlen (rs
->buf
);
7592 /* Further sanity checks, with knowledge of the architecture. */
7593 if (buf_len
> 2 * rsa
->sizeof_g_packet
)
7594 error (_("Remote 'g' packet reply is too long: %s"), rs
->buf
);
7596 /* Save the size of the packet sent to us by the target. It is used
7597 as a heuristic when determining the max size of packets that the
7598 target can safely receive. */
7599 if (rsa
->actual_register_packet_size
== 0)
7600 rsa
->actual_register_packet_size
= buf_len
;
7602 /* If this is smaller than we guessed the 'g' packet would be,
7603 update our records. A 'g' reply that doesn't include a register's
7604 value implies either that the register is not available, or that
7605 the 'p' packet must be used. */
7606 if (buf_len
< 2 * rsa
->sizeof_g_packet
)
7608 long sizeof_g_packet
= buf_len
/ 2;
7610 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7612 long offset
= rsa
->regs
[i
].offset
;
7613 long reg_size
= register_size (gdbarch
, i
);
7615 if (rsa
->regs
[i
].pnum
== -1)
7618 if (offset
>= sizeof_g_packet
)
7619 rsa
->regs
[i
].in_g_packet
= 0;
7620 else if (offset
+ reg_size
> sizeof_g_packet
)
7621 error (_("Truncated register %d in remote 'g' packet"), i
);
7623 rsa
->regs
[i
].in_g_packet
= 1;
7626 /* Looks valid enough, we can assume this is the correct length
7627 for a 'g' packet. It's important not to adjust
7628 rsa->sizeof_g_packet if we have truncated registers otherwise
7629 this "if" won't be run the next time the method is called
7630 with a packet of the same size and one of the internal errors
7631 below will trigger instead. */
7632 rsa
->sizeof_g_packet
= sizeof_g_packet
;
7635 regs
= (char *) alloca (rsa
->sizeof_g_packet
);
7637 /* Unimplemented registers read as all bits zero. */
7638 memset (regs
, 0, rsa
->sizeof_g_packet
);
7640 /* Reply describes registers byte by byte, each byte encoded as two
7641 hex characters. Suck them all up, then supply them to the
7642 register cacheing/storage mechanism. */
7645 for (i
= 0; i
< rsa
->sizeof_g_packet
; i
++)
7647 if (p
[0] == 0 || p
[1] == 0)
7648 /* This shouldn't happen - we adjusted sizeof_g_packet above. */
7649 internal_error (__FILE__
, __LINE__
,
7650 _("unexpected end of 'g' packet reply"));
7652 if (p
[0] == 'x' && p
[1] == 'x')
7653 regs
[i
] = 0; /* 'x' */
7655 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
7659 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
7661 struct packet_reg
*r
= &rsa
->regs
[i
];
7662 long reg_size
= register_size (gdbarch
, i
);
7666 if ((r
->offset
+ reg_size
) * 2 > strlen (rs
->buf
))
7667 /* This shouldn't happen - we adjusted in_g_packet above. */
7668 internal_error (__FILE__
, __LINE__
,
7669 _("unexpected end of 'g' packet reply"));
7670 else if (rs
->buf
[r
->offset
* 2] == 'x')
7672 gdb_assert (r
->offset
* 2 < strlen (rs
->buf
));
7673 /* The register isn't available, mark it as such (at
7674 the same time setting the value to zero). */
7675 regcache_raw_supply (regcache
, r
->regnum
, NULL
);
7678 regcache_raw_supply (regcache
, r
->regnum
,
7685 fetch_registers_using_g (struct regcache
*regcache
)
7688 process_g_packet (regcache
);
7691 /* Make the remote selected traceframe match GDB's selected
7695 set_remote_traceframe (void)
7698 struct remote_state
*rs
= get_remote_state ();
7700 if (rs
->remote_traceframe_number
== get_traceframe_number ())
7703 /* Avoid recursion, remote_trace_find calls us again. */
7704 rs
->remote_traceframe_number
= get_traceframe_number ();
7706 newnum
= target_trace_find (tfind_number
,
7707 get_traceframe_number (), 0, 0, NULL
);
7709 /* Should not happen. If it does, all bets are off. */
7710 if (newnum
!= get_traceframe_number ())
7711 warning (_("could not set remote traceframe"));
7715 remote_fetch_registers (struct target_ops
*ops
,
7716 struct regcache
*regcache
, int regnum
)
7718 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7721 set_remote_traceframe ();
7722 set_general_thread (regcache_get_ptid (regcache
));
7726 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7728 gdb_assert (reg
!= NULL
);
7730 /* If this register might be in the 'g' packet, try that first -
7731 we are likely to read more than one register. If this is the
7732 first 'g' packet, we might be overly optimistic about its
7733 contents, so fall back to 'p'. */
7734 if (reg
->in_g_packet
)
7736 fetch_registers_using_g (regcache
);
7737 if (reg
->in_g_packet
)
7741 if (fetch_register_using_p (regcache
, reg
))
7744 /* This register is not available. */
7745 regcache_raw_supply (regcache
, reg
->regnum
, NULL
);
7750 fetch_registers_using_g (regcache
);
7752 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7753 if (!rsa
->regs
[i
].in_g_packet
)
7754 if (!fetch_register_using_p (regcache
, &rsa
->regs
[i
]))
7756 /* This register is not available. */
7757 regcache_raw_supply (regcache
, i
, NULL
);
7761 /* Prepare to store registers. Since we may send them all (using a
7762 'G' request), we have to read out the ones we don't want to change
7766 remote_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
7768 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7771 /* Make sure the entire registers array is valid. */
7772 switch (packet_support (PACKET_P
))
7774 case PACKET_DISABLE
:
7775 case PACKET_SUPPORT_UNKNOWN
:
7776 /* Make sure all the necessary registers are cached. */
7777 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7778 if (rsa
->regs
[i
].in_g_packet
)
7779 regcache_raw_update (regcache
, rsa
->regs
[i
].regnum
);
7786 /* Helper: Attempt to store REGNUM using the P packet. Return fail IFF
7787 packet was not recognized. */
7790 store_register_using_P (const struct regcache
*regcache
,
7791 struct packet_reg
*reg
)
7793 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
7794 struct remote_state
*rs
= get_remote_state ();
7795 /* Try storing a single register. */
7796 char *buf
= rs
->buf
;
7797 gdb_byte
*regp
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
->regnum
));
7800 if (packet_support (PACKET_P
) == PACKET_DISABLE
)
7803 if (reg
->pnum
== -1)
7806 xsnprintf (buf
, get_remote_packet_size (), "P%s=", phex_nz (reg
->pnum
, 0));
7807 p
= buf
+ strlen (buf
);
7808 regcache_raw_collect (regcache
, reg
->regnum
, regp
);
7809 bin2hex (regp
, p
, register_size (gdbarch
, reg
->regnum
));
7811 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7813 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_P
]))
7818 error (_("Could not write register \"%s\"; remote failure reply '%s'"),
7819 gdbarch_register_name (gdbarch
, reg
->regnum
), rs
->buf
);
7820 case PACKET_UNKNOWN
:
7823 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
7827 /* Store register REGNUM, or all registers if REGNUM == -1, from the
7828 contents of the register cache buffer. FIXME: ignores errors. */
7831 store_registers_using_G (const struct regcache
*regcache
)
7833 struct remote_state
*rs
= get_remote_state ();
7834 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7838 /* Extract all the registers in the regcache copying them into a
7843 regs
= (gdb_byte
*) alloca (rsa
->sizeof_g_packet
);
7844 memset (regs
, 0, rsa
->sizeof_g_packet
);
7845 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7847 struct packet_reg
*r
= &rsa
->regs
[i
];
7850 regcache_raw_collect (regcache
, r
->regnum
, regs
+ r
->offset
);
7854 /* Command describes registers byte by byte,
7855 each byte encoded as two hex characters. */
7858 bin2hex (regs
, p
, rsa
->sizeof_g_packet
);
7860 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
7861 if (packet_check_result (rs
->buf
) == PACKET_ERROR
)
7862 error (_("Could not write registers; remote failure reply '%s'"),
7866 /* Store register REGNUM, or all registers if REGNUM == -1, from the contents
7867 of the register cache buffer. FIXME: ignores errors. */
7870 remote_store_registers (struct target_ops
*ops
,
7871 struct regcache
*regcache
, int regnum
)
7873 struct remote_arch_state
*rsa
= get_remote_arch_state ();
7876 set_remote_traceframe ();
7877 set_general_thread (regcache_get_ptid (regcache
));
7881 struct packet_reg
*reg
= packet_reg_from_regnum (rsa
, regnum
);
7883 gdb_assert (reg
!= NULL
);
7885 /* Always prefer to store registers using the 'P' packet if
7886 possible; we often change only a small number of registers.
7887 Sometimes we change a larger number; we'd need help from a
7888 higher layer to know to use 'G'. */
7889 if (store_register_using_P (regcache
, reg
))
7892 /* For now, don't complain if we have no way to write the
7893 register. GDB loses track of unavailable registers too
7894 easily. Some day, this may be an error. We don't have
7895 any way to read the register, either... */
7896 if (!reg
->in_g_packet
)
7899 store_registers_using_G (regcache
);
7903 store_registers_using_G (regcache
);
7905 for (i
= 0; i
< gdbarch_num_regs (get_regcache_arch (regcache
)); i
++)
7906 if (!rsa
->regs
[i
].in_g_packet
)
7907 if (!store_register_using_P (regcache
, &rsa
->regs
[i
]))
7908 /* See above for why we do not issue an error here. */
7913 /* Return the number of hex digits in num. */
7916 hexnumlen (ULONGEST num
)
7920 for (i
= 0; num
!= 0; i
++)
7923 return std::max (i
, 1);
7926 /* Set BUF to the minimum number of hex digits representing NUM. */
7929 hexnumstr (char *buf
, ULONGEST num
)
7931 int len
= hexnumlen (num
);
7933 return hexnumnstr (buf
, num
, len
);
7937 /* Set BUF to the hex digits representing NUM, padded to WIDTH characters. */
7940 hexnumnstr (char *buf
, ULONGEST num
, int width
)
7946 for (i
= width
- 1; i
>= 0; i
--)
7948 buf
[i
] = "0123456789abcdef"[(num
& 0xf)];
7955 /* Mask all but the least significant REMOTE_ADDRESS_SIZE bits. */
7958 remote_address_masked (CORE_ADDR addr
)
7960 unsigned int address_size
= remote_address_size
;
7962 /* If "remoteaddresssize" was not set, default to target address size. */
7964 address_size
= gdbarch_addr_bit (target_gdbarch ());
7966 if (address_size
> 0
7967 && address_size
< (sizeof (ULONGEST
) * 8))
7969 /* Only create a mask when that mask can safely be constructed
7970 in a ULONGEST variable. */
7973 mask
= (mask
<< address_size
) - 1;
7979 /* Determine whether the remote target supports binary downloading.
7980 This is accomplished by sending a no-op memory write of zero length
7981 to the target at the specified address. It does not suffice to send
7982 the whole packet, since many stubs strip the eighth bit and
7983 subsequently compute a wrong checksum, which causes real havoc with
7986 NOTE: This can still lose if the serial line is not eight-bit
7987 clean. In cases like this, the user should clear "remote
7991 check_binary_download (CORE_ADDR addr
)
7993 struct remote_state
*rs
= get_remote_state ();
7995 switch (packet_support (PACKET_X
))
7997 case PACKET_DISABLE
:
8001 case PACKET_SUPPORT_UNKNOWN
:
8007 p
+= hexnumstr (p
, (ULONGEST
) addr
);
8009 p
+= hexnumstr (p
, (ULONGEST
) 0);
8013 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8014 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8016 if (rs
->buf
[0] == '\0')
8019 fprintf_unfiltered (gdb_stdlog
,
8020 "binary downloading NOT "
8021 "supported by target\n");
8022 remote_protocol_packets
[PACKET_X
].support
= PACKET_DISABLE
;
8027 fprintf_unfiltered (gdb_stdlog
,
8028 "binary downloading supported by target\n");
8029 remote_protocol_packets
[PACKET_X
].support
= PACKET_ENABLE
;
8036 /* Helper function to resize the payload in order to try to get a good
8037 alignment. We try to write an amount of data such that the next write will
8038 start on an address aligned on REMOTE_ALIGN_WRITES. */
8041 align_for_efficient_write (int todo
, CORE_ADDR memaddr
)
8043 return ((memaddr
+ todo
) & ~(REMOTE_ALIGN_WRITES
- 1)) - memaddr
;
8046 /* Write memory data directly to the remote machine.
8047 This does not inform the data cache; the data cache uses this.
8048 HEADER is the starting part of the packet.
8049 MEMADDR is the address in the remote memory space.
8050 MYADDR is the address of the buffer in our space.
8051 LEN_UNITS is the number of addressable units to write.
8052 UNIT_SIZE is the length in bytes of an addressable unit.
8053 PACKET_FORMAT should be either 'X' or 'M', and indicates if we
8054 should send data as binary ('X'), or hex-encoded ('M').
8056 The function creates packet of the form
8057 <HEADER><ADDRESS>,<LENGTH>:<DATA>
8059 where encoding of <DATA> is terminated by PACKET_FORMAT.
8061 If USE_LENGTH is 0, then the <LENGTH> field and the preceding comma
8064 Return the transferred status, error or OK (an
8065 'enum target_xfer_status' value). Save the number of addressable units
8066 transferred in *XFERED_LEN_UNITS. Only transfer a single packet.
8068 On a platform with an addressable memory size of 2 bytes (UNIT_SIZE == 2), an
8069 exchange between gdb and the stub could look like (?? in place of the
8075 -> $M1000,3:eeeeffffeeee#??
8079 <- eeeeffffeeeedddd */
8081 static enum target_xfer_status
8082 remote_write_bytes_aux (const char *header
, CORE_ADDR memaddr
,
8083 const gdb_byte
*myaddr
, ULONGEST len_units
,
8084 int unit_size
, ULONGEST
*xfered_len_units
,
8085 char packet_format
, int use_length
)
8087 struct remote_state
*rs
= get_remote_state ();
8093 int payload_capacity_bytes
;
8094 int payload_length_bytes
;
8096 if (packet_format
!= 'X' && packet_format
!= 'M')
8097 internal_error (__FILE__
, __LINE__
,
8098 _("remote_write_bytes_aux: bad packet format"));
8101 return TARGET_XFER_EOF
;
8103 payload_capacity_bytes
= get_memory_write_packet_size ();
8105 /* The packet buffer will be large enough for the payload;
8106 get_memory_packet_size ensures this. */
8109 /* Compute the size of the actual payload by subtracting out the
8110 packet header and footer overhead: "$M<memaddr>,<len>:...#nn". */
8112 payload_capacity_bytes
-= strlen ("$,:#NN");
8114 /* The comma won't be used. */
8115 payload_capacity_bytes
+= 1;
8116 payload_capacity_bytes
-= strlen (header
);
8117 payload_capacity_bytes
-= hexnumlen (memaddr
);
8119 /* Construct the packet excluding the data: "<header><memaddr>,<len>:". */
8121 strcat (rs
->buf
, header
);
8122 p
= rs
->buf
+ strlen (header
);
8124 /* Compute a best guess of the number of bytes actually transfered. */
8125 if (packet_format
== 'X')
8127 /* Best guess at number of bytes that will fit. */
8128 todo_units
= std::min (len_units
,
8129 (ULONGEST
) payload_capacity_bytes
/ unit_size
);
8131 payload_capacity_bytes
-= hexnumlen (todo_units
);
8132 todo_units
= std::min (todo_units
, payload_capacity_bytes
/ unit_size
);
8136 /* Number of bytes that will fit. */
8138 = std::min (len_units
,
8139 (ULONGEST
) (payload_capacity_bytes
/ unit_size
) / 2);
8141 payload_capacity_bytes
-= hexnumlen (todo_units
);
8142 todo_units
= std::min (todo_units
,
8143 (payload_capacity_bytes
/ unit_size
) / 2);
8146 if (todo_units
<= 0)
8147 internal_error (__FILE__
, __LINE__
,
8148 _("minimum packet size too small to write data"));
8150 /* If we already need another packet, then try to align the end
8151 of this packet to a useful boundary. */
8152 if (todo_units
> 2 * REMOTE_ALIGN_WRITES
&& todo_units
< len_units
)
8153 todo_units
= align_for_efficient_write (todo_units
, memaddr
);
8155 /* Append "<memaddr>". */
8156 memaddr
= remote_address_masked (memaddr
);
8157 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8164 /* Append the length and retain its location and size. It may need to be
8165 adjusted once the packet body has been created. */
8167 plenlen
= hexnumstr (p
, (ULONGEST
) todo_units
);
8175 /* Append the packet body. */
8176 if (packet_format
== 'X')
8178 /* Binary mode. Send target system values byte by byte, in
8179 increasing byte addresses. Only escape certain critical
8181 payload_length_bytes
=
8182 remote_escape_output (myaddr
, todo_units
, unit_size
, (gdb_byte
*) p
,
8183 &units_written
, payload_capacity_bytes
);
8185 /* If not all TODO units fit, then we'll need another packet. Make
8186 a second try to keep the end of the packet aligned. Don't do
8187 this if the packet is tiny. */
8188 if (units_written
< todo_units
&& units_written
> 2 * REMOTE_ALIGN_WRITES
)
8192 new_todo_units
= align_for_efficient_write (units_written
, memaddr
);
8194 if (new_todo_units
!= units_written
)
8195 payload_length_bytes
=
8196 remote_escape_output (myaddr
, new_todo_units
, unit_size
,
8197 (gdb_byte
*) p
, &units_written
,
8198 payload_capacity_bytes
);
8201 p
+= payload_length_bytes
;
8202 if (use_length
&& units_written
< todo_units
)
8204 /* Escape chars have filled up the buffer prematurely,
8205 and we have actually sent fewer units than planned.
8206 Fix-up the length field of the packet. Use the same
8207 number of characters as before. */
8208 plen
+= hexnumnstr (plen
, (ULONGEST
) units_written
,
8210 *plen
= ':'; /* overwrite \0 from hexnumnstr() */
8215 /* Normal mode: Send target system values byte by byte, in
8216 increasing byte addresses. Each byte is encoded as a two hex
8218 p
+= 2 * bin2hex (myaddr
, p
, todo_units
* unit_size
);
8219 units_written
= todo_units
;
8222 putpkt_binary (rs
->buf
, (int) (p
- rs
->buf
));
8223 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8225 if (rs
->buf
[0] == 'E')
8226 return TARGET_XFER_E_IO
;
8228 /* Return UNITS_WRITTEN, not TODO_UNITS, in case escape chars caused us to
8229 send fewer units than we'd planned. */
8230 *xfered_len_units
= (ULONGEST
) units_written
;
8231 return TARGET_XFER_OK
;
8234 /* Write memory data directly to the remote machine.
8235 This does not inform the data cache; the data cache uses this.
8236 MEMADDR is the address in the remote memory space.
8237 MYADDR is the address of the buffer in our space.
8238 LEN is the number of bytes.
8240 Return the transferred status, error or OK (an
8241 'enum target_xfer_status' value). Save the number of bytes
8242 transferred in *XFERED_LEN. Only transfer a single packet. */
8244 static enum target_xfer_status
8245 remote_write_bytes (CORE_ADDR memaddr
, const gdb_byte
*myaddr
, ULONGEST len
,
8246 int unit_size
, ULONGEST
*xfered_len
)
8248 const char *packet_format
= NULL
;
8250 /* Check whether the target supports binary download. */
8251 check_binary_download (memaddr
);
8253 switch (packet_support (PACKET_X
))
8256 packet_format
= "X";
8258 case PACKET_DISABLE
:
8259 packet_format
= "M";
8261 case PACKET_SUPPORT_UNKNOWN
:
8262 internal_error (__FILE__
, __LINE__
,
8263 _("remote_write_bytes: bad internal state"));
8265 internal_error (__FILE__
, __LINE__
, _("bad switch"));
8268 return remote_write_bytes_aux (packet_format
,
8269 memaddr
, myaddr
, len
, unit_size
, xfered_len
,
8270 packet_format
[0], 1);
8273 /* Read memory data directly from the remote machine.
8274 This does not use the data cache; the data cache uses this.
8275 MEMADDR is the address in the remote memory space.
8276 MYADDR is the address of the buffer in our space.
8277 LEN_UNITS is the number of addressable memory units to read..
8278 UNIT_SIZE is the length in bytes of an addressable unit.
8280 Return the transferred status, error or OK (an
8281 'enum target_xfer_status' value). Save the number of bytes
8282 transferred in *XFERED_LEN_UNITS.
8284 See the comment of remote_write_bytes_aux for an example of
8285 memory read/write exchange between gdb and the stub. */
8287 static enum target_xfer_status
8288 remote_read_bytes_1 (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ULONGEST len_units
,
8289 int unit_size
, ULONGEST
*xfered_len_units
)
8291 struct remote_state
*rs
= get_remote_state ();
8292 int buf_size_bytes
; /* Max size of packet output buffer. */
8297 buf_size_bytes
= get_memory_read_packet_size ();
8298 /* The packet buffer will be large enough for the payload;
8299 get_memory_packet_size ensures this. */
8301 /* Number of units that will fit. */
8302 todo_units
= std::min (len_units
,
8303 (ULONGEST
) (buf_size_bytes
/ unit_size
) / 2);
8305 /* Construct "m"<memaddr>","<len>". */
8306 memaddr
= remote_address_masked (memaddr
);
8309 p
+= hexnumstr (p
, (ULONGEST
) memaddr
);
8311 p
+= hexnumstr (p
, (ULONGEST
) todo_units
);
8314 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8315 if (rs
->buf
[0] == 'E'
8316 && isxdigit (rs
->buf
[1]) && isxdigit (rs
->buf
[2])
8317 && rs
->buf
[3] == '\0')
8318 return TARGET_XFER_E_IO
;
8319 /* Reply describes memory byte by byte, each byte encoded as two hex
8322 decoded_bytes
= hex2bin (p
, myaddr
, todo_units
* unit_size
);
8323 /* Return what we have. Let higher layers handle partial reads. */
8324 *xfered_len_units
= (ULONGEST
) (decoded_bytes
/ unit_size
);
8325 return TARGET_XFER_OK
;
8328 /* Using the set of read-only target sections of remote, read live
8331 For interface/parameters/return description see target.h,
8334 static enum target_xfer_status
8335 remote_xfer_live_readonly_partial (struct target_ops
*ops
, gdb_byte
*readbuf
,
8336 ULONGEST memaddr
, ULONGEST len
,
8337 int unit_size
, ULONGEST
*xfered_len
)
8339 struct target_section
*secp
;
8340 struct target_section_table
*table
;
8342 secp
= target_section_by_addr (ops
, memaddr
);
8344 && (bfd_get_section_flags (secp
->the_bfd_section
->owner
,
8345 secp
->the_bfd_section
)
8348 struct target_section
*p
;
8349 ULONGEST memend
= memaddr
+ len
;
8351 table
= target_get_section_table (ops
);
8353 for (p
= table
->sections
; p
< table
->sections_end
; p
++)
8355 if (memaddr
>= p
->addr
)
8357 if (memend
<= p
->endaddr
)
8359 /* Entire transfer is within this section. */
8360 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8363 else if (memaddr
>= p
->endaddr
)
8365 /* This section ends before the transfer starts. */
8370 /* This section overlaps the transfer. Just do half. */
8371 len
= p
->endaddr
- memaddr
;
8372 return remote_read_bytes_1 (memaddr
, readbuf
, len
, unit_size
,
8379 return TARGET_XFER_EOF
;
8382 /* Similar to remote_read_bytes_1, but it reads from the remote stub
8383 first if the requested memory is unavailable in traceframe.
8384 Otherwise, fall back to remote_read_bytes_1. */
8386 static enum target_xfer_status
8387 remote_read_bytes (struct target_ops
*ops
, CORE_ADDR memaddr
,
8388 gdb_byte
*myaddr
, ULONGEST len
, int unit_size
,
8389 ULONGEST
*xfered_len
)
8392 return TARGET_XFER_EOF
;
8394 if (get_traceframe_number () != -1)
8396 VEC(mem_range_s
) *available
;
8398 /* If we fail to get the set of available memory, then the
8399 target does not support querying traceframe info, and so we
8400 attempt reading from the traceframe anyway (assuming the
8401 target implements the old QTro packet then). */
8402 if (traceframe_available_memory (&available
, memaddr
, len
))
8404 struct cleanup
*old_chain
;
8406 old_chain
= make_cleanup (VEC_cleanup(mem_range_s
), &available
);
8408 if (VEC_empty (mem_range_s
, available
)
8409 || VEC_index (mem_range_s
, available
, 0)->start
!= memaddr
)
8411 enum target_xfer_status res
;
8413 /* Don't read into the traceframe's available
8415 if (!VEC_empty (mem_range_s
, available
))
8417 LONGEST oldlen
= len
;
8419 len
= VEC_index (mem_range_s
, available
, 0)->start
- memaddr
;
8420 gdb_assert (len
<= oldlen
);
8423 do_cleanups (old_chain
);
8425 /* This goes through the topmost target again. */
8426 res
= remote_xfer_live_readonly_partial (ops
, myaddr
, memaddr
,
8427 len
, unit_size
, xfered_len
);
8428 if (res
== TARGET_XFER_OK
)
8429 return TARGET_XFER_OK
;
8432 /* No use trying further, we know some memory starting
8433 at MEMADDR isn't available. */
8435 return TARGET_XFER_UNAVAILABLE
;
8439 /* Don't try to read more than how much is available, in
8440 case the target implements the deprecated QTro packet to
8441 cater for older GDBs (the target's knowledge of read-only
8442 sections may be outdated by now). */
8443 len
= VEC_index (mem_range_s
, available
, 0)->length
;
8445 do_cleanups (old_chain
);
8449 return remote_read_bytes_1 (memaddr
, myaddr
, len
, unit_size
, xfered_len
);
8454 /* Sends a packet with content determined by the printf format string
8455 FORMAT and the remaining arguments, then gets the reply. Returns
8456 whether the packet was a success, a failure, or unknown. */
8458 static enum packet_result
remote_send_printf (const char *format
, ...)
8459 ATTRIBUTE_PRINTF (1, 2);
8461 static enum packet_result
8462 remote_send_printf (const char *format
, ...)
8464 struct remote_state
*rs
= get_remote_state ();
8465 int max_size
= get_remote_packet_size ();
8468 va_start (ap
, format
);
8471 if (vsnprintf (rs
->buf
, max_size
, format
, ap
) >= max_size
)
8472 internal_error (__FILE__
, __LINE__
, _("Too long remote packet."));
8474 if (putpkt (rs
->buf
) < 0)
8475 error (_("Communication problem with target."));
8478 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
8480 return packet_check_result (rs
->buf
);
8483 /* Flash writing can take quite some time. We'll set
8484 effectively infinite timeout for flash operations.
8485 In future, we'll need to decide on a better approach. */
8486 static const int remote_flash_timeout
= 1000;
8489 remote_flash_erase (struct target_ops
*ops
,
8490 ULONGEST address
, LONGEST length
)
8492 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
8493 enum packet_result ret
;
8494 scoped_restore restore_timeout
8495 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8497 ret
= remote_send_printf ("vFlashErase:%s,%s",
8498 phex (address
, addr_size
),
8502 case PACKET_UNKNOWN
:
8503 error (_("Remote target does not support flash erase"));
8505 error (_("Error erasing flash with vFlashErase packet"));
8511 static enum target_xfer_status
8512 remote_flash_write (struct target_ops
*ops
, ULONGEST address
,
8513 ULONGEST length
, ULONGEST
*xfered_len
,
8514 const gdb_byte
*data
)
8516 scoped_restore restore_timeout
8517 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8518 return remote_write_bytes_aux ("vFlashWrite:", address
, data
, length
, 1,
8523 remote_flash_done (struct target_ops
*ops
)
8527 scoped_restore restore_timeout
8528 = make_scoped_restore (&remote_timeout
, remote_flash_timeout
);
8530 ret
= remote_send_printf ("vFlashDone");
8534 case PACKET_UNKNOWN
:
8535 error (_("Remote target does not support vFlashDone"));
8537 error (_("Error finishing flash operation"));
8544 remote_files_info (struct target_ops
*ignore
)
8546 puts_filtered ("Debugging a target over a serial line.\n");
8549 /* Stuff for dealing with the packets which are part of this protocol.
8550 See comment at top of file for details. */
8552 /* Close/unpush the remote target, and throw a TARGET_CLOSE_ERROR
8553 error to higher layers. Called when a serial error is detected.
8554 The exception message is STRING, followed by a colon and a blank,
8555 the system error message for errno at function entry and final dot
8556 for output compatibility with throw_perror_with_name. */
8559 unpush_and_perror (const char *string
)
8561 int saved_errno
= errno
;
8563 remote_unpush_target ();
8564 throw_error (TARGET_CLOSE_ERROR
, "%s: %s.", string
,
8565 safe_strerror (saved_errno
));
8568 /* Read a single character from the remote end. The current quit
8569 handler is overridden to avoid quitting in the middle of packet
8570 sequence, as that would break communication with the remote server.
8571 See remote_serial_quit_handler for more detail. */
8574 readchar (int timeout
)
8577 struct remote_state
*rs
= get_remote_state ();
8580 scoped_restore restore_quit
8581 = make_scoped_restore (&quit_handler
, remote_serial_quit_handler
);
8583 rs
->got_ctrlc_during_io
= 0;
8585 ch
= serial_readchar (rs
->remote_desc
, timeout
);
8587 if (rs
->got_ctrlc_during_io
)
8594 switch ((enum serial_rc
) ch
)
8597 remote_unpush_target ();
8598 throw_error (TARGET_CLOSE_ERROR
, _("Remote connection closed"));
8601 unpush_and_perror (_("Remote communication error. "
8602 "Target disconnected."));
8604 case SERIAL_TIMEOUT
:
8610 /* Wrapper for serial_write that closes the target and throws if
8611 writing fails. The current quit handler is overridden to avoid
8612 quitting in the middle of packet sequence, as that would break
8613 communication with the remote server. See
8614 remote_serial_quit_handler for more detail. */
8617 remote_serial_write (const char *str
, int len
)
8619 struct remote_state
*rs
= get_remote_state ();
8621 scoped_restore restore_quit
8622 = make_scoped_restore (&quit_handler
, remote_serial_quit_handler
);
8624 rs
->got_ctrlc_during_io
= 0;
8626 if (serial_write (rs
->remote_desc
, str
, len
))
8628 unpush_and_perror (_("Remote communication error. "
8629 "Target disconnected."));
8632 if (rs
->got_ctrlc_during_io
)
8636 /* Send the command in *BUF to the remote machine, and read the reply
8637 into *BUF. Report an error if we get an error reply. Resize
8638 *BUF using xrealloc if necessary to hold the result, and update
8642 remote_send (char **buf
,
8646 getpkt (buf
, sizeof_buf
, 0);
8648 if ((*buf
)[0] == 'E')
8649 error (_("Remote failure reply: %s"), *buf
);
8652 /* Return a string representing an escaped version of BUF, of len N.
8653 E.g. \n is converted to \\n, \t to \\t, etc. */
8656 escape_buffer (const char *buf
, int n
)
8660 stb
.putstrn (buf
, n
, '\\');
8661 return std::move (stb
.string ());
8664 /* Display a null-terminated packet on stdout, for debugging, using C
8668 print_packet (const char *buf
)
8670 puts_filtered ("\"");
8671 fputstr_filtered (buf
, '"', gdb_stdout
);
8672 puts_filtered ("\"");
8676 putpkt (const char *buf
)
8678 return putpkt_binary (buf
, strlen (buf
));
8681 /* Send a packet to the remote machine, with error checking. The data
8682 of the packet is in BUF. The string in BUF can be at most
8683 get_remote_packet_size () - 5 to account for the $, # and checksum,
8684 and for a possible /0 if we are debugging (remote_debug) and want
8685 to print the sent packet as a string. */
8688 putpkt_binary (const char *buf
, int cnt
)
8690 struct remote_state
*rs
= get_remote_state ();
8692 unsigned char csum
= 0;
8693 char *buf2
= (char *) xmalloc (cnt
+ 6);
8694 struct cleanup
*old_chain
= make_cleanup (xfree
, buf2
);
8700 /* Catch cases like trying to read memory or listing threads while
8701 we're waiting for a stop reply. The remote server wouldn't be
8702 ready to handle this request, so we'd hang and timeout. We don't
8703 have to worry about this in synchronous mode, because in that
8704 case it's not possible to issue a command while the target is
8705 running. This is not a problem in non-stop mode, because in that
8706 case, the stub is always ready to process serial input. */
8707 if (!target_is_non_stop_p ()
8708 && target_is_async_p ()
8709 && rs
->waiting_for_stop_reply
)
8711 error (_("Cannot execute this command while the target is running.\n"
8712 "Use the \"interrupt\" command to stop the target\n"
8713 "and then try again."));
8716 /* We're sending out a new packet. Make sure we don't look at a
8717 stale cached response. */
8718 rs
->cached_wait_status
= 0;
8720 /* Copy the packet into buffer BUF2, encapsulating it
8721 and giving it a checksum. */
8726 for (i
= 0; i
< cnt
; i
++)
8732 *p
++ = tohex ((csum
>> 4) & 0xf);
8733 *p
++ = tohex (csum
& 0xf);
8735 /* Send it over and over until we get a positive ack. */
8739 int started_error_output
= 0;
8745 int len
= (int) (p
- buf2
);
8748 = escape_buffer (buf2
, std::min (len
, REMOTE_DEBUG_MAX_CHAR
));
8750 fprintf_unfiltered (gdb_stdlog
, "Sending packet: %s", str
.c_str ());
8752 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
8754 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
8755 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
8758 fprintf_unfiltered (gdb_stdlog
, "...");
8760 gdb_flush (gdb_stdlog
);
8762 remote_serial_write (buf2
, p
- buf2
);
8764 /* If this is a no acks version of the remote protocol, send the
8765 packet and move on. */
8769 /* Read until either a timeout occurs (-2) or '+' is read.
8770 Handle any notification that arrives in the mean time. */
8773 ch
= readchar (remote_timeout
);
8781 case SERIAL_TIMEOUT
:
8784 if (started_error_output
)
8786 putchar_unfiltered ('\n');
8787 started_error_output
= 0;
8796 fprintf_unfiltered (gdb_stdlog
, "Ack\n");
8797 do_cleanups (old_chain
);
8801 fprintf_unfiltered (gdb_stdlog
, "Nak\n");
8803 case SERIAL_TIMEOUT
:
8807 do_cleanups (old_chain
);
8810 break; /* Retransmit buffer. */
8814 fprintf_unfiltered (gdb_stdlog
,
8815 "Packet instead of Ack, ignoring it\n");
8816 /* It's probably an old response sent because an ACK
8817 was lost. Gobble up the packet and ack it so it
8818 doesn't get retransmitted when we resend this
8821 remote_serial_write ("+", 1);
8822 continue; /* Now, go look for +. */
8829 /* If we got a notification, handle it, and go back to looking
8831 /* We've found the start of a notification. Now
8832 collect the data. */
8833 val
= read_frame (&rs
->buf
, &rs
->buf_size
);
8838 std::string str
= escape_buffer (rs
->buf
, val
);
8840 fprintf_unfiltered (gdb_stdlog
,
8841 " Notification received: %s\n",
8844 handle_notification (rs
->notif_state
, rs
->buf
);
8845 /* We're in sync now, rewait for the ack. */
8852 if (!started_error_output
)
8854 started_error_output
= 1;
8855 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8857 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8858 fprintf_unfiltered (gdb_stdlog
, "%s", rs
->buf
);
8867 if (!started_error_output
)
8869 started_error_output
= 1;
8870 fprintf_unfiltered (gdb_stdlog
, "putpkt: Junk: ");
8872 fputc_unfiltered (ch
& 0177, gdb_stdlog
);
8876 break; /* Here to retransmit. */
8880 /* This is wrong. If doing a long backtrace, the user should be
8881 able to get out next time we call QUIT, without anything as
8882 violent as interrupt_query. If we want to provide a way out of
8883 here without getting to the next QUIT, it should be based on
8884 hitting ^C twice as in remote_wait. */
8893 do_cleanups (old_chain
);
8897 /* Come here after finding the start of a frame when we expected an
8898 ack. Do our best to discard the rest of this packet. */
8907 c
= readchar (remote_timeout
);
8910 case SERIAL_TIMEOUT
:
8911 /* Nothing we can do. */
8914 /* Discard the two bytes of checksum and stop. */
8915 c
= readchar (remote_timeout
);
8917 c
= readchar (remote_timeout
);
8920 case '*': /* Run length encoding. */
8921 /* Discard the repeat count. */
8922 c
= readchar (remote_timeout
);
8927 /* A regular character. */
8933 /* Come here after finding the start of the frame. Collect the rest
8934 into *BUF, verifying the checksum, length, and handling run-length
8935 compression. NUL terminate the buffer. If there is not enough room,
8936 expand *BUF using xrealloc.
8938 Returns -1 on error, number of characters in buffer (ignoring the
8939 trailing NULL) on success. (could be extended to return one of the
8940 SERIAL status indications). */
8943 read_frame (char **buf_p
,
8950 struct remote_state
*rs
= get_remote_state ();
8957 c
= readchar (remote_timeout
);
8960 case SERIAL_TIMEOUT
:
8962 fputs_filtered ("Timeout in mid-packet, retrying\n", gdb_stdlog
);
8966 fputs_filtered ("Saw new packet start in middle of old one\n",
8968 return -1; /* Start a new packet, count retries. */
8971 unsigned char pktcsum
;
8977 check_0
= readchar (remote_timeout
);
8979 check_1
= readchar (remote_timeout
);
8981 if (check_0
== SERIAL_TIMEOUT
|| check_1
== SERIAL_TIMEOUT
)
8984 fputs_filtered ("Timeout in checksum, retrying\n",
8988 else if (check_0
< 0 || check_1
< 0)
8991 fputs_filtered ("Communication error in checksum\n",
8996 /* Don't recompute the checksum; with no ack packets we
8997 don't have any way to indicate a packet retransmission
9002 pktcsum
= (fromhex (check_0
) << 4) | fromhex (check_1
);
9003 if (csum
== pktcsum
)
9008 std::string str
= escape_buffer (buf
, bc
);
9010 fprintf_unfiltered (gdb_stdlog
,
9011 "Bad checksum, sentsum=0x%x, "
9012 "csum=0x%x, buf=%s\n",
9013 pktcsum
, csum
, str
.c_str ());
9015 /* Number of characters in buffer ignoring trailing
9019 case '*': /* Run length encoding. */
9024 c
= readchar (remote_timeout
);
9026 repeat
= c
- ' ' + 3; /* Compute repeat count. */
9028 /* The character before ``*'' is repeated. */
9030 if (repeat
> 0 && repeat
<= 255 && bc
> 0)
9032 if (bc
+ repeat
- 1 >= *sizeof_buf
- 1)
9034 /* Make some more room in the buffer. */
9035 *sizeof_buf
+= repeat
;
9036 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9040 memset (&buf
[bc
], buf
[bc
- 1], repeat
);
9046 printf_filtered (_("Invalid run length encoding: %s\n"), buf
);
9050 if (bc
>= *sizeof_buf
- 1)
9052 /* Make some more room in the buffer. */
9054 *buf_p
= (char *) xrealloc (*buf_p
, *sizeof_buf
);
9065 /* Read a packet from the remote machine, with error checking, and
9066 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9067 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9068 rather than timing out; this is used (in synchronous mode) to wait
9069 for a target that is is executing user code to stop. */
9070 /* FIXME: ezannoni 2000-02-01 this wrapper is necessary so that we
9071 don't have to change all the calls to getpkt to deal with the
9072 return value, because at the moment I don't know what the right
9073 thing to do it for those. */
9079 getpkt_sane (buf
, sizeof_buf
, forever
);
9083 /* Read a packet from the remote machine, with error checking, and
9084 store it in *BUF. Resize *BUF using xrealloc if necessary to hold
9085 the result, and update *SIZEOF_BUF. If FOREVER, wait forever
9086 rather than timing out; this is used (in synchronous mode) to wait
9087 for a target that is is executing user code to stop. If FOREVER ==
9088 0, this function is allowed to time out gracefully and return an
9089 indication of this to the caller. Otherwise return the number of
9090 bytes read. If EXPECTING_NOTIF, consider receiving a notification
9091 enough reason to return to the caller. *IS_NOTIF is an output
9092 boolean that indicates whether *BUF holds a notification or not
9093 (a regular packet). */
9096 getpkt_or_notif_sane_1 (char **buf
, long *sizeof_buf
, int forever
,
9097 int expecting_notif
, int *is_notif
)
9099 struct remote_state
*rs
= get_remote_state ();
9105 /* We're reading a new response. Make sure we don't look at a
9106 previously cached response. */
9107 rs
->cached_wait_status
= 0;
9109 strcpy (*buf
, "timeout");
9112 timeout
= watchdog
> 0 ? watchdog
: -1;
9113 else if (expecting_notif
)
9114 timeout
= 0; /* There should already be a char in the buffer. If
9117 timeout
= remote_timeout
;
9121 /* Process any number of notifications, and then return when
9125 /* If we get a timeout or bad checksum, retry up to MAX_TRIES
9127 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
9129 /* This can loop forever if the remote side sends us
9130 characters continuously, but if it pauses, we'll get
9131 SERIAL_TIMEOUT from readchar because of timeout. Then
9132 we'll count that as a retry.
9134 Note that even when forever is set, we will only wait
9135 forever prior to the start of a packet. After that, we
9136 expect characters to arrive at a brisk pace. They should
9137 show up within remote_timeout intervals. */
9139 c
= readchar (timeout
);
9140 while (c
!= SERIAL_TIMEOUT
&& c
!= '$' && c
!= '%');
9142 if (c
== SERIAL_TIMEOUT
)
9144 if (expecting_notif
)
9145 return -1; /* Don't complain, it's normal to not get
9146 anything in this case. */
9148 if (forever
) /* Watchdog went off? Kill the target. */
9150 remote_unpush_target ();
9151 throw_error (TARGET_CLOSE_ERROR
,
9152 _("Watchdog timeout has expired. "
9153 "Target detached."));
9156 fputs_filtered ("Timed out.\n", gdb_stdlog
);
9160 /* We've found the start of a packet or notification.
9161 Now collect the data. */
9162 val
= read_frame (buf
, sizeof_buf
);
9167 remote_serial_write ("-", 1);
9170 if (tries
> MAX_TRIES
)
9172 /* We have tried hard enough, and just can't receive the
9173 packet/notification. Give up. */
9174 printf_unfiltered (_("Ignoring packet error, continuing...\n"));
9176 /* Skip the ack char if we're in no-ack mode. */
9177 if (!rs
->noack_mode
)
9178 remote_serial_write ("+", 1);
9182 /* If we got an ordinary packet, return that to our caller. */
9188 = escape_buffer (*buf
,
9189 std::min (val
, REMOTE_DEBUG_MAX_CHAR
));
9191 fprintf_unfiltered (gdb_stdlog
, "Packet received: %s",
9194 if (str
.length () > REMOTE_DEBUG_MAX_CHAR
)
9196 fprintf_unfiltered (gdb_stdlog
, "[%zu bytes omitted]",
9197 str
.length () - REMOTE_DEBUG_MAX_CHAR
);
9200 fprintf_unfiltered (gdb_stdlog
, "\n");
9203 /* Skip the ack char if we're in no-ack mode. */
9204 if (!rs
->noack_mode
)
9205 remote_serial_write ("+", 1);
9206 if (is_notif
!= NULL
)
9211 /* If we got a notification, handle it, and go back to looking
9215 gdb_assert (c
== '%');
9219 std::string str
= escape_buffer (*buf
, val
);
9221 fprintf_unfiltered (gdb_stdlog
,
9222 " Notification received: %s\n",
9225 if (is_notif
!= NULL
)
9228 handle_notification (rs
->notif_state
, *buf
);
9230 /* Notifications require no acknowledgement. */
9232 if (expecting_notif
)
9239 getpkt_sane (char **buf
, long *sizeof_buf
, int forever
)
9241 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 0, NULL
);
9245 getpkt_or_notif_sane (char **buf
, long *sizeof_buf
, int forever
,
9248 return getpkt_or_notif_sane_1 (buf
, sizeof_buf
, forever
, 1,
9252 /* Check whether EVENT is a fork event for the process specified
9253 by the pid passed in DATA, and if it is, kill the fork child. */
9256 kill_child_of_pending_fork (QUEUE (stop_reply_p
) *q
,
9257 QUEUE_ITER (stop_reply_p
) *iter
,
9261 struct queue_iter_param
*param
= (struct queue_iter_param
*) data
;
9262 int parent_pid
= *(int *) param
->input
;
9264 if (is_pending_fork_parent (&event
->ws
, parent_pid
, event
->ptid
))
9266 struct remote_state
*rs
= get_remote_state ();
9267 int child_pid
= ptid_get_pid (event
->ws
.value
.related_pid
);
9270 res
= remote_vkill (child_pid
, rs
);
9272 error (_("Can't kill fork child process %d"), child_pid
);
9278 /* Kill any new fork children of process PID that haven't been
9279 processed by follow_fork. */
9282 kill_new_fork_children (int pid
, struct remote_state
*rs
)
9284 struct thread_info
*thread
;
9285 struct notif_client
*notif
= ¬if_client_stop
;
9286 struct queue_iter_param param
;
9288 /* Kill the fork child threads of any threads in process PID
9289 that are stopped at a fork event. */
9290 ALL_NON_EXITED_THREADS (thread
)
9292 struct target_waitstatus
*ws
= &thread
->pending_follow
;
9294 if (is_pending_fork_parent (ws
, pid
, thread
->ptid
))
9296 struct remote_state
*rs
= get_remote_state ();
9297 int child_pid
= ptid_get_pid (ws
->value
.related_pid
);
9300 res
= remote_vkill (child_pid
, rs
);
9302 error (_("Can't kill fork child process %d"), child_pid
);
9306 /* Check for any pending fork events (not reported or processed yet)
9307 in process PID and kill those fork child threads as well. */
9308 remote_notif_get_pending_events (notif
);
9310 param
.output
= NULL
;
9311 QUEUE_iterate (stop_reply_p
, stop_reply_queue
,
9312 kill_child_of_pending_fork
, ¶m
);
9316 /* Target hook to kill the current inferior. */
9319 remote_kill (struct target_ops
*ops
)
9322 int pid
= ptid_get_pid (inferior_ptid
);
9323 struct remote_state
*rs
= get_remote_state ();
9325 if (packet_support (PACKET_vKill
) != PACKET_DISABLE
)
9327 /* If we're stopped while forking and we haven't followed yet,
9328 kill the child task. We need to do this before killing the
9329 parent task because if this is a vfork then the parent will
9331 kill_new_fork_children (pid
, rs
);
9333 res
= remote_vkill (pid
, rs
);
9336 target_mourn_inferior (inferior_ptid
);
9341 /* If we are in 'target remote' mode and we are killing the only
9342 inferior, then we will tell gdbserver to exit and unpush the
9344 if (res
== -1 && !remote_multi_process_p (rs
)
9345 && number_of_live_inferiors () == 1)
9349 /* We've killed the remote end, we get to mourn it. If we are
9350 not in extended mode, mourning the inferior also unpushes
9351 remote_ops from the target stack, which closes the remote
9353 target_mourn_inferior (inferior_ptid
);
9358 error (_("Can't kill process"));
9361 /* Send a kill request to the target using the 'vKill' packet. */
9364 remote_vkill (int pid
, struct remote_state
*rs
)
9366 if (packet_support (PACKET_vKill
) == PACKET_DISABLE
)
9369 /* Tell the remote target to detach. */
9370 xsnprintf (rs
->buf
, get_remote_packet_size (), "vKill;%x", pid
);
9372 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9374 switch (packet_ok (rs
->buf
,
9375 &remote_protocol_packets
[PACKET_vKill
]))
9381 case PACKET_UNKNOWN
:
9384 internal_error (__FILE__
, __LINE__
, _("Bad result from packet_ok"));
9388 /* Send a kill request to the target using the 'k' packet. */
9391 remote_kill_k (void)
9393 /* Catch errors so the user can quit from gdb even when we
9394 aren't on speaking terms with the remote system. */
9399 CATCH (ex
, RETURN_MASK_ERROR
)
9401 if (ex
.error
== TARGET_CLOSE_ERROR
)
9403 /* If we got an (EOF) error that caused the target
9404 to go away, then we're done, that's what we wanted.
9405 "k" is susceptible to cause a premature EOF, given
9406 that the remote server isn't actually required to
9407 reply to "k", and it can happen that it doesn't
9408 even get to reply ACK to the "k". */
9412 /* Otherwise, something went wrong. We didn't actually kill
9413 the target. Just propagate the exception, and let the
9414 user or higher layers decide what to do. */
9415 throw_exception (ex
);
9421 remote_mourn (struct target_ops
*target
)
9423 struct remote_state
*rs
= get_remote_state ();
9425 /* In 'target remote' mode with one inferior, we close the connection. */
9426 if (!rs
->extended
&& number_of_live_inferiors () <= 1)
9428 unpush_target (target
);
9430 /* remote_close takes care of doing most of the clean up. */
9431 generic_mourn_inferior ();
9435 /* In case we got here due to an error, but we're going to stay
9437 rs
->waiting_for_stop_reply
= 0;
9439 /* If the current general thread belonged to the process we just
9440 detached from or has exited, the remote side current general
9441 thread becomes undefined. Considering a case like this:
9443 - We just got here due to a detach.
9444 - The process that we're detaching from happens to immediately
9445 report a global breakpoint being hit in non-stop mode, in the
9446 same thread we had selected before.
9447 - GDB attaches to this process again.
9448 - This event happens to be the next event we handle.
9450 GDB would consider that the current general thread didn't need to
9451 be set on the stub side (with Hg), since for all it knew,
9452 GENERAL_THREAD hadn't changed.
9454 Notice that although in all-stop mode, the remote server always
9455 sets the current thread to the thread reporting the stop event,
9456 that doesn't happen in non-stop mode; in non-stop, the stub *must
9457 not* change the current thread when reporting a breakpoint hit,
9458 due to the decoupling of event reporting and event handling.
9460 To keep things simple, we always invalidate our notion of the
9462 record_currthread (rs
, minus_one_ptid
);
9464 /* Call common code to mark the inferior as not running. */
9465 generic_mourn_inferior ();
9467 if (!have_inferiors ())
9469 if (!remote_multi_process_p (rs
))
9471 /* Check whether the target is running now - some remote stubs
9472 automatically restart after kill. */
9474 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9476 if (rs
->buf
[0] == 'S' || rs
->buf
[0] == 'T')
9478 /* Assume that the target has been restarted. Set
9479 inferior_ptid so that bits of core GDB realizes
9480 there's something here, e.g., so that the user can
9481 say "kill" again. */
9482 inferior_ptid
= magic_null_ptid
;
9489 extended_remote_supports_disable_randomization (struct target_ops
*self
)
9491 return packet_support (PACKET_QDisableRandomization
) == PACKET_ENABLE
;
9495 extended_remote_disable_randomization (int val
)
9497 struct remote_state
*rs
= get_remote_state ();
9500 xsnprintf (rs
->buf
, get_remote_packet_size (), "QDisableRandomization:%x",
9503 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
9505 error (_("Target does not support QDisableRandomization."));
9506 if (strcmp (reply
, "OK") != 0)
9507 error (_("Bogus QDisableRandomization reply from target: %s"), reply
);
9511 extended_remote_run (const std::string
&args
)
9513 struct remote_state
*rs
= get_remote_state ();
9515 const char *remote_exec_file
= get_remote_exec_file ();
9517 /* If the user has disabled vRun support, or we have detected that
9518 support is not available, do not try it. */
9519 if (packet_support (PACKET_vRun
) == PACKET_DISABLE
)
9522 strcpy (rs
->buf
, "vRun;");
9523 len
= strlen (rs
->buf
);
9525 if (strlen (remote_exec_file
) * 2 + len
>= get_remote_packet_size ())
9526 error (_("Remote file name too long for run packet"));
9527 len
+= 2 * bin2hex ((gdb_byte
*) remote_exec_file
, rs
->buf
+ len
,
9528 strlen (remote_exec_file
));
9534 gdb_argv
argv (args
.c_str ());
9535 for (i
= 0; argv
[i
] != NULL
; i
++)
9537 if (strlen (argv
[i
]) * 2 + 1 + len
>= get_remote_packet_size ())
9538 error (_("Argument list too long for run packet"));
9539 rs
->buf
[len
++] = ';';
9540 len
+= 2 * bin2hex ((gdb_byte
*) argv
[i
], rs
->buf
+ len
,
9545 rs
->buf
[len
++] = '\0';
9548 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9550 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_vRun
]))
9553 /* We have a wait response. All is well. */
9555 case PACKET_UNKNOWN
:
9558 if (remote_exec_file
[0] == '\0')
9559 error (_("Running the default executable on the remote target failed; "
9560 "try \"set remote exec-file\"?"));
9562 error (_("Running \"%s\" on the remote target failed"),
9565 gdb_assert_not_reached (_("bad switch"));
9569 /* Helper function to send set/unset environment packets. ACTION is
9570 either "set" or "unset". PACKET is either "QEnvironmentHexEncoded"
9571 or "QEnvironmentUnsetVariable". VALUE is the variable to be
9575 send_environment_packet (struct remote_state
*rs
,
9580 /* Convert the environment variable to an hex string, which
9581 is the best format to be transmitted over the wire. */
9582 std::string encoded_value
= bin2hex ((const gdb_byte
*) value
,
9585 xsnprintf (rs
->buf
, get_remote_packet_size (),
9586 "%s:%s", packet
, encoded_value
.c_str ());
9589 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9590 if (strcmp (rs
->buf
, "OK") != 0)
9591 warning (_("Unable to %s environment variable '%s' on remote."),
9595 /* Helper function to handle the QEnvironment* packets. */
9598 extended_remote_environment_support (struct remote_state
*rs
)
9600 if (packet_support (PACKET_QEnvironmentReset
) != PACKET_DISABLE
)
9602 putpkt ("QEnvironmentReset");
9603 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9604 if (strcmp (rs
->buf
, "OK") != 0)
9605 warning (_("Unable to reset environment on remote."));
9608 gdb_environ
*e
= ¤t_inferior ()->environment
;
9610 if (packet_support (PACKET_QEnvironmentHexEncoded
) != PACKET_DISABLE
)
9611 for (const std::string
&el
: e
->user_set_env ())
9612 send_environment_packet (rs
, "set", "QEnvironmentHexEncoded",
9615 if (packet_support (PACKET_QEnvironmentUnset
) != PACKET_DISABLE
)
9616 for (const std::string
&el
: e
->user_unset_env ())
9617 send_environment_packet (rs
, "unset", "QEnvironmentUnset", el
.c_str ());
9620 /* In the extended protocol we want to be able to do things like
9621 "run" and have them basically work as expected. So we need
9622 a special create_inferior function. We support changing the
9623 executable file and the command line arguments, but not the
9627 extended_remote_create_inferior (struct target_ops
*ops
,
9628 const char *exec_file
,
9629 const std::string
&args
,
9630 char **env
, int from_tty
)
9634 struct remote_state
*rs
= get_remote_state ();
9635 const char *remote_exec_file
= get_remote_exec_file ();
9637 /* If running asynchronously, register the target file descriptor
9638 with the event loop. */
9639 if (target_can_async_p ())
9642 /* Disable address space randomization if requested (and supported). */
9643 if (extended_remote_supports_disable_randomization (ops
))
9644 extended_remote_disable_randomization (disable_randomization
);
9646 /* If startup-with-shell is on, we inform gdbserver to start the
9647 remote inferior using a shell. */
9648 if (packet_support (PACKET_QStartupWithShell
) != PACKET_DISABLE
)
9650 xsnprintf (rs
->buf
, get_remote_packet_size (),
9651 "QStartupWithShell:%d", startup_with_shell
? 1 : 0);
9653 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9654 if (strcmp (rs
->buf
, "OK") != 0)
9656 Remote replied unexpectedly while setting startup-with-shell: %s"),
9660 extended_remote_environment_support (rs
);
9662 /* Now restart the remote server. */
9663 run_worked
= extended_remote_run (args
) != -1;
9666 /* vRun was not supported. Fail if we need it to do what the
9668 if (remote_exec_file
[0])
9669 error (_("Remote target does not support \"set remote exec-file\""));
9671 error (_("Remote target does not support \"set args\" or run <ARGS>"));
9673 /* Fall back to "R". */
9674 extended_remote_restart ();
9677 if (!have_inferiors ())
9679 /* Clean up from the last time we ran, before we mark the target
9680 running again. This will mark breakpoints uninserted, and
9681 get_offsets may insert breakpoints. */
9682 init_thread_list ();
9683 init_wait_for_inferior ();
9686 /* vRun's success return is a stop reply. */
9687 stop_reply
= run_worked
? rs
->buf
: NULL
;
9688 add_current_inferior_and_thread (stop_reply
);
9690 /* Get updated offsets, if the stub uses qOffsets. */
9695 /* Given a location's target info BP_TGT and the packet buffer BUF, output
9696 the list of conditions (in agent expression bytecode format), if any, the
9697 target needs to evaluate. The output is placed into the packet buffer
9698 started from BUF and ended at BUF_END. */
9701 remote_add_target_side_condition (struct gdbarch
*gdbarch
,
9702 struct bp_target_info
*bp_tgt
, char *buf
,
9705 if (bp_tgt
->conditions
.empty ())
9708 buf
+= strlen (buf
);
9709 xsnprintf (buf
, buf_end
- buf
, "%s", ";");
9712 /* Send conditions to the target. */
9713 for (agent_expr
*aexpr
: bp_tgt
->conditions
)
9715 xsnprintf (buf
, buf_end
- buf
, "X%x,", aexpr
->len
);
9716 buf
+= strlen (buf
);
9717 for (int i
= 0; i
< aexpr
->len
; ++i
)
9718 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9725 remote_add_target_side_commands (struct gdbarch
*gdbarch
,
9726 struct bp_target_info
*bp_tgt
, char *buf
)
9728 if (bp_tgt
->tcommands
.empty ())
9731 buf
+= strlen (buf
);
9733 sprintf (buf
, ";cmds:%x,", bp_tgt
->persist
);
9734 buf
+= strlen (buf
);
9736 /* Concatenate all the agent expressions that are commands into the
9738 for (agent_expr
*aexpr
: bp_tgt
->tcommands
)
9740 sprintf (buf
, "X%x,", aexpr
->len
);
9741 buf
+= strlen (buf
);
9742 for (int i
= 0; i
< aexpr
->len
; ++i
)
9743 buf
= pack_hex_byte (buf
, aexpr
->buf
[i
]);
9748 /* Insert a breakpoint. On targets that have software breakpoint
9749 support, we ask the remote target to do the work; on targets
9750 which don't, we insert a traditional memory breakpoint. */
9753 remote_insert_breakpoint (struct target_ops
*ops
,
9754 struct gdbarch
*gdbarch
,
9755 struct bp_target_info
*bp_tgt
)
9757 /* Try the "Z" s/w breakpoint packet if it is not already disabled.
9758 If it succeeds, then set the support to PACKET_ENABLE. If it
9759 fails, and the user has explicitly requested the Z support then
9760 report an error, otherwise, mark it disabled and go on. */
9762 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9764 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
9765 struct remote_state
*rs
;
9769 /* Make sure the remote is pointing at the right process, if
9771 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9772 set_general_process ();
9774 rs
= get_remote_state ();
9776 endbuf
= rs
->buf
+ get_remote_packet_size ();
9781 addr
= (ULONGEST
) remote_address_masked (addr
);
9782 p
+= hexnumstr (p
, addr
);
9783 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9785 if (remote_supports_cond_breakpoints (ops
))
9786 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
9788 if (remote_can_run_breakpoint_commands (ops
))
9789 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
9792 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9794 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
]))
9800 case PACKET_UNKNOWN
:
9805 /* If this breakpoint has target-side commands but this stub doesn't
9806 support Z0 packets, throw error. */
9807 if (!bp_tgt
->tcommands
.empty ())
9808 throw_error (NOT_SUPPORTED_ERROR
, _("\
9809 Target doesn't support breakpoints that have target side commands."));
9811 return memory_insert_breakpoint (ops
, gdbarch
, bp_tgt
);
9815 remote_remove_breakpoint (struct target_ops
*ops
,
9816 struct gdbarch
*gdbarch
,
9817 struct bp_target_info
*bp_tgt
,
9818 enum remove_bp_reason reason
)
9820 CORE_ADDR addr
= bp_tgt
->placed_address
;
9821 struct remote_state
*rs
= get_remote_state ();
9823 if (packet_support (PACKET_Z0
) != PACKET_DISABLE
)
9826 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9828 /* Make sure the remote is pointing at the right process, if
9830 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9831 set_general_process ();
9837 addr
= (ULONGEST
) remote_address_masked (bp_tgt
->placed_address
);
9838 p
+= hexnumstr (p
, addr
);
9839 xsnprintf (p
, endbuf
- p
, ",%d", bp_tgt
->kind
);
9842 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9844 return (rs
->buf
[0] == 'E');
9847 return memory_remove_breakpoint (ops
, gdbarch
, bp_tgt
, reason
);
9850 static enum Z_packet_type
9851 watchpoint_to_Z_packet (int type
)
9856 return Z_PACKET_WRITE_WP
;
9859 return Z_PACKET_READ_WP
;
9862 return Z_PACKET_ACCESS_WP
;
9865 internal_error (__FILE__
, __LINE__
,
9866 _("hw_bp_to_z: bad watchpoint type %d"), type
);
9871 remote_insert_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9872 enum target_hw_bp_type type
, struct expression
*cond
)
9874 struct remote_state
*rs
= get_remote_state ();
9875 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9877 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9879 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9882 /* Make sure the remote is pointing at the right process, if
9884 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9885 set_general_process ();
9887 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "Z%x,", packet
);
9888 p
= strchr (rs
->buf
, '\0');
9889 addr
= remote_address_masked (addr
);
9890 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9891 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9894 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9896 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9900 case PACKET_UNKNOWN
:
9905 internal_error (__FILE__
, __LINE__
,
9906 _("remote_insert_watchpoint: reached end of function"));
9910 remote_watchpoint_addr_within_range (struct target_ops
*target
, CORE_ADDR addr
,
9911 CORE_ADDR start
, int length
)
9913 CORE_ADDR diff
= remote_address_masked (addr
- start
);
9915 return diff
< length
;
9920 remote_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
, int len
,
9921 enum target_hw_bp_type type
, struct expression
*cond
)
9923 struct remote_state
*rs
= get_remote_state ();
9924 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
9926 enum Z_packet_type packet
= watchpoint_to_Z_packet (type
);
9928 if (packet_support (PACKET_Z0
+ packet
) == PACKET_DISABLE
)
9931 /* Make sure the remote is pointing at the right process, if
9933 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
9934 set_general_process ();
9936 xsnprintf (rs
->buf
, endbuf
- rs
->buf
, "z%x,", packet
);
9937 p
= strchr (rs
->buf
, '\0');
9938 addr
= remote_address_masked (addr
);
9939 p
+= hexnumstr (p
, (ULONGEST
) addr
);
9940 xsnprintf (p
, endbuf
- p
, ",%x", len
);
9942 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
9944 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z0
+ packet
]))
9947 case PACKET_UNKNOWN
:
9952 internal_error (__FILE__
, __LINE__
,
9953 _("remote_remove_watchpoint: reached end of function"));
9957 int remote_hw_watchpoint_limit
= -1;
9958 int remote_hw_watchpoint_length_limit
= -1;
9959 int remote_hw_breakpoint_limit
= -1;
9962 remote_region_ok_for_hw_watchpoint (struct target_ops
*self
,
9963 CORE_ADDR addr
, int len
)
9965 if (remote_hw_watchpoint_length_limit
== 0)
9967 else if (remote_hw_watchpoint_length_limit
< 0)
9969 else if (len
<= remote_hw_watchpoint_length_limit
)
9976 remote_check_watch_resources (struct target_ops
*self
,
9977 enum bptype type
, int cnt
, int ot
)
9979 if (type
== bp_hardware_breakpoint
)
9981 if (remote_hw_breakpoint_limit
== 0)
9983 else if (remote_hw_breakpoint_limit
< 0)
9985 else if (cnt
<= remote_hw_breakpoint_limit
)
9990 if (remote_hw_watchpoint_limit
== 0)
9992 else if (remote_hw_watchpoint_limit
< 0)
9996 else if (cnt
<= remote_hw_watchpoint_limit
)
10002 /* The to_stopped_by_sw_breakpoint method of target remote. */
10005 remote_stopped_by_sw_breakpoint (struct target_ops
*ops
)
10007 struct thread_info
*thread
= inferior_thread ();
10009 return (thread
->priv
!= NULL
10010 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_SW_BREAKPOINT
);
10013 /* The to_supports_stopped_by_sw_breakpoint method of target
10017 remote_supports_stopped_by_sw_breakpoint (struct target_ops
*ops
)
10019 return (packet_support (PACKET_swbreak_feature
) == PACKET_ENABLE
);
10022 /* The to_stopped_by_hw_breakpoint method of target remote. */
10025 remote_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10027 struct thread_info
*thread
= inferior_thread ();
10029 return (thread
->priv
!= NULL
10030 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_HW_BREAKPOINT
);
10033 /* The to_supports_stopped_by_hw_breakpoint method of target
10037 remote_supports_stopped_by_hw_breakpoint (struct target_ops
*ops
)
10039 return (packet_support (PACKET_hwbreak_feature
) == PACKET_ENABLE
);
10043 remote_stopped_by_watchpoint (struct target_ops
*ops
)
10045 struct thread_info
*thread
= inferior_thread ();
10047 return (thread
->priv
!= NULL
10048 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
);
10052 remote_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
10054 struct thread_info
*thread
= inferior_thread ();
10056 if (thread
->priv
!= NULL
10057 && thread
->priv
->stop_reason
== TARGET_STOPPED_BY_WATCHPOINT
)
10059 *addr_p
= thread
->priv
->watch_data_address
;
10068 remote_insert_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10069 struct bp_target_info
*bp_tgt
)
10071 CORE_ADDR addr
= bp_tgt
->reqstd_address
;
10072 struct remote_state
*rs
;
10076 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10079 /* Make sure the remote is pointing at the right process, if
10081 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10082 set_general_process ();
10084 rs
= get_remote_state ();
10086 endbuf
= rs
->buf
+ get_remote_packet_size ();
10092 addr
= remote_address_masked (addr
);
10093 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10094 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10096 if (remote_supports_cond_breakpoints (self
))
10097 remote_add_target_side_condition (gdbarch
, bp_tgt
, p
, endbuf
);
10099 if (remote_can_run_breakpoint_commands (self
))
10100 remote_add_target_side_commands (gdbarch
, bp_tgt
, p
);
10103 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10105 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10108 if (rs
->buf
[1] == '.')
10110 message
= strchr (rs
->buf
+ 2, '.');
10112 error (_("Remote failure reply: %s"), message
+ 1);
10115 case PACKET_UNKNOWN
:
10120 internal_error (__FILE__
, __LINE__
,
10121 _("remote_insert_hw_breakpoint: reached end of function"));
10126 remote_remove_hw_breakpoint (struct target_ops
*self
, struct gdbarch
*gdbarch
,
10127 struct bp_target_info
*bp_tgt
)
10130 struct remote_state
*rs
= get_remote_state ();
10132 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
10134 if (packet_support (PACKET_Z1
) == PACKET_DISABLE
)
10137 /* Make sure the remote is pointing at the right process, if
10139 if (!gdbarch_has_global_breakpoints (target_gdbarch ()))
10140 set_general_process ();
10146 addr
= remote_address_masked (bp_tgt
->placed_address
);
10147 p
+= hexnumstr (p
, (ULONGEST
) addr
);
10148 xsnprintf (p
, endbuf
- p
, ",%x", bp_tgt
->kind
);
10151 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10153 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[PACKET_Z1
]))
10156 case PACKET_UNKNOWN
:
10161 internal_error (__FILE__
, __LINE__
,
10162 _("remote_remove_hw_breakpoint: reached end of function"));
10165 /* Verify memory using the "qCRC:" request. */
10168 remote_verify_memory (struct target_ops
*ops
,
10169 const gdb_byte
*data
, CORE_ADDR lma
, ULONGEST size
)
10171 struct remote_state
*rs
= get_remote_state ();
10172 unsigned long host_crc
, target_crc
;
10175 /* It doesn't make sense to use qCRC if the remote target is
10176 connected but not running. */
10177 if (target_has_execution
&& packet_support (PACKET_qCRC
) != PACKET_DISABLE
)
10179 enum packet_result result
;
10181 /* Make sure the remote is pointing at the right process. */
10182 set_general_process ();
10184 /* FIXME: assumes lma can fit into long. */
10185 xsnprintf (rs
->buf
, get_remote_packet_size (), "qCRC:%lx,%lx",
10186 (long) lma
, (long) size
);
10189 /* Be clever; compute the host_crc before waiting for target
10191 host_crc
= xcrc32 (data
, size
, 0xffffffff);
10193 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10195 result
= packet_ok (rs
->buf
,
10196 &remote_protocol_packets
[PACKET_qCRC
]);
10197 if (result
== PACKET_ERROR
)
10199 else if (result
== PACKET_OK
)
10201 for (target_crc
= 0, tmp
= &rs
->buf
[1]; *tmp
; tmp
++)
10202 target_crc
= target_crc
* 16 + fromhex (*tmp
);
10204 return (host_crc
== target_crc
);
10208 return simple_verify_memory (ops
, data
, lma
, size
);
10211 /* compare-sections command
10213 With no arguments, compares each loadable section in the exec bfd
10214 with the same memory range on the target, and reports mismatches.
10215 Useful for verifying the image on the target against the exec file. */
10218 compare_sections_command (char *args
, int from_tty
)
10221 struct cleanup
*old_chain
;
10222 gdb_byte
*sectdata
;
10223 const char *sectname
;
10224 bfd_size_type size
;
10227 int mismatched
= 0;
10232 error (_("command cannot be used without an exec file"));
10234 /* Make sure the remote is pointing at the right process. */
10235 set_general_process ();
10237 if (args
!= NULL
&& strcmp (args
, "-r") == 0)
10243 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
10245 if (!(s
->flags
& SEC_LOAD
))
10246 continue; /* Skip non-loadable section. */
10248 if (read_only
&& (s
->flags
& SEC_READONLY
) == 0)
10249 continue; /* Skip writeable sections */
10251 size
= bfd_get_section_size (s
);
10253 continue; /* Skip zero-length section. */
10255 sectname
= bfd_get_section_name (exec_bfd
, s
);
10256 if (args
&& strcmp (args
, sectname
) != 0)
10257 continue; /* Not the section selected by user. */
10259 matched
= 1; /* Do this section. */
10262 sectdata
= (gdb_byte
*) xmalloc (size
);
10263 old_chain
= make_cleanup (xfree
, sectdata
);
10264 bfd_get_section_contents (exec_bfd
, s
, sectdata
, 0, size
);
10266 res
= target_verify_memory (sectdata
, lma
, size
);
10269 error (_("target memory fault, section %s, range %s -- %s"), sectname
,
10270 paddress (target_gdbarch (), lma
),
10271 paddress (target_gdbarch (), lma
+ size
));
10273 printf_filtered ("Section %s, range %s -- %s: ", sectname
,
10274 paddress (target_gdbarch (), lma
),
10275 paddress (target_gdbarch (), lma
+ size
));
10277 printf_filtered ("matched.\n");
10280 printf_filtered ("MIS-MATCHED!\n");
10284 do_cleanups (old_chain
);
10286 if (mismatched
> 0)
10287 warning (_("One or more sections of the target image does not match\n\
10288 the loaded file\n"));
10289 if (args
&& !matched
)
10290 printf_filtered (_("No loaded section named '%s'.\n"), args
);
10293 /* Write LEN bytes from WRITEBUF into OBJECT_NAME/ANNEX at OFFSET
10294 into remote target. The number of bytes written to the remote
10295 target is returned, or -1 for error. */
10297 static enum target_xfer_status
10298 remote_write_qxfer (struct target_ops
*ops
, const char *object_name
,
10299 const char *annex
, const gdb_byte
*writebuf
,
10300 ULONGEST offset
, LONGEST len
, ULONGEST
*xfered_len
,
10301 struct packet_config
*packet
)
10305 struct remote_state
*rs
= get_remote_state ();
10306 int max_size
= get_memory_write_packet_size ();
10308 if (packet
->support
== PACKET_DISABLE
)
10309 return TARGET_XFER_E_IO
;
10311 /* Insert header. */
10312 i
= snprintf (rs
->buf
, max_size
,
10313 "qXfer:%s:write:%s:%s:",
10314 object_name
, annex
? annex
: "",
10315 phex_nz (offset
, sizeof offset
));
10316 max_size
-= (i
+ 1);
10318 /* Escape as much data as fits into rs->buf. */
10319 buf_len
= remote_escape_output
10320 (writebuf
, len
, 1, (gdb_byte
*) rs
->buf
+ i
, &max_size
, max_size
);
10322 if (putpkt_binary (rs
->buf
, i
+ buf_len
) < 0
10323 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10324 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10325 return TARGET_XFER_E_IO
;
10327 unpack_varlen_hex (rs
->buf
, &n
);
10330 return TARGET_XFER_OK
;
10333 /* Read OBJECT_NAME/ANNEX from the remote target using a qXfer packet.
10334 Data at OFFSET, of up to LEN bytes, is read into READBUF; the
10335 number of bytes read is returned, or 0 for EOF, or -1 for error.
10336 The number of bytes read may be less than LEN without indicating an
10337 EOF. PACKET is checked and updated to indicate whether the remote
10338 target supports this object. */
10340 static enum target_xfer_status
10341 remote_read_qxfer (struct target_ops
*ops
, const char *object_name
,
10343 gdb_byte
*readbuf
, ULONGEST offset
, LONGEST len
,
10344 ULONGEST
*xfered_len
,
10345 struct packet_config
*packet
)
10347 struct remote_state
*rs
= get_remote_state ();
10348 LONGEST i
, n
, packet_len
;
10350 if (packet
->support
== PACKET_DISABLE
)
10351 return TARGET_XFER_E_IO
;
10353 /* Check whether we've cached an end-of-object packet that matches
10355 if (rs
->finished_object
)
10357 if (strcmp (object_name
, rs
->finished_object
) == 0
10358 && strcmp (annex
? annex
: "", rs
->finished_annex
) == 0
10359 && offset
== rs
->finished_offset
)
10360 return TARGET_XFER_EOF
;
10363 /* Otherwise, we're now reading something different. Discard
10365 xfree (rs
->finished_object
);
10366 xfree (rs
->finished_annex
);
10367 rs
->finished_object
= NULL
;
10368 rs
->finished_annex
= NULL
;
10371 /* Request only enough to fit in a single packet. The actual data
10372 may not, since we don't know how much of it will need to be escaped;
10373 the target is free to respond with slightly less data. We subtract
10374 five to account for the response type and the protocol frame. */
10375 n
= std::min
<LONGEST
> (get_remote_packet_size () - 5, len
);
10376 snprintf (rs
->buf
, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
10377 object_name
, annex
? annex
: "",
10378 phex_nz (offset
, sizeof offset
),
10379 phex_nz (n
, sizeof n
));
10380 i
= putpkt (rs
->buf
);
10382 return TARGET_XFER_E_IO
;
10385 packet_len
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
10386 if (packet_len
< 0 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10387 return TARGET_XFER_E_IO
;
10389 if (rs
->buf
[0] != 'l' && rs
->buf
[0] != 'm')
10390 error (_("Unknown remote qXfer reply: %s"), rs
->buf
);
10392 /* 'm' means there is (or at least might be) more data after this
10393 batch. That does not make sense unless there's at least one byte
10394 of data in this reply. */
10395 if (rs
->buf
[0] == 'm' && packet_len
== 1)
10396 error (_("Remote qXfer reply contained no data."));
10398 /* Got some data. */
10399 i
= remote_unescape_input ((gdb_byte
*) rs
->buf
+ 1,
10400 packet_len
- 1, readbuf
, n
);
10402 /* 'l' is an EOF marker, possibly including a final block of data,
10403 or possibly empty. If we have the final block of a non-empty
10404 object, record this fact to bypass a subsequent partial read. */
10405 if (rs
->buf
[0] == 'l' && offset
+ i
> 0)
10407 rs
->finished_object
= xstrdup (object_name
);
10408 rs
->finished_annex
= xstrdup (annex
? annex
: "");
10409 rs
->finished_offset
= offset
+ i
;
10413 return TARGET_XFER_EOF
;
10417 return TARGET_XFER_OK
;
10421 static enum target_xfer_status
10422 remote_xfer_partial (struct target_ops
*ops
, enum target_object object
,
10423 const char *annex
, gdb_byte
*readbuf
,
10424 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
10425 ULONGEST
*xfered_len
)
10427 struct remote_state
*rs
;
10431 int unit_size
= gdbarch_addressable_memory_unit_size (target_gdbarch ());
10433 set_remote_traceframe ();
10434 set_general_thread (inferior_ptid
);
10436 rs
= get_remote_state ();
10438 /* Handle memory using the standard memory routines. */
10439 if (object
== TARGET_OBJECT_MEMORY
)
10441 /* If the remote target is connected but not running, we should
10442 pass this request down to a lower stratum (e.g. the executable
10444 if (!target_has_execution
)
10445 return TARGET_XFER_EOF
;
10447 if (writebuf
!= NULL
)
10448 return remote_write_bytes (offset
, writebuf
, len
, unit_size
,
10451 return remote_read_bytes (ops
, offset
, readbuf
, len
, unit_size
,
10455 /* Handle SPU memory using qxfer packets. */
10456 if (object
== TARGET_OBJECT_SPU
)
10459 return remote_read_qxfer (ops
, "spu", annex
, readbuf
, offset
, len
,
10460 xfered_len
, &remote_protocol_packets
10461 [PACKET_qXfer_spu_read
]);
10463 return remote_write_qxfer (ops
, "spu", annex
, writebuf
, offset
, len
,
10464 xfered_len
, &remote_protocol_packets
10465 [PACKET_qXfer_spu_write
]);
10468 /* Handle extra signal info using qxfer packets. */
10469 if (object
== TARGET_OBJECT_SIGNAL_INFO
)
10472 return remote_read_qxfer (ops
, "siginfo", annex
, readbuf
, offset
, len
,
10473 xfered_len
, &remote_protocol_packets
10474 [PACKET_qXfer_siginfo_read
]);
10476 return remote_write_qxfer (ops
, "siginfo", annex
,
10477 writebuf
, offset
, len
, xfered_len
,
10478 &remote_protocol_packets
10479 [PACKET_qXfer_siginfo_write
]);
10482 if (object
== TARGET_OBJECT_STATIC_TRACE_DATA
)
10485 return remote_read_qxfer (ops
, "statictrace", annex
,
10486 readbuf
, offset
, len
, xfered_len
,
10487 &remote_protocol_packets
10488 [PACKET_qXfer_statictrace_read
]);
10490 return TARGET_XFER_E_IO
;
10493 /* Only handle flash writes. */
10494 if (writebuf
!= NULL
)
10498 case TARGET_OBJECT_FLASH
:
10499 return remote_flash_write (ops
, offset
, len
, xfered_len
,
10503 return TARGET_XFER_E_IO
;
10507 /* Map pre-existing objects onto letters. DO NOT do this for new
10508 objects!!! Instead specify new query packets. */
10511 case TARGET_OBJECT_AVR
:
10515 case TARGET_OBJECT_AUXV
:
10516 gdb_assert (annex
== NULL
);
10517 return remote_read_qxfer (ops
, "auxv", annex
, readbuf
, offset
, len
,
10519 &remote_protocol_packets
[PACKET_qXfer_auxv
]);
10521 case TARGET_OBJECT_AVAILABLE_FEATURES
:
10522 return remote_read_qxfer
10523 (ops
, "features", annex
, readbuf
, offset
, len
, xfered_len
,
10524 &remote_protocol_packets
[PACKET_qXfer_features
]);
10526 case TARGET_OBJECT_LIBRARIES
:
10527 return remote_read_qxfer
10528 (ops
, "libraries", annex
, readbuf
, offset
, len
, xfered_len
,
10529 &remote_protocol_packets
[PACKET_qXfer_libraries
]);
10531 case TARGET_OBJECT_LIBRARIES_SVR4
:
10532 return remote_read_qxfer
10533 (ops
, "libraries-svr4", annex
, readbuf
, offset
, len
, xfered_len
,
10534 &remote_protocol_packets
[PACKET_qXfer_libraries_svr4
]);
10536 case TARGET_OBJECT_MEMORY_MAP
:
10537 gdb_assert (annex
== NULL
);
10538 return remote_read_qxfer (ops
, "memory-map", annex
, readbuf
, offset
, len
,
10540 &remote_protocol_packets
[PACKET_qXfer_memory_map
]);
10542 case TARGET_OBJECT_OSDATA
:
10543 /* Should only get here if we're connected. */
10544 gdb_assert (rs
->remote_desc
);
10545 return remote_read_qxfer
10546 (ops
, "osdata", annex
, readbuf
, offset
, len
, xfered_len
,
10547 &remote_protocol_packets
[PACKET_qXfer_osdata
]);
10549 case TARGET_OBJECT_THREADS
:
10550 gdb_assert (annex
== NULL
);
10551 return remote_read_qxfer (ops
, "threads", annex
, readbuf
, offset
, len
,
10553 &remote_protocol_packets
[PACKET_qXfer_threads
]);
10555 case TARGET_OBJECT_TRACEFRAME_INFO
:
10556 gdb_assert (annex
== NULL
);
10557 return remote_read_qxfer
10558 (ops
, "traceframe-info", annex
, readbuf
, offset
, len
, xfered_len
,
10559 &remote_protocol_packets
[PACKET_qXfer_traceframe_info
]);
10561 case TARGET_OBJECT_FDPIC
:
10562 return remote_read_qxfer (ops
, "fdpic", annex
, readbuf
, offset
, len
,
10564 &remote_protocol_packets
[PACKET_qXfer_fdpic
]);
10566 case TARGET_OBJECT_OPENVMS_UIB
:
10567 return remote_read_qxfer (ops
, "uib", annex
, readbuf
, offset
, len
,
10569 &remote_protocol_packets
[PACKET_qXfer_uib
]);
10571 case TARGET_OBJECT_BTRACE
:
10572 return remote_read_qxfer (ops
, "btrace", annex
, readbuf
, offset
, len
,
10574 &remote_protocol_packets
[PACKET_qXfer_btrace
]);
10576 case TARGET_OBJECT_BTRACE_CONF
:
10577 return remote_read_qxfer (ops
, "btrace-conf", annex
, readbuf
, offset
,
10579 &remote_protocol_packets
[PACKET_qXfer_btrace_conf
]);
10581 case TARGET_OBJECT_EXEC_FILE
:
10582 return remote_read_qxfer (ops
, "exec-file", annex
, readbuf
, offset
,
10584 &remote_protocol_packets
[PACKET_qXfer_exec_file
]);
10587 return TARGET_XFER_E_IO
;
10590 /* Minimum outbuf size is get_remote_packet_size (). If LEN is not
10591 large enough let the caller deal with it. */
10592 if (len
< get_remote_packet_size ())
10593 return TARGET_XFER_E_IO
;
10594 len
= get_remote_packet_size ();
10596 /* Except for querying the minimum buffer size, target must be open. */
10597 if (!rs
->remote_desc
)
10598 error (_("remote query is only available after target open"));
10600 gdb_assert (annex
!= NULL
);
10601 gdb_assert (readbuf
!= NULL
);
10605 *p2
++ = query_type
;
10607 /* We used one buffer char for the remote protocol q command and
10608 another for the query type. As the remote protocol encapsulation
10609 uses 4 chars plus one extra in case we are debugging
10610 (remote_debug), we have PBUFZIZ - 7 left to pack the query
10613 while (annex
[i
] && (i
< (get_remote_packet_size () - 8)))
10615 /* Bad caller may have sent forbidden characters. */
10616 gdb_assert (isprint (annex
[i
]) && annex
[i
] != '$' && annex
[i
] != '#');
10621 gdb_assert (annex
[i
] == '\0');
10623 i
= putpkt (rs
->buf
);
10625 return TARGET_XFER_E_IO
;
10627 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10628 strcpy ((char *) readbuf
, rs
->buf
);
10630 *xfered_len
= strlen ((char *) readbuf
);
10631 return TARGET_XFER_OK
;
10634 /* Implementation of to_get_memory_xfer_limit. */
10637 remote_get_memory_xfer_limit (struct target_ops
*ops
)
10639 return get_memory_write_packet_size ();
10643 remote_search_memory (struct target_ops
* ops
,
10644 CORE_ADDR start_addr
, ULONGEST search_space_len
,
10645 const gdb_byte
*pattern
, ULONGEST pattern_len
,
10646 CORE_ADDR
*found_addrp
)
10648 int addr_size
= gdbarch_addr_bit (target_gdbarch ()) / 8;
10649 struct remote_state
*rs
= get_remote_state ();
10650 int max_size
= get_memory_write_packet_size ();
10651 struct packet_config
*packet
=
10652 &remote_protocol_packets
[PACKET_qSearch_memory
];
10653 /* Number of packet bytes used to encode the pattern;
10654 this could be more than PATTERN_LEN due to escape characters. */
10655 int escaped_pattern_len
;
10656 /* Amount of pattern that was encodable in the packet. */
10657 int used_pattern_len
;
10660 ULONGEST found_addr
;
10662 /* Don't go to the target if we don't have to.
10663 This is done before checking packet->support to avoid the possibility that
10664 a success for this edge case means the facility works in general. */
10665 if (pattern_len
> search_space_len
)
10667 if (pattern_len
== 0)
10669 *found_addrp
= start_addr
;
10673 /* If we already know the packet isn't supported, fall back to the simple
10674 way of searching memory. */
10676 if (packet_config_support (packet
) == PACKET_DISABLE
)
10678 /* Target doesn't provided special support, fall back and use the
10679 standard support (copy memory and do the search here). */
10680 return simple_search_memory (ops
, start_addr
, search_space_len
,
10681 pattern
, pattern_len
, found_addrp
);
10684 /* Make sure the remote is pointing at the right process. */
10685 set_general_process ();
10687 /* Insert header. */
10688 i
= snprintf (rs
->buf
, max_size
,
10689 "qSearch:memory:%s;%s;",
10690 phex_nz (start_addr
, addr_size
),
10691 phex_nz (search_space_len
, sizeof (search_space_len
)));
10692 max_size
-= (i
+ 1);
10694 /* Escape as much data as fits into rs->buf. */
10695 escaped_pattern_len
=
10696 remote_escape_output (pattern
, pattern_len
, 1, (gdb_byte
*) rs
->buf
+ i
,
10697 &used_pattern_len
, max_size
);
10699 /* Bail if the pattern is too large. */
10700 if (used_pattern_len
!= pattern_len
)
10701 error (_("Pattern is too large to transmit to remote target."));
10703 if (putpkt_binary (rs
->buf
, i
+ escaped_pattern_len
) < 0
10704 || getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) < 0
10705 || packet_ok (rs
->buf
, packet
) != PACKET_OK
)
10707 /* The request may not have worked because the command is not
10708 supported. If so, fall back to the simple way. */
10709 if (packet
->support
== PACKET_DISABLE
)
10711 return simple_search_memory (ops
, start_addr
, search_space_len
,
10712 pattern
, pattern_len
, found_addrp
);
10717 if (rs
->buf
[0] == '0')
10719 else if (rs
->buf
[0] == '1')
10722 if (rs
->buf
[1] != ',')
10723 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10724 unpack_varlen_hex (rs
->buf
+ 2, &found_addr
);
10725 *found_addrp
= found_addr
;
10728 error (_("Unknown qSearch:memory reply: %s"), rs
->buf
);
10734 remote_rcmd (struct target_ops
*self
, const char *command
,
10735 struct ui_file
*outbuf
)
10737 struct remote_state
*rs
= get_remote_state ();
10740 if (!rs
->remote_desc
)
10741 error (_("remote rcmd is only available after target open"));
10743 /* Send a NULL command across as an empty command. */
10744 if (command
== NULL
)
10747 /* The query prefix. */
10748 strcpy (rs
->buf
, "qRcmd,");
10749 p
= strchr (rs
->buf
, '\0');
10751 if ((strlen (rs
->buf
) + strlen (command
) * 2 + 8/*misc*/)
10752 > get_remote_packet_size ())
10753 error (_("\"monitor\" command ``%s'' is too long."), command
);
10755 /* Encode the actual command. */
10756 bin2hex ((const gdb_byte
*) command
, p
, strlen (command
));
10758 if (putpkt (rs
->buf
) < 0)
10759 error (_("Communication problem with target."));
10761 /* get/display the response */
10766 /* XXX - see also remote_get_noisy_reply(). */
10767 QUIT
; /* Allow user to bail out with ^C. */
10769 if (getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0) == -1)
10771 /* Timeout. Continue to (try to) read responses.
10772 This is better than stopping with an error, assuming the stub
10773 is still executing the (long) monitor command.
10774 If needed, the user can interrupt gdb using C-c, obtaining
10775 an effect similar to stop on timeout. */
10779 if (buf
[0] == '\0')
10780 error (_("Target does not support this command."));
10781 if (buf
[0] == 'O' && buf
[1] != 'K')
10783 remote_console_output (buf
+ 1); /* 'O' message from stub. */
10786 if (strcmp (buf
, "OK") == 0)
10788 if (strlen (buf
) == 3 && buf
[0] == 'E'
10789 && isdigit (buf
[1]) && isdigit (buf
[2]))
10791 error (_("Protocol error with Rcmd"));
10793 for (p
= buf
; p
[0] != '\0' && p
[1] != '\0'; p
+= 2)
10795 char c
= (fromhex (p
[0]) << 4) + fromhex (p
[1]);
10797 fputc_unfiltered (c
, outbuf
);
10803 static VEC(mem_region_s
) *
10804 remote_memory_map (struct target_ops
*ops
)
10806 VEC(mem_region_s
) *result
= NULL
;
10807 char *text
= target_read_stralloc (¤t_target
,
10808 TARGET_OBJECT_MEMORY_MAP
, NULL
);
10812 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
10814 result
= parse_memory_map (text
);
10815 do_cleanups (back_to
);
10822 packet_command (char *args
, int from_tty
)
10824 struct remote_state
*rs
= get_remote_state ();
10826 if (!rs
->remote_desc
)
10827 error (_("command can only be used with remote target"));
10830 error (_("remote-packet command requires packet text as argument"));
10832 puts_filtered ("sending: ");
10833 print_packet (args
);
10834 puts_filtered ("\n");
10837 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
10838 puts_filtered ("received: ");
10839 print_packet (rs
->buf
);
10840 puts_filtered ("\n");
10844 /* --------- UNIT_TEST for THREAD oriented PACKETS ------------------- */
10846 static void display_thread_info (struct gdb_ext_thread_info
*info
);
10848 static void threadset_test_cmd (char *cmd
, int tty
);
10850 static void threadalive_test (char *cmd
, int tty
);
10852 static void threadlist_test_cmd (char *cmd
, int tty
);
10854 int get_and_display_threadinfo (threadref
*ref
);
10856 static void threadinfo_test_cmd (char *cmd
, int tty
);
10858 static int thread_display_step (threadref
*ref
, void *context
);
10860 static void threadlist_update_test_cmd (char *cmd
, int tty
);
10862 static void init_remote_threadtests (void);
10864 #define SAMPLE_THREAD 0x05060708 /* Truncated 64 bit threadid. */
10867 threadset_test_cmd (char *cmd
, int tty
)
10869 int sample_thread
= SAMPLE_THREAD
;
10871 printf_filtered (_("Remote threadset test\n"));
10872 set_general_thread (sample_thread
);
10877 threadalive_test (char *cmd
, int tty
)
10879 int sample_thread
= SAMPLE_THREAD
;
10880 int pid
= ptid_get_pid (inferior_ptid
);
10881 ptid_t ptid
= ptid_build (pid
, sample_thread
, 0);
10883 if (remote_thread_alive (ptid
))
10884 printf_filtered ("PASS: Thread alive test\n");
10886 printf_filtered ("FAIL: Thread alive test\n");
10889 void output_threadid (char *title
, threadref
*ref
);
10892 output_threadid (char *title
, threadref
*ref
)
10896 pack_threadid (&hexid
[0], ref
); /* Convert threead id into hex. */
10898 printf_filtered ("%s %s\n", title
, (&hexid
[0]));
10902 threadlist_test_cmd (char *cmd
, int tty
)
10905 threadref nextthread
;
10906 int done
, result_count
;
10907 threadref threadlist
[3];
10909 printf_filtered ("Remote Threadlist test\n");
10910 if (!remote_get_threadlist (startflag
, &nextthread
, 3, &done
,
10911 &result_count
, &threadlist
[0]))
10912 printf_filtered ("FAIL: threadlist test\n");
10915 threadref
*scan
= threadlist
;
10916 threadref
*limit
= scan
+ result_count
;
10918 while (scan
< limit
)
10919 output_threadid (" thread ", scan
++);
10924 display_thread_info (struct gdb_ext_thread_info
*info
)
10926 output_threadid ("Threadid: ", &info
->threadid
);
10927 printf_filtered ("Name: %s\n ", info
->shortname
);
10928 printf_filtered ("State: %s\n", info
->display
);
10929 printf_filtered ("other: %s\n\n", info
->more_display
);
10933 get_and_display_threadinfo (threadref
*ref
)
10937 struct gdb_ext_thread_info threadinfo
;
10939 set
= TAG_THREADID
| TAG_EXISTS
| TAG_THREADNAME
10940 | TAG_MOREDISPLAY
| TAG_DISPLAY
;
10941 if (0 != (result
= remote_get_threadinfo (ref
, set
, &threadinfo
)))
10942 display_thread_info (&threadinfo
);
10947 threadinfo_test_cmd (char *cmd
, int tty
)
10949 int athread
= SAMPLE_THREAD
;
10953 int_to_threadref (&thread
, athread
);
10954 printf_filtered ("Remote Threadinfo test\n");
10955 if (!get_and_display_threadinfo (&thread
))
10956 printf_filtered ("FAIL cannot get thread info\n");
10960 thread_display_step (threadref
*ref
, void *context
)
10962 /* output_threadid(" threadstep ",ref); *//* simple test */
10963 return get_and_display_threadinfo (ref
);
10967 threadlist_update_test_cmd (char *cmd
, int tty
)
10969 printf_filtered ("Remote Threadlist update test\n");
10970 remote_threadlist_iterator (thread_display_step
, 0, CRAZY_MAX_THREADS
);
10974 init_remote_threadtests (void)
10976 add_com ("tlist", class_obscure
, threadlist_test_cmd
,
10977 _("Fetch and print the remote list of "
10978 "thread identifiers, one pkt only"));
10979 add_com ("tinfo", class_obscure
, threadinfo_test_cmd
,
10980 _("Fetch and display info about one thread"));
10981 add_com ("tset", class_obscure
, threadset_test_cmd
,
10982 _("Test setting to a different thread"));
10983 add_com ("tupd", class_obscure
, threadlist_update_test_cmd
,
10984 _("Iterate through updating all remote thread info"));
10985 add_com ("talive", class_obscure
, threadalive_test
,
10986 _(" Remote thread alive test "));
10991 /* Convert a thread ID to a string. Returns the string in a static
10994 static const char *
10995 remote_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
10997 static char buf
[64];
10998 struct remote_state
*rs
= get_remote_state ();
11000 if (ptid_equal (ptid
, null_ptid
))
11001 return normal_pid_to_str (ptid
);
11002 else if (ptid_is_pid (ptid
))
11004 /* Printing an inferior target id. */
11006 /* When multi-process extensions are off, there's no way in the
11007 remote protocol to know the remote process id, if there's any
11008 at all. There's one exception --- when we're connected with
11009 target extended-remote, and we manually attached to a process
11010 with "attach PID". We don't record anywhere a flag that
11011 allows us to distinguish that case from the case of
11012 connecting with extended-remote and the stub already being
11013 attached to a process, and reporting yes to qAttached, hence
11014 no smart special casing here. */
11015 if (!remote_multi_process_p (rs
))
11017 xsnprintf (buf
, sizeof buf
, "Remote target");
11021 return normal_pid_to_str (ptid
);
11025 if (ptid_equal (magic_null_ptid
, ptid
))
11026 xsnprintf (buf
, sizeof buf
, "Thread <main>");
11027 else if (remote_multi_process_p (rs
))
11028 if (ptid_get_lwp (ptid
) == 0)
11029 return normal_pid_to_str (ptid
);
11031 xsnprintf (buf
, sizeof buf
, "Thread %d.%ld",
11032 ptid_get_pid (ptid
), ptid_get_lwp (ptid
));
11034 xsnprintf (buf
, sizeof buf
, "Thread %ld",
11035 ptid_get_lwp (ptid
));
11040 /* Get the address of the thread local variable in OBJFILE which is
11041 stored at OFFSET within the thread local storage for thread PTID. */
11044 remote_get_thread_local_address (struct target_ops
*ops
,
11045 ptid_t ptid
, CORE_ADDR lm
, CORE_ADDR offset
)
11047 if (packet_support (PACKET_qGetTLSAddr
) != PACKET_DISABLE
)
11049 struct remote_state
*rs
= get_remote_state ();
11051 char *endp
= rs
->buf
+ get_remote_packet_size ();
11052 enum packet_result result
;
11054 strcpy (p
, "qGetTLSAddr:");
11056 p
= write_ptid (p
, endp
, ptid
);
11058 p
+= hexnumstr (p
, offset
);
11060 p
+= hexnumstr (p
, lm
);
11064 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11065 result
= packet_ok (rs
->buf
,
11066 &remote_protocol_packets
[PACKET_qGetTLSAddr
]);
11067 if (result
== PACKET_OK
)
11071 unpack_varlen_hex (rs
->buf
, &result
);
11074 else if (result
== PACKET_UNKNOWN
)
11075 throw_error (TLS_GENERIC_ERROR
,
11076 _("Remote target doesn't support qGetTLSAddr packet"));
11078 throw_error (TLS_GENERIC_ERROR
,
11079 _("Remote target failed to process qGetTLSAddr request"));
11082 throw_error (TLS_GENERIC_ERROR
,
11083 _("TLS not supported or disabled on this target"));
11088 /* Provide thread local base, i.e. Thread Information Block address.
11089 Returns 1 if ptid is found and thread_local_base is non zero. */
11092 remote_get_tib_address (struct target_ops
*self
, ptid_t ptid
, CORE_ADDR
*addr
)
11094 if (packet_support (PACKET_qGetTIBAddr
) != PACKET_DISABLE
)
11096 struct remote_state
*rs
= get_remote_state ();
11098 char *endp
= rs
->buf
+ get_remote_packet_size ();
11099 enum packet_result result
;
11101 strcpy (p
, "qGetTIBAddr:");
11103 p
= write_ptid (p
, endp
, ptid
);
11107 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
11108 result
= packet_ok (rs
->buf
,
11109 &remote_protocol_packets
[PACKET_qGetTIBAddr
]);
11110 if (result
== PACKET_OK
)
11114 unpack_varlen_hex (rs
->buf
, &result
);
11116 *addr
= (CORE_ADDR
) result
;
11119 else if (result
== PACKET_UNKNOWN
)
11120 error (_("Remote target doesn't support qGetTIBAddr packet"));
11122 error (_("Remote target failed to process qGetTIBAddr request"));
11125 error (_("qGetTIBAddr not supported or disabled on this target"));
11130 /* Support for inferring a target description based on the current
11131 architecture and the size of a 'g' packet. While the 'g' packet
11132 can have any size (since optional registers can be left off the
11133 end), some sizes are easily recognizable given knowledge of the
11134 approximate architecture. */
11136 struct remote_g_packet_guess
11139 const struct target_desc
*tdesc
;
11141 typedef struct remote_g_packet_guess remote_g_packet_guess_s
;
11142 DEF_VEC_O(remote_g_packet_guess_s
);
11144 struct remote_g_packet_data
11146 VEC(remote_g_packet_guess_s
) *guesses
;
11149 static struct gdbarch_data
*remote_g_packet_data_handle
;
11152 remote_g_packet_data_init (struct obstack
*obstack
)
11154 return OBSTACK_ZALLOC (obstack
, struct remote_g_packet_data
);
11158 register_remote_g_packet_guess (struct gdbarch
*gdbarch
, int bytes
,
11159 const struct target_desc
*tdesc
)
11161 struct remote_g_packet_data
*data
11162 = ((struct remote_g_packet_data
*)
11163 gdbarch_data (gdbarch
, remote_g_packet_data_handle
));
11164 struct remote_g_packet_guess new_guess
, *guess
;
11167 gdb_assert (tdesc
!= NULL
);
11170 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11172 if (guess
->bytes
== bytes
)
11173 internal_error (__FILE__
, __LINE__
,
11174 _("Duplicate g packet description added for size %d"),
11177 new_guess
.bytes
= bytes
;
11178 new_guess
.tdesc
= tdesc
;
11179 VEC_safe_push (remote_g_packet_guess_s
, data
->guesses
, &new_guess
);
11182 /* Return 1 if remote_read_description would do anything on this target
11183 and architecture, 0 otherwise. */
11186 remote_read_description_p (struct target_ops
*target
)
11188 struct remote_g_packet_data
*data
11189 = ((struct remote_g_packet_data
*)
11190 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11192 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11198 static const struct target_desc
*
11199 remote_read_description (struct target_ops
*target
)
11201 struct remote_g_packet_data
*data
11202 = ((struct remote_g_packet_data
*)
11203 gdbarch_data (target_gdbarch (), remote_g_packet_data_handle
));
11205 /* Do not try this during initial connection, when we do not know
11206 whether there is a running but stopped thread. */
11207 if (!target_has_execution
|| ptid_equal (inferior_ptid
, null_ptid
))
11208 return target
->beneath
->to_read_description (target
->beneath
);
11210 if (!VEC_empty (remote_g_packet_guess_s
, data
->guesses
))
11212 struct remote_g_packet_guess
*guess
;
11214 int bytes
= send_g_packet ();
11217 VEC_iterate (remote_g_packet_guess_s
, data
->guesses
, ix
, guess
);
11219 if (guess
->bytes
== bytes
)
11220 return guess
->tdesc
;
11222 /* We discard the g packet. A minor optimization would be to
11223 hold on to it, and fill the register cache once we have selected
11224 an architecture, but it's too tricky to do safely. */
11227 return target
->beneath
->to_read_description (target
->beneath
);
11230 /* Remote file transfer support. This is host-initiated I/O, not
11231 target-initiated; for target-initiated, see remote-fileio.c. */
11233 /* If *LEFT is at least the length of STRING, copy STRING to
11234 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11235 decrease *LEFT. Otherwise raise an error. */
11238 remote_buffer_add_string (char **buffer
, int *left
, const char *string
)
11240 int len
= strlen (string
);
11243 error (_("Packet too long for target."));
11245 memcpy (*buffer
, string
, len
);
11249 /* NUL-terminate the buffer as a convenience, if there is
11255 /* If *LEFT is large enough, hex encode LEN bytes from BYTES into
11256 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11257 decrease *LEFT. Otherwise raise an error. */
11260 remote_buffer_add_bytes (char **buffer
, int *left
, const gdb_byte
*bytes
,
11263 if (2 * len
> *left
)
11264 error (_("Packet too long for target."));
11266 bin2hex (bytes
, *buffer
, len
);
11267 *buffer
+= 2 * len
;
11270 /* NUL-terminate the buffer as a convenience, if there is
11276 /* If *LEFT is large enough, convert VALUE to hex and add it to
11277 *BUFFER, update *BUFFER to point to the new end of the buffer, and
11278 decrease *LEFT. Otherwise raise an error. */
11281 remote_buffer_add_int (char **buffer
, int *left
, ULONGEST value
)
11283 int len
= hexnumlen (value
);
11286 error (_("Packet too long for target."));
11288 hexnumstr (*buffer
, value
);
11292 /* NUL-terminate the buffer as a convenience, if there is
11298 /* Parse an I/O result packet from BUFFER. Set RETCODE to the return
11299 value, *REMOTE_ERRNO to the remote error number or zero if none
11300 was included, and *ATTACHMENT to point to the start of the annex
11301 if any. The length of the packet isn't needed here; there may
11302 be NUL bytes in BUFFER, but they will be after *ATTACHMENT.
11304 Return 0 if the packet could be parsed, -1 if it could not. If
11305 -1 is returned, the other variables may not be initialized. */
11308 remote_hostio_parse_result (char *buffer
, int *retcode
,
11309 int *remote_errno
, char **attachment
)
11314 *attachment
= NULL
;
11316 if (buffer
[0] != 'F')
11320 *retcode
= strtol (&buffer
[1], &p
, 16);
11321 if (errno
!= 0 || p
== &buffer
[1])
11324 /* Check for ",errno". */
11328 *remote_errno
= strtol (p
+ 1, &p2
, 16);
11329 if (errno
!= 0 || p
+ 1 == p2
)
11334 /* Check for ";attachment". If there is no attachment, the
11335 packet should end here. */
11338 *attachment
= p
+ 1;
11341 else if (*p
== '\0')
11347 /* Send a prepared I/O packet to the target and read its response.
11348 The prepared packet is in the global RS->BUF before this function
11349 is called, and the answer is there when we return.
11351 COMMAND_BYTES is the length of the request to send, which may include
11352 binary data. WHICH_PACKET is the packet configuration to check
11353 before attempting a packet. If an error occurs, *REMOTE_ERRNO
11354 is set to the error number and -1 is returned. Otherwise the value
11355 returned by the function is returned.
11357 ATTACHMENT and ATTACHMENT_LEN should be non-NULL if and only if an
11358 attachment is expected; an error will be reported if there's a
11359 mismatch. If one is found, *ATTACHMENT will be set to point into
11360 the packet buffer and *ATTACHMENT_LEN will be set to the
11361 attachment's length. */
11364 remote_hostio_send_command (int command_bytes
, int which_packet
,
11365 int *remote_errno
, char **attachment
,
11366 int *attachment_len
)
11368 struct remote_state
*rs
= get_remote_state ();
11369 int ret
, bytes_read
;
11370 char *attachment_tmp
;
11372 if (!rs
->remote_desc
11373 || packet_support (which_packet
) == PACKET_DISABLE
)
11375 *remote_errno
= FILEIO_ENOSYS
;
11379 putpkt_binary (rs
->buf
, command_bytes
);
11380 bytes_read
= getpkt_sane (&rs
->buf
, &rs
->buf_size
, 0);
11382 /* If it timed out, something is wrong. Don't try to parse the
11384 if (bytes_read
< 0)
11386 *remote_errno
= FILEIO_EINVAL
;
11390 switch (packet_ok (rs
->buf
, &remote_protocol_packets
[which_packet
]))
11393 *remote_errno
= FILEIO_EINVAL
;
11395 case PACKET_UNKNOWN
:
11396 *remote_errno
= FILEIO_ENOSYS
;
11402 if (remote_hostio_parse_result (rs
->buf
, &ret
, remote_errno
,
11405 *remote_errno
= FILEIO_EINVAL
;
11409 /* Make sure we saw an attachment if and only if we expected one. */
11410 if ((attachment_tmp
== NULL
&& attachment
!= NULL
)
11411 || (attachment_tmp
!= NULL
&& attachment
== NULL
))
11413 *remote_errno
= FILEIO_EINVAL
;
11417 /* If an attachment was found, it must point into the packet buffer;
11418 work out how many bytes there were. */
11419 if (attachment_tmp
!= NULL
)
11421 *attachment
= attachment_tmp
;
11422 *attachment_len
= bytes_read
- (*attachment
- rs
->buf
);
11428 /* Invalidate the readahead cache. */
11431 readahead_cache_invalidate (void)
11433 struct remote_state
*rs
= get_remote_state ();
11435 rs
->readahead_cache
.fd
= -1;
11438 /* Invalidate the readahead cache if it is holding data for FD. */
11441 readahead_cache_invalidate_fd (int fd
)
11443 struct remote_state
*rs
= get_remote_state ();
11445 if (rs
->readahead_cache
.fd
== fd
)
11446 rs
->readahead_cache
.fd
= -1;
11449 /* Set the filesystem remote_hostio functions that take FILENAME
11450 arguments will use. Return 0 on success, or -1 if an error
11451 occurs (and set *REMOTE_ERRNO). */
11454 remote_hostio_set_filesystem (struct inferior
*inf
, int *remote_errno
)
11456 struct remote_state
*rs
= get_remote_state ();
11457 int required_pid
= (inf
== NULL
|| inf
->fake_pid_p
) ? 0 : inf
->pid
;
11459 int left
= get_remote_packet_size () - 1;
11463 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11466 if (rs
->fs_pid
!= -1 && required_pid
== rs
->fs_pid
)
11469 remote_buffer_add_string (&p
, &left
, "vFile:setfs:");
11471 xsnprintf (arg
, sizeof (arg
), "%x", required_pid
);
11472 remote_buffer_add_string (&p
, &left
, arg
);
11474 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_setfs
,
11475 remote_errno
, NULL
, NULL
);
11477 if (packet_support (PACKET_vFile_setfs
) == PACKET_DISABLE
)
11481 rs
->fs_pid
= required_pid
;
11486 /* Implementation of to_fileio_open. */
11489 remote_hostio_open (struct target_ops
*self
,
11490 struct inferior
*inf
, const char *filename
,
11491 int flags
, int mode
, int warn_if_slow
,
11494 struct remote_state
*rs
= get_remote_state ();
11496 int left
= get_remote_packet_size () - 1;
11500 static int warning_issued
= 0;
11502 printf_unfiltered (_("Reading %s from remote target...\n"),
11505 if (!warning_issued
)
11507 warning (_("File transfers from remote targets can be slow."
11508 " Use \"set sysroot\" to access files locally"
11510 warning_issued
= 1;
11514 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11517 remote_buffer_add_string (&p
, &left
, "vFile:open:");
11519 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11520 strlen (filename
));
11521 remote_buffer_add_string (&p
, &left
, ",");
11523 remote_buffer_add_int (&p
, &left
, flags
);
11524 remote_buffer_add_string (&p
, &left
, ",");
11526 remote_buffer_add_int (&p
, &left
, mode
);
11528 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_open
,
11529 remote_errno
, NULL
, NULL
);
11532 /* Implementation of to_fileio_pwrite. */
11535 remote_hostio_pwrite (struct target_ops
*self
,
11536 int fd
, const gdb_byte
*write_buf
, int len
,
11537 ULONGEST offset
, int *remote_errno
)
11539 struct remote_state
*rs
= get_remote_state ();
11541 int left
= get_remote_packet_size ();
11544 readahead_cache_invalidate_fd (fd
);
11546 remote_buffer_add_string (&p
, &left
, "vFile:pwrite:");
11548 remote_buffer_add_int (&p
, &left
, fd
);
11549 remote_buffer_add_string (&p
, &left
, ",");
11551 remote_buffer_add_int (&p
, &left
, offset
);
11552 remote_buffer_add_string (&p
, &left
, ",");
11554 p
+= remote_escape_output (write_buf
, len
, 1, (gdb_byte
*) p
, &out_len
,
11555 get_remote_packet_size () - (p
- rs
->buf
));
11557 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pwrite
,
11558 remote_errno
, NULL
, NULL
);
11561 /* Helper for the implementation of to_fileio_pread. Read the file
11562 from the remote side with vFile:pread. */
11565 remote_hostio_pread_vFile (struct target_ops
*self
,
11566 int fd
, gdb_byte
*read_buf
, int len
,
11567 ULONGEST offset
, int *remote_errno
)
11569 struct remote_state
*rs
= get_remote_state ();
11572 int left
= get_remote_packet_size ();
11573 int ret
, attachment_len
;
11576 remote_buffer_add_string (&p
, &left
, "vFile:pread:");
11578 remote_buffer_add_int (&p
, &left
, fd
);
11579 remote_buffer_add_string (&p
, &left
, ",");
11581 remote_buffer_add_int (&p
, &left
, len
);
11582 remote_buffer_add_string (&p
, &left
, ",");
11584 remote_buffer_add_int (&p
, &left
, offset
);
11586 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_pread
,
11587 remote_errno
, &attachment
,
11593 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11595 if (read_len
!= ret
)
11596 error (_("Read returned %d, but %d bytes."), ret
, (int) read_len
);
11601 /* Serve pread from the readahead cache. Returns number of bytes
11602 read, or 0 if the request can't be served from the cache. */
11605 remote_hostio_pread_from_cache (struct remote_state
*rs
,
11606 int fd
, gdb_byte
*read_buf
, size_t len
,
11609 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11611 if (cache
->fd
== fd
11612 && cache
->offset
<= offset
11613 && offset
< cache
->offset
+ cache
->bufsize
)
11615 ULONGEST max
= cache
->offset
+ cache
->bufsize
;
11617 if (offset
+ len
> max
)
11618 len
= max
- offset
;
11620 memcpy (read_buf
, cache
->buf
+ offset
- cache
->offset
, len
);
11627 /* Implementation of to_fileio_pread. */
11630 remote_hostio_pread (struct target_ops
*self
,
11631 int fd
, gdb_byte
*read_buf
, int len
,
11632 ULONGEST offset
, int *remote_errno
)
11635 struct remote_state
*rs
= get_remote_state ();
11636 struct readahead_cache
*cache
= &rs
->readahead_cache
;
11638 ret
= remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11641 cache
->hit_count
++;
11644 fprintf_unfiltered (gdb_stdlog
, "readahead cache hit %s\n",
11645 pulongest (cache
->hit_count
));
11649 cache
->miss_count
++;
11651 fprintf_unfiltered (gdb_stdlog
, "readahead cache miss %s\n",
11652 pulongest (cache
->miss_count
));
11655 cache
->offset
= offset
;
11656 cache
->bufsize
= get_remote_packet_size ();
11657 cache
->buf
= (gdb_byte
*) xrealloc (cache
->buf
, cache
->bufsize
);
11659 ret
= remote_hostio_pread_vFile (self
, cache
->fd
, cache
->buf
, cache
->bufsize
,
11660 cache
->offset
, remote_errno
);
11663 readahead_cache_invalidate_fd (fd
);
11667 cache
->bufsize
= ret
;
11668 return remote_hostio_pread_from_cache (rs
, fd
, read_buf
, len
, offset
);
11671 /* Implementation of to_fileio_close. */
11674 remote_hostio_close (struct target_ops
*self
, int fd
, int *remote_errno
)
11676 struct remote_state
*rs
= get_remote_state ();
11678 int left
= get_remote_packet_size () - 1;
11680 readahead_cache_invalidate_fd (fd
);
11682 remote_buffer_add_string (&p
, &left
, "vFile:close:");
11684 remote_buffer_add_int (&p
, &left
, fd
);
11686 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_close
,
11687 remote_errno
, NULL
, NULL
);
11690 /* Implementation of to_fileio_unlink. */
11693 remote_hostio_unlink (struct target_ops
*self
,
11694 struct inferior
*inf
, const char *filename
,
11697 struct remote_state
*rs
= get_remote_state ();
11699 int left
= get_remote_packet_size () - 1;
11701 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11704 remote_buffer_add_string (&p
, &left
, "vFile:unlink:");
11706 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11707 strlen (filename
));
11709 return remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_unlink
,
11710 remote_errno
, NULL
, NULL
);
11713 /* Implementation of to_fileio_readlink. */
11716 remote_hostio_readlink (struct target_ops
*self
,
11717 struct inferior
*inf
, const char *filename
,
11720 struct remote_state
*rs
= get_remote_state ();
11723 int left
= get_remote_packet_size ();
11724 int len
, attachment_len
;
11728 if (remote_hostio_set_filesystem (inf
, remote_errno
) != 0)
11731 remote_buffer_add_string (&p
, &left
, "vFile:readlink:");
11733 remote_buffer_add_bytes (&p
, &left
, (const gdb_byte
*) filename
,
11734 strlen (filename
));
11736 len
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_readlink
,
11737 remote_errno
, &attachment
,
11743 ret
= (char *) xmalloc (len
+ 1);
11745 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11746 (gdb_byte
*) ret
, len
);
11747 if (read_len
!= len
)
11748 error (_("Readlink returned %d, but %d bytes."), len
, read_len
);
11754 /* Implementation of to_fileio_fstat. */
11757 remote_hostio_fstat (struct target_ops
*self
,
11758 int fd
, struct stat
*st
,
11761 struct remote_state
*rs
= get_remote_state ();
11763 int left
= get_remote_packet_size ();
11764 int attachment_len
, ret
;
11766 struct fio_stat fst
;
11769 remote_buffer_add_string (&p
, &left
, "vFile:fstat:");
11771 remote_buffer_add_int (&p
, &left
, fd
);
11773 ret
= remote_hostio_send_command (p
- rs
->buf
, PACKET_vFile_fstat
,
11774 remote_errno
, &attachment
,
11778 if (*remote_errno
!= FILEIO_ENOSYS
)
11781 /* Strictly we should return -1, ENOSYS here, but when
11782 "set sysroot remote:" was implemented in August 2008
11783 BFD's need for a stat function was sidestepped with
11784 this hack. This was not remedied until March 2015
11785 so we retain the previous behavior to avoid breaking
11788 Note that the memset is a March 2015 addition; older
11789 GDBs set st_size *and nothing else* so the structure
11790 would have garbage in all other fields. This might
11791 break something but retaining the previous behavior
11792 here would be just too wrong. */
11794 memset (st
, 0, sizeof (struct stat
));
11795 st
->st_size
= INT_MAX
;
11799 read_len
= remote_unescape_input ((gdb_byte
*) attachment
, attachment_len
,
11800 (gdb_byte
*) &fst
, sizeof (fst
));
11802 if (read_len
!= ret
)
11803 error (_("vFile:fstat returned %d, but %d bytes."), ret
, read_len
);
11805 if (read_len
!= sizeof (fst
))
11806 error (_("vFile:fstat returned %d bytes, but expecting %d."),
11807 read_len
, (int) sizeof (fst
));
11809 remote_fileio_to_host_stat (&fst
, st
);
11814 /* Implementation of to_filesystem_is_local. */
11817 remote_filesystem_is_local (struct target_ops
*self
)
11819 /* Valgrind GDB presents itself as a remote target but works
11820 on the local filesystem: it does not implement remote get
11821 and users are not expected to set a sysroot. To handle
11822 this case we treat the remote filesystem as local if the
11823 sysroot is exactly TARGET_SYSROOT_PREFIX and if the stub
11824 does not support vFile:open. */
11825 if (strcmp (gdb_sysroot
, TARGET_SYSROOT_PREFIX
) == 0)
11827 enum packet_support ps
= packet_support (PACKET_vFile_open
);
11829 if (ps
== PACKET_SUPPORT_UNKNOWN
)
11831 int fd
, remote_errno
;
11833 /* Try opening a file to probe support. The supplied
11834 filename is irrelevant, we only care about whether
11835 the stub recognizes the packet or not. */
11836 fd
= remote_hostio_open (self
, NULL
, "just probing",
11837 FILEIO_O_RDONLY
, 0700, 0,
11841 remote_hostio_close (self
, fd
, &remote_errno
);
11843 ps
= packet_support (PACKET_vFile_open
);
11846 if (ps
== PACKET_DISABLE
)
11848 static int warning_issued
= 0;
11850 if (!warning_issued
)
11852 warning (_("remote target does not support file"
11853 " transfer, attempting to access files"
11854 " from local filesystem."));
11855 warning_issued
= 1;
11866 remote_fileio_errno_to_host (int errnum
)
11872 case FILEIO_ENOENT
:
11880 case FILEIO_EACCES
:
11882 case FILEIO_EFAULT
:
11886 case FILEIO_EEXIST
:
11888 case FILEIO_ENODEV
:
11890 case FILEIO_ENOTDIR
:
11892 case FILEIO_EISDIR
:
11894 case FILEIO_EINVAL
:
11896 case FILEIO_ENFILE
:
11898 case FILEIO_EMFILE
:
11902 case FILEIO_ENOSPC
:
11904 case FILEIO_ESPIPE
:
11908 case FILEIO_ENOSYS
:
11910 case FILEIO_ENAMETOOLONG
:
11911 return ENAMETOOLONG
;
11917 remote_hostio_error (int errnum
)
11919 int host_error
= remote_fileio_errno_to_host (errnum
);
11921 if (host_error
== -1)
11922 error (_("Unknown remote I/O error %d"), errnum
);
11924 error (_("Remote I/O error: %s"), safe_strerror (host_error
));
11928 remote_hostio_close_cleanup (void *opaque
)
11930 int fd
= *(int *) opaque
;
11933 remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
);
11937 remote_file_put (const char *local_file
, const char *remote_file
, int from_tty
)
11939 struct cleanup
*back_to
, *close_cleanup
;
11940 int retcode
, fd
, remote_errno
, bytes
, io_size
;
11942 int bytes_in_buffer
;
11945 struct remote_state
*rs
= get_remote_state ();
11947 if (!rs
->remote_desc
)
11948 error (_("command can only be used with remote target"));
11950 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "rb");
11952 perror_with_name (local_file
);
11954 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
11955 remote_file
, (FILEIO_O_WRONLY
| FILEIO_O_CREAT
11957 0700, 0, &remote_errno
);
11959 remote_hostio_error (remote_errno
);
11961 /* Send up to this many bytes at once. They won't all fit in the
11962 remote packet limit, so we'll transfer slightly fewer. */
11963 io_size
= get_remote_packet_size ();
11964 buffer
= (gdb_byte
*) xmalloc (io_size
);
11965 back_to
= make_cleanup (xfree
, buffer
);
11967 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
11969 bytes_in_buffer
= 0;
11972 while (bytes_in_buffer
|| !saw_eof
)
11976 bytes
= fread (buffer
+ bytes_in_buffer
, 1,
11977 io_size
- bytes_in_buffer
,
11981 if (ferror (file
.get ()))
11982 error (_("Error reading %s."), local_file
);
11985 /* EOF. Unless there is something still in the
11986 buffer from the last iteration, we are done. */
11988 if (bytes_in_buffer
== 0)
11996 bytes
+= bytes_in_buffer
;
11997 bytes_in_buffer
= 0;
11999 retcode
= remote_hostio_pwrite (find_target_at (process_stratum
),
12001 offset
, &remote_errno
);
12004 remote_hostio_error (remote_errno
);
12005 else if (retcode
== 0)
12006 error (_("Remote write of %d bytes returned 0!"), bytes
);
12007 else if (retcode
< bytes
)
12009 /* Short write. Save the rest of the read data for the next
12011 bytes_in_buffer
= bytes
- retcode
;
12012 memmove (buffer
, buffer
+ retcode
, bytes_in_buffer
);
12018 discard_cleanups (close_cleanup
);
12019 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12020 remote_hostio_error (remote_errno
);
12023 printf_filtered (_("Successfully sent file \"%s\".\n"), local_file
);
12024 do_cleanups (back_to
);
12028 remote_file_get (const char *remote_file
, const char *local_file
, int from_tty
)
12030 struct cleanup
*back_to
, *close_cleanup
;
12031 int fd
, remote_errno
, bytes
, io_size
;
12034 struct remote_state
*rs
= get_remote_state ();
12036 if (!rs
->remote_desc
)
12037 error (_("command can only be used with remote target"));
12039 fd
= remote_hostio_open (find_target_at (process_stratum
), NULL
,
12040 remote_file
, FILEIO_O_RDONLY
, 0, 0,
12043 remote_hostio_error (remote_errno
);
12045 gdb_file_up file
= gdb_fopen_cloexec (local_file
, "wb");
12047 perror_with_name (local_file
);
12049 /* Send up to this many bytes at once. They won't all fit in the
12050 remote packet limit, so we'll transfer slightly fewer. */
12051 io_size
= get_remote_packet_size ();
12052 buffer
= (gdb_byte
*) xmalloc (io_size
);
12053 back_to
= make_cleanup (xfree
, buffer
);
12055 close_cleanup
= make_cleanup (remote_hostio_close_cleanup
, &fd
);
12060 bytes
= remote_hostio_pread (find_target_at (process_stratum
),
12061 fd
, buffer
, io_size
, offset
, &remote_errno
);
12063 /* Success, but no bytes, means end-of-file. */
12066 remote_hostio_error (remote_errno
);
12070 bytes
= fwrite (buffer
, 1, bytes
, file
.get ());
12072 perror_with_name (local_file
);
12075 discard_cleanups (close_cleanup
);
12076 if (remote_hostio_close (find_target_at (process_stratum
), fd
, &remote_errno
))
12077 remote_hostio_error (remote_errno
);
12080 printf_filtered (_("Successfully fetched file \"%s\".\n"), remote_file
);
12081 do_cleanups (back_to
);
12085 remote_file_delete (const char *remote_file
, int from_tty
)
12087 int retcode
, remote_errno
;
12088 struct remote_state
*rs
= get_remote_state ();
12090 if (!rs
->remote_desc
)
12091 error (_("command can only be used with remote target"));
12093 retcode
= remote_hostio_unlink (find_target_at (process_stratum
),
12094 NULL
, remote_file
, &remote_errno
);
12096 remote_hostio_error (remote_errno
);
12099 printf_filtered (_("Successfully deleted file \"%s\".\n"), remote_file
);
12103 remote_put_command (char *args
, int from_tty
)
12106 error_no_arg (_("file to put"));
12108 gdb_argv
argv (args
);
12109 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12110 error (_("Invalid parameters to remote put"));
12112 remote_file_put (argv
[0], argv
[1], from_tty
);
12116 remote_get_command (char *args
, int from_tty
)
12119 error_no_arg (_("file to get"));
12121 gdb_argv
argv (args
);
12122 if (argv
[0] == NULL
|| argv
[1] == NULL
|| argv
[2] != NULL
)
12123 error (_("Invalid parameters to remote get"));
12125 remote_file_get (argv
[0], argv
[1], from_tty
);
12129 remote_delete_command (char *args
, int from_tty
)
12132 error_no_arg (_("file to delete"));
12134 gdb_argv
argv (args
);
12135 if (argv
[0] == NULL
|| argv
[1] != NULL
)
12136 error (_("Invalid parameters to remote delete"));
12138 remote_file_delete (argv
[0], from_tty
);
12142 remote_command (char *args
, int from_tty
)
12144 help_list (remote_cmdlist
, "remote ", all_commands
, gdb_stdout
);
12148 remote_can_execute_reverse (struct target_ops
*self
)
12150 if (packet_support (PACKET_bs
) == PACKET_ENABLE
12151 || packet_support (PACKET_bc
) == PACKET_ENABLE
)
12158 remote_supports_non_stop (struct target_ops
*self
)
12164 remote_supports_disable_randomization (struct target_ops
*self
)
12166 /* Only supported in extended mode. */
12171 remote_supports_multi_process (struct target_ops
*self
)
12173 struct remote_state
*rs
= get_remote_state ();
12175 return remote_multi_process_p (rs
);
12179 remote_supports_cond_tracepoints (void)
12181 return packet_support (PACKET_ConditionalTracepoints
) == PACKET_ENABLE
;
12185 remote_supports_cond_breakpoints (struct target_ops
*self
)
12187 return packet_support (PACKET_ConditionalBreakpoints
) == PACKET_ENABLE
;
12191 remote_supports_fast_tracepoints (void)
12193 return packet_support (PACKET_FastTracepoints
) == PACKET_ENABLE
;
12197 remote_supports_static_tracepoints (void)
12199 return packet_support (PACKET_StaticTracepoints
) == PACKET_ENABLE
;
12203 remote_supports_install_in_trace (void)
12205 return packet_support (PACKET_InstallInTrace
) == PACKET_ENABLE
;
12209 remote_supports_enable_disable_tracepoint (struct target_ops
*self
)
12211 return (packet_support (PACKET_EnableDisableTracepoints_feature
)
12216 remote_supports_string_tracing (struct target_ops
*self
)
12218 return packet_support (PACKET_tracenz_feature
) == PACKET_ENABLE
;
12222 remote_can_run_breakpoint_commands (struct target_ops
*self
)
12224 return packet_support (PACKET_BreakpointCommands
) == PACKET_ENABLE
;
12228 remote_trace_init (struct target_ops
*self
)
12231 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12232 if (strcmp (target_buf
, "OK") != 0)
12233 error (_("Target does not support this command."));
12236 static void free_actions_list (char **actions_list
);
12237 static void free_actions_list_cleanup_wrapper (void *);
12239 free_actions_list_cleanup_wrapper (void *al
)
12241 free_actions_list ((char **) al
);
12245 free_actions_list (char **actions_list
)
12249 if (actions_list
== 0)
12252 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
12253 xfree (actions_list
[ndx
]);
12255 xfree (actions_list
);
12258 /* Recursive routine to walk through command list including loops, and
12259 download packets for each command. */
12262 remote_download_command_source (int num
, ULONGEST addr
,
12263 struct command_line
*cmds
)
12265 struct remote_state
*rs
= get_remote_state ();
12266 struct command_line
*cmd
;
12268 for (cmd
= cmds
; cmd
; cmd
= cmd
->next
)
12270 QUIT
; /* Allow user to bail out with ^C. */
12271 strcpy (rs
->buf
, "QTDPsrc:");
12272 encode_source_string (num
, addr
, "cmd", cmd
->line
,
12273 rs
->buf
+ strlen (rs
->buf
),
12274 rs
->buf_size
- strlen (rs
->buf
));
12276 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12277 if (strcmp (target_buf
, "OK"))
12278 warning (_("Target does not support source download."));
12280 if (cmd
->control_type
== while_control
12281 || cmd
->control_type
== while_stepping_control
)
12283 remote_download_command_source (num
, addr
, *cmd
->body_list
);
12285 QUIT
; /* Allow user to bail out with ^C. */
12286 strcpy (rs
->buf
, "QTDPsrc:");
12287 encode_source_string (num
, addr
, "cmd", "end",
12288 rs
->buf
+ strlen (rs
->buf
),
12289 rs
->buf_size
- strlen (rs
->buf
));
12291 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12292 if (strcmp (target_buf
, "OK"))
12293 warning (_("Target does not support source download."));
12299 remote_download_tracepoint (struct target_ops
*self
, struct bp_location
*loc
)
12301 #define BUF_SIZE 2048
12305 char buf
[BUF_SIZE
];
12306 char **tdp_actions
;
12307 char **stepping_actions
;
12309 struct cleanup
*old_chain
= NULL
;
12311 struct breakpoint
*b
= loc
->owner
;
12312 struct tracepoint
*t
= (struct tracepoint
*) b
;
12314 encode_actions_rsp (loc
, &tdp_actions
, &stepping_actions
);
12315 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
12317 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
12320 tpaddr
= loc
->address
;
12321 sprintf_vma (addrbuf
, tpaddr
);
12322 xsnprintf (buf
, BUF_SIZE
, "QTDP:%x:%s:%c:%lx:%x", b
->number
,
12323 addrbuf
, /* address */
12324 (b
->enable_state
== bp_enabled
? 'E' : 'D'),
12325 t
->step_count
, t
->pass_count
);
12326 /* Fast tracepoints are mostly handled by the target, but we can
12327 tell the target how big of an instruction block should be moved
12329 if (b
->type
== bp_fast_tracepoint
)
12331 /* Only test for support at download time; we may not know
12332 target capabilities at definition time. */
12333 if (remote_supports_fast_tracepoints ())
12335 if (gdbarch_fast_tracepoint_valid_at (loc
->gdbarch
, tpaddr
,
12337 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":F%x",
12338 gdb_insn_length (loc
->gdbarch
, tpaddr
));
12340 /* If it passed validation at definition but fails now,
12341 something is very wrong. */
12342 internal_error (__FILE__
, __LINE__
,
12343 _("Fast tracepoint not "
12344 "valid during download"));
12347 /* Fast tracepoints are functionally identical to regular
12348 tracepoints, so don't take lack of support as a reason to
12349 give up on the trace run. */
12350 warning (_("Target does not support fast tracepoints, "
12351 "downloading %d as regular tracepoint"), b
->number
);
12353 else if (b
->type
== bp_static_tracepoint
)
12355 /* Only test for support at download time; we may not know
12356 target capabilities at definition time. */
12357 if (remote_supports_static_tracepoints ())
12359 struct static_tracepoint_marker marker
;
12361 if (target_static_tracepoint_marker_at (tpaddr
, &marker
))
12362 strcat (buf
, ":S");
12364 error (_("Static tracepoint not valid during download"));
12367 /* Fast tracepoints are functionally identical to regular
12368 tracepoints, so don't take lack of support as a reason
12369 to give up on the trace run. */
12370 error (_("Target does not support static tracepoints"));
12372 /* If the tracepoint has a conditional, make it into an agent
12373 expression and append to the definition. */
12376 /* Only test support at download time, we may not know target
12377 capabilities at definition time. */
12378 if (remote_supports_cond_tracepoints ())
12380 agent_expr_up aexpr
= gen_eval_for_expr (tpaddr
, loc
->cond
.get ());
12381 xsnprintf (buf
+ strlen (buf
), BUF_SIZE
- strlen (buf
), ":X%x,",
12383 pkt
= buf
+ strlen (buf
);
12384 for (ndx
= 0; ndx
< aexpr
->len
; ++ndx
)
12385 pkt
= pack_hex_byte (pkt
, aexpr
->buf
[ndx
]);
12389 warning (_("Target does not support conditional tracepoints, "
12390 "ignoring tp %d cond"), b
->number
);
12393 if (b
->commands
|| *default_collect
)
12396 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12397 if (strcmp (target_buf
, "OK"))
12398 error (_("Target does not support tracepoints."));
12400 /* do_single_steps (t); */
12403 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
12405 QUIT
; /* Allow user to bail out with ^C. */
12406 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%c",
12407 b
->number
, addrbuf
, /* address */
12409 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
12412 remote_get_noisy_reply (&target_buf
,
12414 if (strcmp (target_buf
, "OK"))
12415 error (_("Error on target while setting tracepoints."));
12418 if (stepping_actions
)
12420 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
12422 QUIT
; /* Allow user to bail out with ^C. */
12423 xsnprintf (buf
, BUF_SIZE
, "QTDP:-%x:%s:%s%s%s",
12424 b
->number
, addrbuf
, /* address */
12425 ((ndx
== 0) ? "S" : ""),
12426 stepping_actions
[ndx
],
12427 (stepping_actions
[ndx
+ 1] ? "-" : ""));
12429 remote_get_noisy_reply (&target_buf
,
12431 if (strcmp (target_buf
, "OK"))
12432 error (_("Error on target while setting tracepoints."));
12436 if (packet_support (PACKET_TracepointSource
) == PACKET_ENABLE
)
12438 if (b
->location
!= NULL
)
12440 strcpy (buf
, "QTDPsrc:");
12441 encode_source_string (b
->number
, loc
->address
, "at",
12442 event_location_to_string (b
->location
.get ()),
12443 buf
+ strlen (buf
), 2048 - strlen (buf
));
12445 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12446 if (strcmp (target_buf
, "OK"))
12447 warning (_("Target does not support source download."));
12449 if (b
->cond_string
)
12451 strcpy (buf
, "QTDPsrc:");
12452 encode_source_string (b
->number
, loc
->address
,
12453 "cond", b
->cond_string
, buf
+ strlen (buf
),
12454 2048 - strlen (buf
));
12456 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12457 if (strcmp (target_buf
, "OK"))
12458 warning (_("Target does not support source download."));
12460 remote_download_command_source (b
->number
, loc
->address
,
12461 breakpoint_commands (b
));
12464 do_cleanups (old_chain
);
12468 remote_can_download_tracepoint (struct target_ops
*self
)
12470 struct remote_state
*rs
= get_remote_state ();
12471 struct trace_status
*ts
;
12474 /* Don't try to install tracepoints until we've relocated our
12475 symbols, and fetched and merged the target's tracepoint list with
12477 if (rs
->starting_up
)
12480 ts
= current_trace_status ();
12481 status
= remote_get_trace_status (self
, ts
);
12483 if (status
== -1 || !ts
->running_known
|| !ts
->running
)
12486 /* If we are in a tracing experiment, but remote stub doesn't support
12487 installing tracepoint in trace, we have to return. */
12488 if (!remote_supports_install_in_trace ())
12496 remote_download_trace_state_variable (struct target_ops
*self
,
12497 struct trace_state_variable
*tsv
)
12499 struct remote_state
*rs
= get_remote_state ();
12502 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDV:%x:%s:%x:",
12503 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8),
12505 p
= rs
->buf
+ strlen (rs
->buf
);
12506 if ((p
- rs
->buf
) + strlen (tsv
->name
) * 2 >= get_remote_packet_size ())
12507 error (_("Trace state variable name too long for tsv definition packet"));
12508 p
+= 2 * bin2hex ((gdb_byte
*) (tsv
->name
), p
, strlen (tsv
->name
));
12511 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12512 if (*target_buf
== '\0')
12513 error (_("Target does not support this command."));
12514 if (strcmp (target_buf
, "OK") != 0)
12515 error (_("Error on target while downloading trace state variable."));
12519 remote_enable_tracepoint (struct target_ops
*self
,
12520 struct bp_location
*location
)
12522 struct remote_state
*rs
= get_remote_state ();
12525 sprintf_vma (addr_buf
, location
->address
);
12526 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTEnable:%x:%s",
12527 location
->owner
->number
, addr_buf
);
12529 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12530 if (*rs
->buf
== '\0')
12531 error (_("Target does not support enabling tracepoints while a trace run is ongoing."));
12532 if (strcmp (rs
->buf
, "OK") != 0)
12533 error (_("Error on target while enabling tracepoint."));
12537 remote_disable_tracepoint (struct target_ops
*self
,
12538 struct bp_location
*location
)
12540 struct remote_state
*rs
= get_remote_state ();
12543 sprintf_vma (addr_buf
, location
->address
);
12544 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisable:%x:%s",
12545 location
->owner
->number
, addr_buf
);
12547 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
12548 if (*rs
->buf
== '\0')
12549 error (_("Target does not support disabling tracepoints while a trace run is ongoing."));
12550 if (strcmp (rs
->buf
, "OK") != 0)
12551 error (_("Error on target while disabling tracepoint."));
12555 remote_trace_set_readonly_regions (struct target_ops
*self
)
12559 bfd_size_type size
;
12565 return; /* No information to give. */
12567 strcpy (target_buf
, "QTro");
12568 offset
= strlen (target_buf
);
12569 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
12571 char tmp1
[40], tmp2
[40];
12574 if ((s
->flags
& SEC_LOAD
) == 0 ||
12575 /* (s->flags & SEC_CODE) == 0 || */
12576 (s
->flags
& SEC_READONLY
) == 0)
12580 vma
= bfd_get_section_vma (abfd
, s
);
12581 size
= bfd_get_section_size (s
);
12582 sprintf_vma (tmp1
, vma
);
12583 sprintf_vma (tmp2
, vma
+ size
);
12584 sec_length
= 1 + strlen (tmp1
) + 1 + strlen (tmp2
);
12585 if (offset
+ sec_length
+ 1 > target_buf_size
)
12587 if (packet_support (PACKET_qXfer_traceframe_info
) != PACKET_ENABLE
)
12589 Too many sections for read-only sections definition packet."));
12592 xsnprintf (target_buf
+ offset
, target_buf_size
- offset
, ":%s,%s",
12594 offset
+= sec_length
;
12598 putpkt (target_buf
);
12599 getpkt (&target_buf
, &target_buf_size
, 0);
12604 remote_trace_start (struct target_ops
*self
)
12606 putpkt ("QTStart");
12607 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12608 if (*target_buf
== '\0')
12609 error (_("Target does not support this command."));
12610 if (strcmp (target_buf
, "OK") != 0)
12611 error (_("Bogus reply from target: %s"), target_buf
);
12615 remote_get_trace_status (struct target_ops
*self
, struct trace_status
*ts
)
12617 /* Initialize it just to avoid a GCC false warning. */
12619 /* FIXME we need to get register block size some other way. */
12620 extern int trace_regblock_size
;
12621 enum packet_result result
;
12623 if (packet_support (PACKET_qTStatus
) == PACKET_DISABLE
)
12626 trace_regblock_size
= get_remote_arch_state ()->sizeof_g_packet
;
12628 putpkt ("qTStatus");
12632 p
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12634 CATCH (ex
, RETURN_MASK_ERROR
)
12636 if (ex
.error
!= TARGET_CLOSE_ERROR
)
12638 exception_fprintf (gdb_stderr
, ex
, "qTStatus: ");
12641 throw_exception (ex
);
12645 result
= packet_ok (p
, &remote_protocol_packets
[PACKET_qTStatus
]);
12647 /* If the remote target doesn't do tracing, flag it. */
12648 if (result
== PACKET_UNKNOWN
)
12651 /* We're working with a live target. */
12652 ts
->filename
= NULL
;
12655 error (_("Bogus trace status reply from target: %s"), target_buf
);
12657 /* Function 'parse_trace_status' sets default value of each field of
12658 'ts' at first, so we don't have to do it here. */
12659 parse_trace_status (p
, ts
);
12661 return ts
->running
;
12665 remote_get_tracepoint_status (struct target_ops
*self
, struct breakpoint
*bp
,
12666 struct uploaded_tp
*utp
)
12668 struct remote_state
*rs
= get_remote_state ();
12670 struct bp_location
*loc
;
12671 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
12672 size_t size
= get_remote_packet_size ();
12677 tp
->traceframe_usage
= 0;
12678 for (loc
= tp
->loc
; loc
; loc
= loc
->next
)
12680 /* If the tracepoint was never downloaded, don't go asking for
12682 if (tp
->number_on_target
== 0)
12684 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", tp
->number_on_target
,
12685 phex_nz (loc
->address
, 0));
12687 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12688 if (reply
&& *reply
)
12691 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12697 utp
->hit_count
= 0;
12698 utp
->traceframe_usage
= 0;
12699 xsnprintf (rs
->buf
, size
, "qTP:%x:%s", utp
->number
,
12700 phex_nz (utp
->addr
, 0));
12702 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12703 if (reply
&& *reply
)
12706 parse_tracepoint_status (reply
+ 1, bp
, utp
);
12712 remote_trace_stop (struct target_ops
*self
)
12715 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12716 if (*target_buf
== '\0')
12717 error (_("Target does not support this command."));
12718 if (strcmp (target_buf
, "OK") != 0)
12719 error (_("Bogus reply from target: %s"), target_buf
);
12723 remote_trace_find (struct target_ops
*self
,
12724 enum trace_find_type type
, int num
,
12725 CORE_ADDR addr1
, CORE_ADDR addr2
,
12728 struct remote_state
*rs
= get_remote_state ();
12729 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
12731 int target_frameno
= -1, target_tracept
= -1;
12733 /* Lookups other than by absolute frame number depend on the current
12734 trace selected, so make sure it is correct on the remote end
12736 if (type
!= tfind_number
)
12737 set_remote_traceframe ();
12740 strcpy (p
, "QTFrame:");
12741 p
= strchr (p
, '\0');
12745 xsnprintf (p
, endbuf
- p
, "%x", num
);
12748 xsnprintf (p
, endbuf
- p
, "pc:%s", phex_nz (addr1
, 0));
12751 xsnprintf (p
, endbuf
- p
, "tdp:%x", num
);
12754 xsnprintf (p
, endbuf
- p
, "range:%s:%s", phex_nz (addr1
, 0),
12755 phex_nz (addr2
, 0));
12757 case tfind_outside
:
12758 xsnprintf (p
, endbuf
- p
, "outside:%s:%s", phex_nz (addr1
, 0),
12759 phex_nz (addr2
, 0));
12762 error (_("Unknown trace find type %d"), type
);
12766 reply
= remote_get_noisy_reply (&(rs
->buf
), &rs
->buf_size
);
12767 if (*reply
== '\0')
12768 error (_("Target does not support this command."));
12770 while (reply
&& *reply
)
12775 target_frameno
= (int) strtol (p
, &reply
, 16);
12777 error (_("Unable to parse trace frame number"));
12778 /* Don't update our remote traceframe number cache on failure
12779 to select a remote traceframe. */
12780 if (target_frameno
== -1)
12785 target_tracept
= (int) strtol (p
, &reply
, 16);
12787 error (_("Unable to parse tracepoint number"));
12789 case 'O': /* "OK"? */
12790 if (reply
[1] == 'K' && reply
[2] == '\0')
12793 error (_("Bogus reply from target: %s"), reply
);
12796 error (_("Bogus reply from target: %s"), reply
);
12799 *tpp
= target_tracept
;
12801 rs
->remote_traceframe_number
= target_frameno
;
12802 return target_frameno
;
12806 remote_get_trace_state_variable_value (struct target_ops
*self
,
12807 int tsvnum
, LONGEST
*val
)
12809 struct remote_state
*rs
= get_remote_state ();
12813 set_remote_traceframe ();
12815 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTV:%x", tsvnum
);
12817 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12818 if (reply
&& *reply
)
12822 unpack_varlen_hex (reply
+ 1, &uval
);
12823 *val
= (LONGEST
) uval
;
12831 remote_save_trace_data (struct target_ops
*self
, const char *filename
)
12833 struct remote_state
*rs
= get_remote_state ();
12837 strcpy (p
, "QTSave:");
12839 if ((p
- rs
->buf
) + strlen (filename
) * 2 >= get_remote_packet_size ())
12840 error (_("Remote file name too long for trace save packet"));
12841 p
+= 2 * bin2hex ((gdb_byte
*) filename
, p
, strlen (filename
));
12844 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12845 if (*reply
== '\0')
12846 error (_("Target does not support this command."));
12847 if (strcmp (reply
, "OK") != 0)
12848 error (_("Bogus reply from target: %s"), reply
);
12852 /* This is basically a memory transfer, but needs to be its own packet
12853 because we don't know how the target actually organizes its trace
12854 memory, plus we want to be able to ask for as much as possible, but
12855 not be unhappy if we don't get as much as we ask for. */
12858 remote_get_raw_trace_data (struct target_ops
*self
,
12859 gdb_byte
*buf
, ULONGEST offset
, LONGEST len
)
12861 struct remote_state
*rs
= get_remote_state ();
12867 strcpy (p
, "qTBuffer:");
12869 p
+= hexnumstr (p
, offset
);
12871 p
+= hexnumstr (p
, len
);
12875 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12876 if (reply
&& *reply
)
12878 /* 'l' by itself means we're at the end of the buffer and
12879 there is nothing more to get. */
12883 /* Convert the reply into binary. Limit the number of bytes to
12884 convert according to our passed-in buffer size, rather than
12885 what was returned in the packet; if the target is
12886 unexpectedly generous and gives us a bigger reply than we
12887 asked for, we don't want to crash. */
12888 rslt
= hex2bin (target_buf
, buf
, len
);
12892 /* Something went wrong, flag as an error. */
12897 remote_set_disconnected_tracing (struct target_ops
*self
, int val
)
12899 struct remote_state
*rs
= get_remote_state ();
12901 if (packet_support (PACKET_DisconnectedTracing_feature
) == PACKET_ENABLE
)
12905 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTDisconnected:%x", val
);
12907 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12908 if (*reply
== '\0')
12909 error (_("Target does not support this command."));
12910 if (strcmp (reply
, "OK") != 0)
12911 error (_("Bogus reply from target: %s"), reply
);
12914 warning (_("Target does not support disconnected tracing."));
12918 remote_core_of_thread (struct target_ops
*ops
, ptid_t ptid
)
12920 struct thread_info
*info
= find_thread_ptid (ptid
);
12922 if (info
&& info
->priv
)
12923 return info
->priv
->core
;
12928 remote_set_circular_trace_buffer (struct target_ops
*self
, int val
)
12930 struct remote_state
*rs
= get_remote_state ();
12933 xsnprintf (rs
->buf
, get_remote_packet_size (), "QTBuffer:circular:%x", val
);
12935 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12936 if (*reply
== '\0')
12937 error (_("Target does not support this command."));
12938 if (strcmp (reply
, "OK") != 0)
12939 error (_("Bogus reply from target: %s"), reply
);
12942 static struct traceframe_info
*
12943 remote_traceframe_info (struct target_ops
*self
)
12947 text
= target_read_stralloc (¤t_target
,
12948 TARGET_OBJECT_TRACEFRAME_INFO
, NULL
);
12951 struct traceframe_info
*info
;
12952 struct cleanup
*back_to
= make_cleanup (xfree
, text
);
12954 info
= parse_traceframe_info (text
);
12955 do_cleanups (back_to
);
12962 /* Handle the qTMinFTPILen packet. Returns the minimum length of
12963 instruction on which a fast tracepoint may be placed. Returns -1
12964 if the packet is not supported, and 0 if the minimum instruction
12965 length is unknown. */
12968 remote_get_min_fast_tracepoint_insn_len (struct target_ops
*self
)
12970 struct remote_state
*rs
= get_remote_state ();
12973 /* If we're not debugging a process yet, the IPA can't be
12975 if (!target_has_execution
)
12978 /* Make sure the remote is pointing at the right process. */
12979 set_general_process ();
12981 xsnprintf (rs
->buf
, get_remote_packet_size (), "qTMinFTPILen");
12983 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
12984 if (*reply
== '\0')
12988 ULONGEST min_insn_len
;
12990 unpack_varlen_hex (reply
, &min_insn_len
);
12992 return (int) min_insn_len
;
12997 remote_set_trace_buffer_size (struct target_ops
*self
, LONGEST val
)
12999 if (packet_support (PACKET_QTBuffer_size
) != PACKET_DISABLE
)
13001 struct remote_state
*rs
= get_remote_state ();
13002 char *buf
= rs
->buf
;
13003 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13004 enum packet_result result
;
13006 gdb_assert (val
>= 0 || val
== -1);
13007 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTBuffer:size:");
13008 /* Send -1 as literal "-1" to avoid host size dependency. */
13012 buf
+= hexnumstr (buf
, (ULONGEST
) -val
);
13015 buf
+= hexnumstr (buf
, (ULONGEST
) val
);
13018 remote_get_noisy_reply (&rs
->buf
, &rs
->buf_size
);
13019 result
= packet_ok (rs
->buf
,
13020 &remote_protocol_packets
[PACKET_QTBuffer_size
]);
13022 if (result
!= PACKET_OK
)
13023 warning (_("Bogus reply from target: %s"), rs
->buf
);
13028 remote_set_trace_notes (struct target_ops
*self
,
13029 const char *user
, const char *notes
,
13030 const char *stop_notes
)
13032 struct remote_state
*rs
= get_remote_state ();
13034 char *buf
= rs
->buf
;
13035 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13038 buf
+= xsnprintf (buf
, endbuf
- buf
, "QTNotes:");
13041 buf
+= xsnprintf (buf
, endbuf
- buf
, "user:");
13042 nbytes
= bin2hex ((gdb_byte
*) user
, buf
, strlen (user
));
13048 buf
+= xsnprintf (buf
, endbuf
- buf
, "notes:");
13049 nbytes
= bin2hex ((gdb_byte
*) notes
, buf
, strlen (notes
));
13055 buf
+= xsnprintf (buf
, endbuf
- buf
, "tstop:");
13056 nbytes
= bin2hex ((gdb_byte
*) stop_notes
, buf
, strlen (stop_notes
));
13060 /* Ensure the buffer is terminated. */
13064 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
13065 if (*reply
== '\0')
13068 if (strcmp (reply
, "OK") != 0)
13069 error (_("Bogus reply from target: %s"), reply
);
13075 remote_use_agent (struct target_ops
*self
, int use
)
13077 if (packet_support (PACKET_QAgent
) != PACKET_DISABLE
)
13079 struct remote_state
*rs
= get_remote_state ();
13081 /* If the stub supports QAgent. */
13082 xsnprintf (rs
->buf
, get_remote_packet_size (), "QAgent:%d", use
);
13084 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13086 if (strcmp (rs
->buf
, "OK") == 0)
13097 remote_can_use_agent (struct target_ops
*self
)
13099 return (packet_support (PACKET_QAgent
) != PACKET_DISABLE
);
13102 struct btrace_target_info
13104 /* The ptid of the traced thread. */
13107 /* The obtained branch trace configuration. */
13108 struct btrace_config conf
;
13111 /* Reset our idea of our target's btrace configuration. */
13114 remote_btrace_reset (void)
13116 struct remote_state
*rs
= get_remote_state ();
13118 memset (&rs
->btrace_config
, 0, sizeof (rs
->btrace_config
));
13121 /* Check whether the target supports branch tracing. */
13124 remote_supports_btrace (struct target_ops
*self
, enum btrace_format format
)
13126 if (packet_support (PACKET_Qbtrace_off
) != PACKET_ENABLE
)
13128 if (packet_support (PACKET_qXfer_btrace
) != PACKET_ENABLE
)
13133 case BTRACE_FORMAT_NONE
:
13136 case BTRACE_FORMAT_BTS
:
13137 return (packet_support (PACKET_Qbtrace_bts
) == PACKET_ENABLE
);
13139 case BTRACE_FORMAT_PT
:
13140 /* The trace is decoded on the host. Even if our target supports it,
13141 we still need to have libipt to decode the trace. */
13142 #if defined (HAVE_LIBIPT)
13143 return (packet_support (PACKET_Qbtrace_pt
) == PACKET_ENABLE
);
13144 #else /* !defined (HAVE_LIBIPT) */
13146 #endif /* !defined (HAVE_LIBIPT) */
13149 internal_error (__FILE__
, __LINE__
, _("Unknown branch trace format"));
13152 /* Synchronize the configuration with the target. */
13155 btrace_sync_conf (const struct btrace_config
*conf
)
13157 struct packet_config
*packet
;
13158 struct remote_state
*rs
;
13159 char *buf
, *pos
, *endbuf
;
13161 rs
= get_remote_state ();
13163 endbuf
= buf
+ get_remote_packet_size ();
13165 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
];
13166 if (packet_config_support (packet
) == PACKET_ENABLE
13167 && conf
->bts
.size
!= rs
->btrace_config
.bts
.size
)
13170 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13174 getpkt (&buf
, &rs
->buf_size
, 0);
13176 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13178 if (buf
[0] == 'E' && buf
[1] == '.')
13179 error (_("Failed to configure the BTS buffer size: %s"), buf
+ 2);
13181 error (_("Failed to configure the BTS buffer size."));
13184 rs
->btrace_config
.bts
.size
= conf
->bts
.size
;
13187 packet
= &remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
];
13188 if (packet_config_support (packet
) == PACKET_ENABLE
13189 && conf
->pt
.size
!= rs
->btrace_config
.pt
.size
)
13192 pos
+= xsnprintf (pos
, endbuf
- pos
, "%s=0x%x", packet
->name
,
13196 getpkt (&buf
, &rs
->buf_size
, 0);
13198 if (packet_ok (buf
, packet
) == PACKET_ERROR
)
13200 if (buf
[0] == 'E' && buf
[1] == '.')
13201 error (_("Failed to configure the trace buffer size: %s"), buf
+ 2);
13203 error (_("Failed to configure the trace buffer size."));
13206 rs
->btrace_config
.pt
.size
= conf
->pt
.size
;
13210 /* Read the current thread's btrace configuration from the target and
13211 store it into CONF. */
13214 btrace_read_config (struct btrace_config
*conf
)
13218 xml
= target_read_stralloc (¤t_target
,
13219 TARGET_OBJECT_BTRACE_CONF
, "");
13222 struct cleanup
*cleanup
;
13224 cleanup
= make_cleanup (xfree
, xml
);
13225 parse_xml_btrace_conf (conf
, xml
);
13226 do_cleanups (cleanup
);
13230 /* Maybe reopen target btrace. */
13233 remote_btrace_maybe_reopen (void)
13235 struct remote_state
*rs
= get_remote_state ();
13236 struct thread_info
*tp
;
13237 int btrace_target_pushed
= 0;
13240 scoped_restore_current_thread restore_thread
;
13242 ALL_NON_EXITED_THREADS (tp
)
13244 set_general_thread (tp
->ptid
);
13246 memset (&rs
->btrace_config
, 0x00, sizeof (struct btrace_config
));
13247 btrace_read_config (&rs
->btrace_config
);
13249 if (rs
->btrace_config
.format
== BTRACE_FORMAT_NONE
)
13252 #if !defined (HAVE_LIBIPT)
13253 if (rs
->btrace_config
.format
== BTRACE_FORMAT_PT
)
13258 warning (_("GDB does not support Intel Processor Trace. "
13259 "\"record\" will not work in this session."));
13264 #endif /* !defined (HAVE_LIBIPT) */
13266 /* Push target, once, but before anything else happens. This way our
13267 changes to the threads will be cleaned up by unpushing the target
13268 in case btrace_read_config () throws. */
13269 if (!btrace_target_pushed
)
13271 btrace_target_pushed
= 1;
13272 record_btrace_push_target ();
13273 printf_filtered (_("Target is recording using %s.\n"),
13274 btrace_format_string (rs
->btrace_config
.format
));
13277 tp
->btrace
.target
= XCNEW (struct btrace_target_info
);
13278 tp
->btrace
.target
->ptid
= tp
->ptid
;
13279 tp
->btrace
.target
->conf
= rs
->btrace_config
;
13283 /* Enable branch tracing. */
13285 static struct btrace_target_info
*
13286 remote_enable_btrace (struct target_ops
*self
, ptid_t ptid
,
13287 const struct btrace_config
*conf
)
13289 struct btrace_target_info
*tinfo
= NULL
;
13290 struct packet_config
*packet
= NULL
;
13291 struct remote_state
*rs
= get_remote_state ();
13292 char *buf
= rs
->buf
;
13293 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13295 switch (conf
->format
)
13297 case BTRACE_FORMAT_BTS
:
13298 packet
= &remote_protocol_packets
[PACKET_Qbtrace_bts
];
13301 case BTRACE_FORMAT_PT
:
13302 packet
= &remote_protocol_packets
[PACKET_Qbtrace_pt
];
13306 if (packet
== NULL
|| packet_config_support (packet
) != PACKET_ENABLE
)
13307 error (_("Target does not support branch tracing."));
13309 btrace_sync_conf (conf
);
13311 set_general_thread (ptid
);
13313 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13315 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13317 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13319 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13320 error (_("Could not enable branch tracing for %s: %s"),
13321 target_pid_to_str (ptid
), rs
->buf
+ 2);
13323 error (_("Could not enable branch tracing for %s."),
13324 target_pid_to_str (ptid
));
13327 tinfo
= XCNEW (struct btrace_target_info
);
13328 tinfo
->ptid
= ptid
;
13330 /* If we fail to read the configuration, we lose some information, but the
13331 tracing itself is not impacted. */
13334 btrace_read_config (&tinfo
->conf
);
13336 CATCH (err
, RETURN_MASK_ERROR
)
13338 if (err
.message
!= NULL
)
13339 warning ("%s", err
.message
);
13346 /* Disable branch tracing. */
13349 remote_disable_btrace (struct target_ops
*self
,
13350 struct btrace_target_info
*tinfo
)
13352 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_Qbtrace_off
];
13353 struct remote_state
*rs
= get_remote_state ();
13354 char *buf
= rs
->buf
;
13355 char *endbuf
= rs
->buf
+ get_remote_packet_size ();
13357 if (packet_config_support (packet
) != PACKET_ENABLE
)
13358 error (_("Target does not support branch tracing."));
13360 set_general_thread (tinfo
->ptid
);
13362 buf
+= xsnprintf (buf
, endbuf
- buf
, "%s", packet
->name
);
13364 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13366 if (packet_ok (rs
->buf
, packet
) == PACKET_ERROR
)
13368 if (rs
->buf
[0] == 'E' && rs
->buf
[1] == '.')
13369 error (_("Could not disable branch tracing for %s: %s"),
13370 target_pid_to_str (tinfo
->ptid
), rs
->buf
+ 2);
13372 error (_("Could not disable branch tracing for %s."),
13373 target_pid_to_str (tinfo
->ptid
));
13379 /* Teardown branch tracing. */
13382 remote_teardown_btrace (struct target_ops
*self
,
13383 struct btrace_target_info
*tinfo
)
13385 /* We must not talk to the target during teardown. */
13389 /* Read the branch trace. */
13391 static enum btrace_error
13392 remote_read_btrace (struct target_ops
*self
,
13393 struct btrace_data
*btrace
,
13394 struct btrace_target_info
*tinfo
,
13395 enum btrace_read_type type
)
13397 struct packet_config
*packet
= &remote_protocol_packets
[PACKET_qXfer_btrace
];
13398 struct cleanup
*cleanup
;
13402 if (packet_config_support (packet
) != PACKET_ENABLE
)
13403 error (_("Target does not support branch tracing."));
13405 #if !defined(HAVE_LIBEXPAT)
13406 error (_("Cannot process branch tracing result. XML parsing not supported."));
13411 case BTRACE_READ_ALL
:
13414 case BTRACE_READ_NEW
:
13417 case BTRACE_READ_DELTA
:
13421 internal_error (__FILE__
, __LINE__
,
13422 _("Bad branch tracing read type: %u."),
13423 (unsigned int) type
);
13426 xml
= target_read_stralloc (¤t_target
,
13427 TARGET_OBJECT_BTRACE
, annex
);
13429 return BTRACE_ERR_UNKNOWN
;
13431 cleanup
= make_cleanup (xfree
, xml
);
13432 parse_xml_btrace (btrace
, xml
);
13433 do_cleanups (cleanup
);
13435 return BTRACE_ERR_NONE
;
13438 static const struct btrace_config
*
13439 remote_btrace_conf (struct target_ops
*self
,
13440 const struct btrace_target_info
*tinfo
)
13442 return &tinfo
->conf
;
13446 remote_augmented_libraries_svr4_read (struct target_ops
*self
)
13448 return (packet_support (PACKET_augmented_libraries_svr4_read_feature
)
13452 /* Implementation of to_load. */
13455 remote_load (struct target_ops
*self
, const char *name
, int from_tty
)
13457 generic_load (name
, from_tty
);
13460 /* Accepts an integer PID; returns a string representing a file that
13461 can be opened on the remote side to get the symbols for the child
13462 process. Returns NULL if the operation is not supported. */
13465 remote_pid_to_exec_file (struct target_ops
*self
, int pid
)
13467 static char *filename
= NULL
;
13468 struct inferior
*inf
;
13469 char *annex
= NULL
;
13471 if (packet_support (PACKET_qXfer_exec_file
) != PACKET_ENABLE
)
13474 if (filename
!= NULL
)
13477 inf
= find_inferior_pid (pid
);
13479 internal_error (__FILE__
, __LINE__
,
13480 _("not currently attached to process %d"), pid
);
13482 if (!inf
->fake_pid_p
)
13484 const int annex_size
= 9;
13486 annex
= (char *) alloca (annex_size
);
13487 xsnprintf (annex
, annex_size
, "%x", pid
);
13490 filename
= target_read_stralloc (¤t_target
,
13491 TARGET_OBJECT_EXEC_FILE
, annex
);
13496 /* Implement the to_can_do_single_step target_ops method. */
13499 remote_can_do_single_step (struct target_ops
*ops
)
13501 /* We can only tell whether target supports single step or not by
13502 supported s and S vCont actions if the stub supports vContSupported
13503 feature. If the stub doesn't support vContSupported feature,
13504 we have conservatively to think target doesn't supports single
13506 if (packet_support (PACKET_vContSupported
) == PACKET_ENABLE
)
13508 struct remote_state
*rs
= get_remote_state ();
13510 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13511 remote_vcont_probe (rs
);
13513 return rs
->supports_vCont
.s
&& rs
->supports_vCont
.S
;
13519 /* Implementation of the to_execution_direction method for the remote
13522 static enum exec_direction_kind
13523 remote_execution_direction (struct target_ops
*self
)
13525 struct remote_state
*rs
= get_remote_state ();
13527 return rs
->last_resume_exec_dir
;
13531 init_remote_ops (void)
13533 remote_ops
.to_shortname
= "remote";
13534 remote_ops
.to_longname
= "Remote serial target in gdb-specific protocol";
13535 remote_ops
.to_doc
=
13536 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13537 Specify the serial device it is connected to\n\
13538 (e.g. /dev/ttyS0, /dev/ttya, COM1, etc.).";
13539 remote_ops
.to_open
= remote_open
;
13540 remote_ops
.to_close
= remote_close
;
13541 remote_ops
.to_detach
= remote_detach
;
13542 remote_ops
.to_disconnect
= remote_disconnect
;
13543 remote_ops
.to_resume
= remote_resume
;
13544 remote_ops
.to_commit_resume
= remote_commit_resume
;
13545 remote_ops
.to_wait
= remote_wait
;
13546 remote_ops
.to_fetch_registers
= remote_fetch_registers
;
13547 remote_ops
.to_store_registers
= remote_store_registers
;
13548 remote_ops
.to_prepare_to_store
= remote_prepare_to_store
;
13549 remote_ops
.to_files_info
= remote_files_info
;
13550 remote_ops
.to_insert_breakpoint
= remote_insert_breakpoint
;
13551 remote_ops
.to_remove_breakpoint
= remote_remove_breakpoint
;
13552 remote_ops
.to_stopped_by_sw_breakpoint
= remote_stopped_by_sw_breakpoint
;
13553 remote_ops
.to_supports_stopped_by_sw_breakpoint
= remote_supports_stopped_by_sw_breakpoint
;
13554 remote_ops
.to_stopped_by_hw_breakpoint
= remote_stopped_by_hw_breakpoint
;
13555 remote_ops
.to_supports_stopped_by_hw_breakpoint
= remote_supports_stopped_by_hw_breakpoint
;
13556 remote_ops
.to_stopped_by_watchpoint
= remote_stopped_by_watchpoint
;
13557 remote_ops
.to_stopped_data_address
= remote_stopped_data_address
;
13558 remote_ops
.to_watchpoint_addr_within_range
=
13559 remote_watchpoint_addr_within_range
;
13560 remote_ops
.to_can_use_hw_breakpoint
= remote_check_watch_resources
;
13561 remote_ops
.to_insert_hw_breakpoint
= remote_insert_hw_breakpoint
;
13562 remote_ops
.to_remove_hw_breakpoint
= remote_remove_hw_breakpoint
;
13563 remote_ops
.to_region_ok_for_hw_watchpoint
13564 = remote_region_ok_for_hw_watchpoint
;
13565 remote_ops
.to_insert_watchpoint
= remote_insert_watchpoint
;
13566 remote_ops
.to_remove_watchpoint
= remote_remove_watchpoint
;
13567 remote_ops
.to_kill
= remote_kill
;
13568 remote_ops
.to_load
= remote_load
;
13569 remote_ops
.to_mourn_inferior
= remote_mourn
;
13570 remote_ops
.to_pass_signals
= remote_pass_signals
;
13571 remote_ops
.to_set_syscall_catchpoint
= remote_set_syscall_catchpoint
;
13572 remote_ops
.to_program_signals
= remote_program_signals
;
13573 remote_ops
.to_thread_alive
= remote_thread_alive
;
13574 remote_ops
.to_thread_name
= remote_thread_name
;
13575 remote_ops
.to_update_thread_list
= remote_update_thread_list
;
13576 remote_ops
.to_pid_to_str
= remote_pid_to_str
;
13577 remote_ops
.to_extra_thread_info
= remote_threads_extra_info
;
13578 remote_ops
.to_get_ada_task_ptid
= remote_get_ada_task_ptid
;
13579 remote_ops
.to_stop
= remote_stop
;
13580 remote_ops
.to_interrupt
= remote_interrupt
;
13581 remote_ops
.to_pass_ctrlc
= remote_pass_ctrlc
;
13582 remote_ops
.to_xfer_partial
= remote_xfer_partial
;
13583 remote_ops
.to_get_memory_xfer_limit
= remote_get_memory_xfer_limit
;
13584 remote_ops
.to_rcmd
= remote_rcmd
;
13585 remote_ops
.to_pid_to_exec_file
= remote_pid_to_exec_file
;
13586 remote_ops
.to_log_command
= serial_log_command
;
13587 remote_ops
.to_get_thread_local_address
= remote_get_thread_local_address
;
13588 remote_ops
.to_stratum
= process_stratum
;
13589 remote_ops
.to_has_all_memory
= default_child_has_all_memory
;
13590 remote_ops
.to_has_memory
= default_child_has_memory
;
13591 remote_ops
.to_has_stack
= default_child_has_stack
;
13592 remote_ops
.to_has_registers
= default_child_has_registers
;
13593 remote_ops
.to_has_execution
= default_child_has_execution
;
13594 remote_ops
.to_has_thread_control
= tc_schedlock
; /* can lock scheduler */
13595 remote_ops
.to_can_execute_reverse
= remote_can_execute_reverse
;
13596 remote_ops
.to_magic
= OPS_MAGIC
;
13597 remote_ops
.to_memory_map
= remote_memory_map
;
13598 remote_ops
.to_flash_erase
= remote_flash_erase
;
13599 remote_ops
.to_flash_done
= remote_flash_done
;
13600 remote_ops
.to_read_description
= remote_read_description
;
13601 remote_ops
.to_search_memory
= remote_search_memory
;
13602 remote_ops
.to_can_async_p
= remote_can_async_p
;
13603 remote_ops
.to_is_async_p
= remote_is_async_p
;
13604 remote_ops
.to_async
= remote_async
;
13605 remote_ops
.to_thread_events
= remote_thread_events
;
13606 remote_ops
.to_can_do_single_step
= remote_can_do_single_step
;
13607 remote_ops
.to_terminal_inferior
= remote_terminal_inferior
;
13608 remote_ops
.to_terminal_ours
= remote_terminal_ours
;
13609 remote_ops
.to_supports_non_stop
= remote_supports_non_stop
;
13610 remote_ops
.to_supports_multi_process
= remote_supports_multi_process
;
13611 remote_ops
.to_supports_disable_randomization
13612 = remote_supports_disable_randomization
;
13613 remote_ops
.to_filesystem_is_local
= remote_filesystem_is_local
;
13614 remote_ops
.to_fileio_open
= remote_hostio_open
;
13615 remote_ops
.to_fileio_pwrite
= remote_hostio_pwrite
;
13616 remote_ops
.to_fileio_pread
= remote_hostio_pread
;
13617 remote_ops
.to_fileio_fstat
= remote_hostio_fstat
;
13618 remote_ops
.to_fileio_close
= remote_hostio_close
;
13619 remote_ops
.to_fileio_unlink
= remote_hostio_unlink
;
13620 remote_ops
.to_fileio_readlink
= remote_hostio_readlink
;
13621 remote_ops
.to_supports_enable_disable_tracepoint
= remote_supports_enable_disable_tracepoint
;
13622 remote_ops
.to_supports_string_tracing
= remote_supports_string_tracing
;
13623 remote_ops
.to_supports_evaluation_of_breakpoint_conditions
= remote_supports_cond_breakpoints
;
13624 remote_ops
.to_can_run_breakpoint_commands
= remote_can_run_breakpoint_commands
;
13625 remote_ops
.to_trace_init
= remote_trace_init
;
13626 remote_ops
.to_download_tracepoint
= remote_download_tracepoint
;
13627 remote_ops
.to_can_download_tracepoint
= remote_can_download_tracepoint
;
13628 remote_ops
.to_download_trace_state_variable
13629 = remote_download_trace_state_variable
;
13630 remote_ops
.to_enable_tracepoint
= remote_enable_tracepoint
;
13631 remote_ops
.to_disable_tracepoint
= remote_disable_tracepoint
;
13632 remote_ops
.to_trace_set_readonly_regions
= remote_trace_set_readonly_regions
;
13633 remote_ops
.to_trace_start
= remote_trace_start
;
13634 remote_ops
.to_get_trace_status
= remote_get_trace_status
;
13635 remote_ops
.to_get_tracepoint_status
= remote_get_tracepoint_status
;
13636 remote_ops
.to_trace_stop
= remote_trace_stop
;
13637 remote_ops
.to_trace_find
= remote_trace_find
;
13638 remote_ops
.to_get_trace_state_variable_value
13639 = remote_get_trace_state_variable_value
;
13640 remote_ops
.to_save_trace_data
= remote_save_trace_data
;
13641 remote_ops
.to_upload_tracepoints
= remote_upload_tracepoints
;
13642 remote_ops
.to_upload_trace_state_variables
13643 = remote_upload_trace_state_variables
;
13644 remote_ops
.to_get_raw_trace_data
= remote_get_raw_trace_data
;
13645 remote_ops
.to_get_min_fast_tracepoint_insn_len
= remote_get_min_fast_tracepoint_insn_len
;
13646 remote_ops
.to_set_disconnected_tracing
= remote_set_disconnected_tracing
;
13647 remote_ops
.to_set_circular_trace_buffer
= remote_set_circular_trace_buffer
;
13648 remote_ops
.to_set_trace_buffer_size
= remote_set_trace_buffer_size
;
13649 remote_ops
.to_set_trace_notes
= remote_set_trace_notes
;
13650 remote_ops
.to_core_of_thread
= remote_core_of_thread
;
13651 remote_ops
.to_verify_memory
= remote_verify_memory
;
13652 remote_ops
.to_get_tib_address
= remote_get_tib_address
;
13653 remote_ops
.to_set_permissions
= remote_set_permissions
;
13654 remote_ops
.to_static_tracepoint_marker_at
13655 = remote_static_tracepoint_marker_at
;
13656 remote_ops
.to_static_tracepoint_markers_by_strid
13657 = remote_static_tracepoint_markers_by_strid
;
13658 remote_ops
.to_traceframe_info
= remote_traceframe_info
;
13659 remote_ops
.to_use_agent
= remote_use_agent
;
13660 remote_ops
.to_can_use_agent
= remote_can_use_agent
;
13661 remote_ops
.to_supports_btrace
= remote_supports_btrace
;
13662 remote_ops
.to_enable_btrace
= remote_enable_btrace
;
13663 remote_ops
.to_disable_btrace
= remote_disable_btrace
;
13664 remote_ops
.to_teardown_btrace
= remote_teardown_btrace
;
13665 remote_ops
.to_read_btrace
= remote_read_btrace
;
13666 remote_ops
.to_btrace_conf
= remote_btrace_conf
;
13667 remote_ops
.to_augmented_libraries_svr4_read
=
13668 remote_augmented_libraries_svr4_read
;
13669 remote_ops
.to_follow_fork
= remote_follow_fork
;
13670 remote_ops
.to_follow_exec
= remote_follow_exec
;
13671 remote_ops
.to_insert_fork_catchpoint
= remote_insert_fork_catchpoint
;
13672 remote_ops
.to_remove_fork_catchpoint
= remote_remove_fork_catchpoint
;
13673 remote_ops
.to_insert_vfork_catchpoint
= remote_insert_vfork_catchpoint
;
13674 remote_ops
.to_remove_vfork_catchpoint
= remote_remove_vfork_catchpoint
;
13675 remote_ops
.to_insert_exec_catchpoint
= remote_insert_exec_catchpoint
;
13676 remote_ops
.to_remove_exec_catchpoint
= remote_remove_exec_catchpoint
;
13677 remote_ops
.to_execution_direction
= remote_execution_direction
;
13680 /* Set up the extended remote vector by making a copy of the standard
13681 remote vector and adding to it. */
13684 init_extended_remote_ops (void)
13686 extended_remote_ops
= remote_ops
;
13688 extended_remote_ops
.to_shortname
= "extended-remote";
13689 extended_remote_ops
.to_longname
=
13690 "Extended remote serial target in gdb-specific protocol";
13691 extended_remote_ops
.to_doc
=
13692 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
13693 Specify the serial device it is connected to (e.g. /dev/ttya).";
13694 extended_remote_ops
.to_open
= extended_remote_open
;
13695 extended_remote_ops
.to_create_inferior
= extended_remote_create_inferior
;
13696 extended_remote_ops
.to_detach
= extended_remote_detach
;
13697 extended_remote_ops
.to_attach
= extended_remote_attach
;
13698 extended_remote_ops
.to_post_attach
= extended_remote_post_attach
;
13699 extended_remote_ops
.to_supports_disable_randomization
13700 = extended_remote_supports_disable_randomization
;
13704 remote_can_async_p (struct target_ops
*ops
)
13706 struct remote_state
*rs
= get_remote_state ();
13708 /* We don't go async if the user has explicitly prevented it with the
13709 "maint set target-async" command. */
13710 if (!target_async_permitted
)
13713 /* We're async whenever the serial device is. */
13714 return serial_can_async_p (rs
->remote_desc
);
13718 remote_is_async_p (struct target_ops
*ops
)
13720 struct remote_state
*rs
= get_remote_state ();
13722 if (!target_async_permitted
)
13723 /* We only enable async when the user specifically asks for it. */
13726 /* We're async whenever the serial device is. */
13727 return serial_is_async_p (rs
->remote_desc
);
13730 /* Pass the SERIAL event on and up to the client. One day this code
13731 will be able to delay notifying the client of an event until the
13732 point where an entire packet has been received. */
13734 static serial_event_ftype remote_async_serial_handler
;
13737 remote_async_serial_handler (struct serial
*scb
, void *context
)
13739 /* Don't propogate error information up to the client. Instead let
13740 the client find out about the error by querying the target. */
13741 inferior_event_handler (INF_REG_EVENT
, NULL
);
13745 remote_async_inferior_event_handler (gdb_client_data data
)
13747 inferior_event_handler (INF_REG_EVENT
, NULL
);
13751 remote_async (struct target_ops
*ops
, int enable
)
13753 struct remote_state
*rs
= get_remote_state ();
13757 serial_async (rs
->remote_desc
, remote_async_serial_handler
, rs
);
13759 /* If there are pending events in the stop reply queue tell the
13760 event loop to process them. */
13761 if (!QUEUE_is_empty (stop_reply_p
, stop_reply_queue
))
13762 mark_async_event_handler (remote_async_inferior_event_token
);
13763 /* For simplicity, below we clear the pending events token
13764 without remembering whether it is marked, so here we always
13765 mark it. If there's actually no pending notification to
13766 process, this ends up being a no-op (other than a spurious
13767 event-loop wakeup). */
13768 if (target_is_non_stop_p ())
13769 mark_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13773 serial_async (rs
->remote_desc
, NULL
, NULL
);
13774 /* If the core is disabling async, it doesn't want to be
13775 disturbed with target events. Clear all async event sources
13777 clear_async_event_handler (remote_async_inferior_event_token
);
13778 if (target_is_non_stop_p ())
13779 clear_async_event_handler (rs
->notif_state
->get_pending_events_token
);
13783 /* Implementation of the to_thread_events method. */
13786 remote_thread_events (struct target_ops
*ops
, int enable
)
13788 struct remote_state
*rs
= get_remote_state ();
13789 size_t size
= get_remote_packet_size ();
13791 if (packet_support (PACKET_QThreadEvents
) == PACKET_DISABLE
)
13794 xsnprintf (rs
->buf
, size
, "QThreadEvents:%x", enable
? 1 : 0);
13796 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13798 switch (packet_ok (rs
->buf
,
13799 &remote_protocol_packets
[PACKET_QThreadEvents
]))
13802 if (strcmp (rs
->buf
, "OK") != 0)
13803 error (_("Remote refused setting thread events: %s"), rs
->buf
);
13806 warning (_("Remote failure reply: %s"), rs
->buf
);
13808 case PACKET_UNKNOWN
:
13814 set_remote_cmd (char *args
, int from_tty
)
13816 help_list (remote_set_cmdlist
, "set remote ", all_commands
, gdb_stdout
);
13820 show_remote_cmd (char *args
, int from_tty
)
13822 /* We can't just use cmd_show_list here, because we want to skip
13823 the redundant "show remote Z-packet" and the legacy aliases. */
13824 struct cmd_list_element
*list
= remote_show_cmdlist
;
13825 struct ui_out
*uiout
= current_uiout
;
13827 ui_out_emit_tuple
tuple_emitter (uiout
, "showlist");
13828 for (; list
!= NULL
; list
= list
->next
)
13829 if (strcmp (list
->name
, "Z-packet") == 0)
13831 else if (list
->type
== not_set_cmd
)
13832 /* Alias commands are exactly like the original, except they
13833 don't have the normal type. */
13837 ui_out_emit_tuple
option_emitter (uiout
, "option");
13839 uiout
->field_string ("name", list
->name
);
13840 uiout
->text (": ");
13841 if (list
->type
== show_cmd
)
13842 do_show_command (NULL
, from_tty
, list
);
13844 cmd_func (list
, NULL
, from_tty
);
13849 /* Function to be called whenever a new objfile (shlib) is detected. */
13851 remote_new_objfile (struct objfile
*objfile
)
13853 struct remote_state
*rs
= get_remote_state ();
13855 if (rs
->remote_desc
!= 0) /* Have a remote connection. */
13856 remote_check_symbols ();
13859 /* Pull all the tracepoints defined on the target and create local
13860 data structures representing them. We don't want to create real
13861 tracepoints yet, we don't want to mess up the user's existing
13865 remote_upload_tracepoints (struct target_ops
*self
, struct uploaded_tp
**utpp
)
13867 struct remote_state
*rs
= get_remote_state ();
13870 /* Ask for a first packet of tracepoint definition. */
13872 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13874 while (*p
&& *p
!= 'l')
13876 parse_tracepoint_definition (p
, utpp
);
13877 /* Ask for another packet of tracepoint definition. */
13879 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13886 remote_upload_trace_state_variables (struct target_ops
*self
,
13887 struct uploaded_tsv
**utsvp
)
13889 struct remote_state
*rs
= get_remote_state ();
13892 /* Ask for a first packet of variable definition. */
13894 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13896 while (*p
&& *p
!= 'l')
13898 parse_tsv_definition (p
, utsvp
);
13899 /* Ask for another packet of variable definition. */
13901 getpkt (&rs
->buf
, &rs
->buf_size
, 0);
13907 /* The "set/show range-stepping" show hook. */
13910 show_range_stepping (struct ui_file
*file
, int from_tty
,
13911 struct cmd_list_element
*c
,
13914 fprintf_filtered (file
,
13915 _("Debugger's willingness to use range stepping "
13916 "is %s.\n"), value
);
13919 /* The "set/show range-stepping" set hook. */
13922 set_range_stepping (char *ignore_args
, int from_tty
,
13923 struct cmd_list_element
*c
)
13925 struct remote_state
*rs
= get_remote_state ();
13927 /* Whene enabling, check whether range stepping is actually
13928 supported by the target, and warn if not. */
13929 if (use_range_stepping
)
13931 if (rs
->remote_desc
!= NULL
)
13933 if (packet_support (PACKET_vCont
) == PACKET_SUPPORT_UNKNOWN
)
13934 remote_vcont_probe (rs
);
13936 if (packet_support (PACKET_vCont
) == PACKET_ENABLE
13937 && rs
->supports_vCont
.r
)
13941 warning (_("Range stepping is not supported by the current target"));
13946 _initialize_remote (void)
13948 struct cmd_list_element
*cmd
;
13949 const char *cmd_name
;
13951 /* architecture specific data */
13952 remote_gdbarch_data_handle
=
13953 gdbarch_data_register_post_init (init_remote_state
);
13954 remote_g_packet_data_handle
=
13955 gdbarch_data_register_pre_init (remote_g_packet_data_init
);
13958 = register_program_space_data_with_cleanup (NULL
,
13959 remote_pspace_data_cleanup
);
13961 /* Initialize the per-target state. At the moment there is only one
13962 of these, not one per target. Only one target is active at a
13964 remote_state
= new_remote_state ();
13966 init_remote_ops ();
13967 add_target (&remote_ops
);
13969 init_extended_remote_ops ();
13970 add_target (&extended_remote_ops
);
13972 /* Hook into new objfile notification. */
13973 observer_attach_new_objfile (remote_new_objfile
);
13974 /* We're no longer interested in notification events of an inferior
13976 observer_attach_inferior_exit (discard_pending_stop_replies
);
13979 init_remote_threadtests ();
13982 stop_reply_queue
= QUEUE_alloc (stop_reply_p
, stop_reply_xfree
);
13983 /* set/show remote ... */
13985 add_prefix_cmd ("remote", class_maintenance
, set_remote_cmd
, _("\
13986 Remote protocol specific variables\n\
13987 Configure various remote-protocol specific variables such as\n\
13988 the packets being used"),
13989 &remote_set_cmdlist
, "set remote ",
13990 0 /* allow-unknown */, &setlist
);
13991 add_prefix_cmd ("remote", class_maintenance
, show_remote_cmd
, _("\
13992 Remote protocol specific variables\n\
13993 Configure various remote-protocol specific variables such as\n\
13994 the packets being used"),
13995 &remote_show_cmdlist
, "show remote ",
13996 0 /* allow-unknown */, &showlist
);
13998 add_cmd ("compare-sections", class_obscure
, compare_sections_command
, _("\
13999 Compare section data on target to the exec file.\n\
14000 Argument is a single section name (default: all loaded sections).\n\
14001 To compare only read-only loaded sections, specify the -r option."),
14004 add_cmd ("packet", class_maintenance
, packet_command
, _("\
14005 Send an arbitrary packet to a remote target.\n\
14006 maintenance packet TEXT\n\
14007 If GDB is talking to an inferior via the GDB serial protocol, then\n\
14008 this command sends the string TEXT to the inferior, and displays the\n\
14009 response packet. GDB supplies the initial `$' character, and the\n\
14010 terminating `#' character and checksum."),
14013 add_setshow_boolean_cmd ("remotebreak", no_class
, &remote_break
, _("\
14014 Set whether to send break if interrupted."), _("\
14015 Show whether to send break if interrupted."), _("\
14016 If set, a break, instead of a cntrl-c, is sent to the remote target."),
14017 set_remotebreak
, show_remotebreak
,
14018 &setlist
, &showlist
);
14019 cmd_name
= "remotebreak";
14020 cmd
= lookup_cmd (&cmd_name
, setlist
, "", -1, 1);
14021 deprecate_cmd (cmd
, "set remote interrupt-sequence");
14022 cmd_name
= "remotebreak"; /* needed because lookup_cmd updates the pointer */
14023 cmd
= lookup_cmd (&cmd_name
, showlist
, "", -1, 1);
14024 deprecate_cmd (cmd
, "show remote interrupt-sequence");
14026 add_setshow_enum_cmd ("interrupt-sequence", class_support
,
14027 interrupt_sequence_modes
, &interrupt_sequence_mode
,
14029 Set interrupt sequence to remote target."), _("\
14030 Show interrupt sequence to remote target."), _("\
14031 Valid value is \"Ctrl-C\", \"BREAK\" or \"BREAK-g\". The default is \"Ctrl-C\"."),
14032 NULL
, show_interrupt_sequence
,
14033 &remote_set_cmdlist
,
14034 &remote_show_cmdlist
);
14036 add_setshow_boolean_cmd ("interrupt-on-connect", class_support
,
14037 &interrupt_on_connect
, _("\
14038 Set whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14039 Show whether interrupt-sequence is sent to remote target when gdb connects to."), _(" \
14040 If set, interrupt sequence is sent to remote target."),
14042 &remote_set_cmdlist
, &remote_show_cmdlist
);
14044 /* Install commands for configuring memory read/write packets. */
14046 add_cmd ("remotewritesize", no_class
, set_memory_write_packet_size
, _("\
14047 Set the maximum number of bytes per memory write packet (deprecated)."),
14049 add_cmd ("remotewritesize", no_class
, show_memory_write_packet_size
, _("\
14050 Show the maximum number of bytes per memory write packet (deprecated)."),
14052 add_cmd ("memory-write-packet-size", no_class
,
14053 set_memory_write_packet_size
, _("\
14054 Set the maximum number of bytes per memory-write packet.\n\
14055 Specify the number of bytes in a packet or 0 (zero) for the\n\
14056 default packet size. The actual limit is further reduced\n\
14057 dependent on the target. Specify ``fixed'' to disable the\n\
14058 further restriction and ``limit'' to enable that restriction."),
14059 &remote_set_cmdlist
);
14060 add_cmd ("memory-read-packet-size", no_class
,
14061 set_memory_read_packet_size
, _("\
14062 Set the maximum number of bytes per memory-read packet.\n\
14063 Specify the number of bytes in a packet or 0 (zero) for the\n\
14064 default packet size. The actual limit is further reduced\n\
14065 dependent on the target. Specify ``fixed'' to disable the\n\
14066 further restriction and ``limit'' to enable that restriction."),
14067 &remote_set_cmdlist
);
14068 add_cmd ("memory-write-packet-size", no_class
,
14069 show_memory_write_packet_size
,
14070 _("Show the maximum number of bytes per memory-write packet."),
14071 &remote_show_cmdlist
);
14072 add_cmd ("memory-read-packet-size", no_class
,
14073 show_memory_read_packet_size
,
14074 _("Show the maximum number of bytes per memory-read packet."),
14075 &remote_show_cmdlist
);
14077 add_setshow_zinteger_cmd ("hardware-watchpoint-limit", no_class
,
14078 &remote_hw_watchpoint_limit
, _("\
14079 Set the maximum number of target hardware watchpoints."), _("\
14080 Show the maximum number of target hardware watchpoints."), _("\
14081 Specify a negative limit for unlimited."),
14082 NULL
, NULL
, /* FIXME: i18n: The maximum
14083 number of target hardware
14084 watchpoints is %s. */
14085 &remote_set_cmdlist
, &remote_show_cmdlist
);
14086 add_setshow_zinteger_cmd ("hardware-watchpoint-length-limit", no_class
,
14087 &remote_hw_watchpoint_length_limit
, _("\
14088 Set the maximum length (in bytes) of a target hardware watchpoint."), _("\
14089 Show the maximum length (in bytes) of a target hardware watchpoint."), _("\
14090 Specify a negative limit for unlimited."),
14091 NULL
, NULL
, /* FIXME: i18n: The maximum
14092 length (in bytes) of a target
14093 hardware watchpoint is %s. */
14094 &remote_set_cmdlist
, &remote_show_cmdlist
);
14095 add_setshow_zinteger_cmd ("hardware-breakpoint-limit", no_class
,
14096 &remote_hw_breakpoint_limit
, _("\
14097 Set the maximum number of target hardware breakpoints."), _("\
14098 Show the maximum number of target hardware breakpoints."), _("\
14099 Specify a negative limit for unlimited."),
14100 NULL
, NULL
, /* FIXME: i18n: The maximum
14101 number of target hardware
14102 breakpoints is %s. */
14103 &remote_set_cmdlist
, &remote_show_cmdlist
);
14105 add_setshow_zuinteger_cmd ("remoteaddresssize", class_obscure
,
14106 &remote_address_size
, _("\
14107 Set the maximum size of the address (in bits) in a memory packet."), _("\
14108 Show the maximum size of the address (in bits) in a memory packet."), NULL
,
14110 NULL
, /* FIXME: i18n: */
14111 &setlist
, &showlist
);
14113 init_all_packet_configs ();
14115 add_packet_config_cmd (&remote_protocol_packets
[PACKET_X
],
14116 "X", "binary-download", 1);
14118 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCont
],
14119 "vCont", "verbose-resume", 0);
14121 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QPassSignals
],
14122 "QPassSignals", "pass-signals", 0);
14124 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QCatchSyscalls
],
14125 "QCatchSyscalls", "catch-syscalls", 0);
14127 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QProgramSignals
],
14128 "QProgramSignals", "program-signals", 0);
14130 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartupWithShell
],
14131 "QStartupWithShell", "startup-with-shell", 0);
14133 add_packet_config_cmd (&remote_protocol_packets
14134 [PACKET_QEnvironmentHexEncoded
],
14135 "QEnvironmentHexEncoded", "environment-hex-encoded",
14138 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentReset
],
14139 "QEnvironmentReset", "environment-reset",
14142 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QEnvironmentUnset
],
14143 "QEnvironmentUnset", "environment-unset",
14146 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSymbol
],
14147 "qSymbol", "symbol-lookup", 0);
14149 add_packet_config_cmd (&remote_protocol_packets
[PACKET_P
],
14150 "P", "set-register", 1);
14152 add_packet_config_cmd (&remote_protocol_packets
[PACKET_p
],
14153 "p", "fetch-register", 1);
14155 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z0
],
14156 "Z0", "software-breakpoint", 0);
14158 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z1
],
14159 "Z1", "hardware-breakpoint", 0);
14161 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z2
],
14162 "Z2", "write-watchpoint", 0);
14164 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z3
],
14165 "Z3", "read-watchpoint", 0);
14167 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Z4
],
14168 "Z4", "access-watchpoint", 0);
14170 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_auxv
],
14171 "qXfer:auxv:read", "read-aux-vector", 0);
14173 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_exec_file
],
14174 "qXfer:exec-file:read", "pid-to-exec-file", 0);
14176 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_features
],
14177 "qXfer:features:read", "target-features", 0);
14179 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries
],
14180 "qXfer:libraries:read", "library-info", 0);
14182 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_libraries_svr4
],
14183 "qXfer:libraries-svr4:read", "library-info-svr4", 0);
14185 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_memory_map
],
14186 "qXfer:memory-map:read", "memory-map", 0);
14188 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_read
],
14189 "qXfer:spu:read", "read-spu-object", 0);
14191 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_spu_write
],
14192 "qXfer:spu:write", "write-spu-object", 0);
14194 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_osdata
],
14195 "qXfer:osdata:read", "osdata", 0);
14197 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_threads
],
14198 "qXfer:threads:read", "threads", 0);
14200 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_read
],
14201 "qXfer:siginfo:read", "read-siginfo-object", 0);
14203 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_siginfo_write
],
14204 "qXfer:siginfo:write", "write-siginfo-object", 0);
14206 add_packet_config_cmd
14207 (&remote_protocol_packets
[PACKET_qXfer_traceframe_info
],
14208 "qXfer:traceframe-info:read", "traceframe-info", 0);
14210 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_uib
],
14211 "qXfer:uib:read", "unwind-info-block", 0);
14213 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTLSAddr
],
14214 "qGetTLSAddr", "get-thread-local-storage-address",
14217 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qGetTIBAddr
],
14218 "qGetTIBAddr", "get-thread-information-block-address",
14221 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bc
],
14222 "bc", "reverse-continue", 0);
14224 add_packet_config_cmd (&remote_protocol_packets
[PACKET_bs
],
14225 "bs", "reverse-step", 0);
14227 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSupported
],
14228 "qSupported", "supported-packets", 0);
14230 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qSearch_memory
],
14231 "qSearch:memory", "search-memory", 0);
14233 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qTStatus
],
14234 "qTStatus", "trace-status", 0);
14236 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_setfs
],
14237 "vFile:setfs", "hostio-setfs", 0);
14239 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_open
],
14240 "vFile:open", "hostio-open", 0);
14242 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pread
],
14243 "vFile:pread", "hostio-pread", 0);
14245 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_pwrite
],
14246 "vFile:pwrite", "hostio-pwrite", 0);
14248 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_close
],
14249 "vFile:close", "hostio-close", 0);
14251 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_unlink
],
14252 "vFile:unlink", "hostio-unlink", 0);
14254 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_readlink
],
14255 "vFile:readlink", "hostio-readlink", 0);
14257 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vFile_fstat
],
14258 "vFile:fstat", "hostio-fstat", 0);
14260 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vAttach
],
14261 "vAttach", "attach", 0);
14263 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vRun
],
14266 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QStartNoAckMode
],
14267 "QStartNoAckMode", "noack", 0);
14269 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vKill
],
14270 "vKill", "kill", 0);
14272 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qAttached
],
14273 "qAttached", "query-attached", 0);
14275 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalTracepoints
],
14276 "ConditionalTracepoints",
14277 "conditional-tracepoints", 0);
14279 add_packet_config_cmd (&remote_protocol_packets
[PACKET_ConditionalBreakpoints
],
14280 "ConditionalBreakpoints",
14281 "conditional-breakpoints", 0);
14283 add_packet_config_cmd (&remote_protocol_packets
[PACKET_BreakpointCommands
],
14284 "BreakpointCommands",
14285 "breakpoint-commands", 0);
14287 add_packet_config_cmd (&remote_protocol_packets
[PACKET_FastTracepoints
],
14288 "FastTracepoints", "fast-tracepoints", 0);
14290 add_packet_config_cmd (&remote_protocol_packets
[PACKET_TracepointSource
],
14291 "TracepointSource", "TracepointSource", 0);
14293 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAllow
],
14294 "QAllow", "allow", 0);
14296 add_packet_config_cmd (&remote_protocol_packets
[PACKET_StaticTracepoints
],
14297 "StaticTracepoints", "static-tracepoints", 0);
14299 add_packet_config_cmd (&remote_protocol_packets
[PACKET_InstallInTrace
],
14300 "InstallInTrace", "install-in-trace", 0);
14302 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_statictrace_read
],
14303 "qXfer:statictrace:read", "read-sdata-object", 0);
14305 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_fdpic
],
14306 "qXfer:fdpic:read", "read-fdpic-loadmap", 0);
14308 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QDisableRandomization
],
14309 "QDisableRandomization", "disable-randomization", 0);
14311 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QAgent
],
14312 "QAgent", "agent", 0);
14314 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QTBuffer_size
],
14315 "QTBuffer:size", "trace-buffer-size", 0);
14317 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_off
],
14318 "Qbtrace:off", "disable-btrace", 0);
14320 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_bts
],
14321 "Qbtrace:bts", "enable-btrace-bts", 0);
14323 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_pt
],
14324 "Qbtrace:pt", "enable-btrace-pt", 0);
14326 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace
],
14327 "qXfer:btrace", "read-btrace", 0);
14329 add_packet_config_cmd (&remote_protocol_packets
[PACKET_qXfer_btrace_conf
],
14330 "qXfer:btrace-conf", "read-btrace-conf", 0);
14332 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_bts_size
],
14333 "Qbtrace-conf:bts:size", "btrace-conf-bts-size", 0);
14335 add_packet_config_cmd (&remote_protocol_packets
[PACKET_multiprocess_feature
],
14336 "multiprocess-feature", "multiprocess-feature", 0);
14338 add_packet_config_cmd (&remote_protocol_packets
[PACKET_swbreak_feature
],
14339 "swbreak-feature", "swbreak-feature", 0);
14341 add_packet_config_cmd (&remote_protocol_packets
[PACKET_hwbreak_feature
],
14342 "hwbreak-feature", "hwbreak-feature", 0);
14344 add_packet_config_cmd (&remote_protocol_packets
[PACKET_fork_event_feature
],
14345 "fork-event-feature", "fork-event-feature", 0);
14347 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vfork_event_feature
],
14348 "vfork-event-feature", "vfork-event-feature", 0);
14350 add_packet_config_cmd (&remote_protocol_packets
[PACKET_Qbtrace_conf_pt_size
],
14351 "Qbtrace-conf:pt:size", "btrace-conf-pt-size", 0);
14353 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vContSupported
],
14354 "vContSupported", "verbose-resume-supported", 0);
14356 add_packet_config_cmd (&remote_protocol_packets
[PACKET_exec_event_feature
],
14357 "exec-event-feature", "exec-event-feature", 0);
14359 add_packet_config_cmd (&remote_protocol_packets
[PACKET_vCtrlC
],
14360 "vCtrlC", "ctrl-c", 0);
14362 add_packet_config_cmd (&remote_protocol_packets
[PACKET_QThreadEvents
],
14363 "QThreadEvents", "thread-events", 0);
14365 add_packet_config_cmd (&remote_protocol_packets
[PACKET_no_resumed
],
14366 "N stop reply", "no-resumed-stop-reply", 0);
14368 /* Assert that we've registered "set remote foo-packet" commands
14369 for all packet configs. */
14373 for (i
= 0; i
< PACKET_MAX
; i
++)
14375 /* Ideally all configs would have a command associated. Some
14376 still don't though. */
14381 case PACKET_QNonStop
:
14382 case PACKET_EnableDisableTracepoints_feature
:
14383 case PACKET_tracenz_feature
:
14384 case PACKET_DisconnectedTracing_feature
:
14385 case PACKET_augmented_libraries_svr4_read_feature
:
14387 /* Additions to this list need to be well justified:
14388 pre-existing packets are OK; new packets are not. */
14396 /* This catches both forgetting to add a config command, and
14397 forgetting to remove a packet from the exception list. */
14398 gdb_assert (excepted
== (remote_protocol_packets
[i
].name
== NULL
));
14402 /* Keep the old ``set remote Z-packet ...'' working. Each individual
14403 Z sub-packet has its own set and show commands, but users may
14404 have sets to this variable in their .gdbinit files (or in their
14406 add_setshow_auto_boolean_cmd ("Z-packet", class_obscure
,
14407 &remote_Z_packet_detect
, _("\
14408 Set use of remote protocol `Z' packets"), _("\
14409 Show use of remote protocol `Z' packets "), _("\
14410 When set, GDB will attempt to use the remote breakpoint and watchpoint\n\
14412 set_remote_protocol_Z_packet_cmd
,
14413 show_remote_protocol_Z_packet_cmd
,
14414 /* FIXME: i18n: Use of remote protocol
14415 `Z' packets is %s. */
14416 &remote_set_cmdlist
, &remote_show_cmdlist
);
14418 add_prefix_cmd ("remote", class_files
, remote_command
, _("\
14419 Manipulate files on the remote system\n\
14420 Transfer files to and from the remote target system."),
14421 &remote_cmdlist
, "remote ",
14422 0 /* allow-unknown */, &cmdlist
);
14424 add_cmd ("put", class_files
, remote_put_command
,
14425 _("Copy a local file to the remote system."),
14428 add_cmd ("get", class_files
, remote_get_command
,
14429 _("Copy a remote file to the local system."),
14432 add_cmd ("delete", class_files
, remote_delete_command
,
14433 _("Delete a remote file."),
14436 add_setshow_string_noescape_cmd ("exec-file", class_files
,
14437 &remote_exec_file_var
, _("\
14438 Set the remote pathname for \"run\""), _("\
14439 Show the remote pathname for \"run\""), NULL
,
14440 set_remote_exec_file
,
14441 show_remote_exec_file
,
14442 &remote_set_cmdlist
,
14443 &remote_show_cmdlist
);
14445 add_setshow_boolean_cmd ("range-stepping", class_run
,
14446 &use_range_stepping
, _("\
14447 Enable or disable range stepping."), _("\
14448 Show whether target-assisted range stepping is enabled."), _("\
14449 If on, and the target supports it, when stepping a source line, GDB\n\
14450 tells the target to step the corresponding range of addresses itself instead\n\
14451 of issuing multiple single-steps. This speeds up source level\n\
14452 stepping. If off, GDB always issues single-steps, even if range\n\
14453 stepping is supported by the target. The default is on."),
14454 set_range_stepping
,
14455 show_range_stepping
,
14459 /* Eventually initialize fileio. See fileio.c */
14460 initialize_remote_fileio (remote_set_cmdlist
, remote_show_cmdlist
);
14462 /* Take advantage of the fact that the TID field is not used, to tag
14463 special ptids with it set to != 0. */
14464 magic_null_ptid
= ptid_build (42000, -1, 1);
14465 not_sent_ptid
= ptid_build (42000, -2, 1);
14466 any_thread_ptid
= ptid_build (42000, 0, 1);
14468 target_buf_size
= 2048;
14469 target_buf
= (char *) xmalloc (target_buf_size
);